diff --git a/_site/staticwebapp.config.json b/_site/staticwebapp.config.json
deleted file mode 100644
index 56b596620..000000000
--- a/_site/staticwebapp.config.json
+++ /dev/null
@@ -1 +0,0 @@
-{"routes":[{"route":"/","redirect":"/en/","statusCode":301},{"route":"/index.html","redirect":"/en/","statusCode":301},{"route":"/en/references/release-notes","redirect":"/en/references/release-notes/3_26_0.html","statusCode":302},{"route":"/en/te3/other/release-notes","redirect":"/en/references/release-notes/3_26_0.html","statusCode":302},{"route":"/es/references/release-notes","redirect":"/es/references/release-notes/3_26_0.html","statusCode":302},{"route":"/es/te3/other/release-notes","redirect":"/es/references/release-notes/3_26_0.html","statusCode":302},{"route":"/zh/references/release-notes","redirect":"/zh/references/release-notes/3_26_0.html","statusCode":302},{"route":"/zh/te3/other/release-notes","redirect":"/zh/references/release-notes/3_26_0.html","statusCode":302},{"route":"/references/release-notes","redirect":"/en/references/release-notes/3_26_0.html","statusCode":302},{"route":"/Advanced-Scripting.html","redirect":"/en/how-tos/Advanced-Scripting.html","statusCode":301},{"route":"/Best-Practice-Analyzer.html","redirect":"/en/features/Best-Practice-Analyzer.html","statusCode":301},{"route":"/Command-line-Options.html","redirect":"/en/features/Command-line-Options.html","statusCode":301},{"route":"/Custom-Actions.html","redirect":"/en/tutorials/creating-macros.html","statusCode":301},{"route":"/FormatDax.html","redirect":"/en/references/FormatDax.html","statusCode":301},{"route":"/Importing-Tables.html","redirect":"/en/how-tos/Importing-Tables.html","statusCode":301},{"route":"/Power-BI-Desktop-Integration.html","redirect":"/en/getting-started/Power-BI-Desktop-Integration.html","statusCode":301},{"route":"/Useful-script-snippets.html","redirect":"/en/features/Useful-script-snippets.html","statusCode":301},{"route":"/Workspace-Database.html","redirect":"/en/tutorials/workspace-mode.html","statusCode":301},{"route":"/common/Datasets/direct-lake-dataset.html","redirect":"/en/features/Semantic-Model/direct-lake-sql-model.html","statusCode":301},{"route":"/eula","redirect":"/en/security/te3-eula.html","statusCode":301},{"route":"/onboarding/general-introduction.html","redirect":"/en/getting-started/general-introduction.html","statusCode":301},{"route":"/onboarding/index.html","redirect":"/en/getting-started/index.html","statusCode":301},{"route":"/onboarding/installation.html","redirect":"/en/getting-started/installation.html","statusCode":301},{"route":"/other/downloads.html","redirect":"/en/references/downloads.html","statusCode":301},{"route":"/privacy-policy.html","redirect":"/en/security/privacy-policy.html","statusCode":301},{"route":"/projects/te3","redirect":"/en/","statusCode":301},{"route":"/projects/te3/en/latest","redirect":"/en/","statusCode":301},{"route":"/projects/te3/en/latest/downloads.html","redirect":"/en/references/downloads.html","statusCode":301},{"route":"/projects/te3/en/latest/editions.html","redirect":"/en/getting-started/editions.html","statusCode":301},{"route":"/projects/te3/en/latest/getting-started.html","redirect":"/en/getting-started/getting-started.html","statusCode":301},{"route":"/projects/te3/en/latest/security-privacy.html","redirect":"/en/security/security-privacy.html","statusCode":301},{"route":"/roslyn","redirect":"/en/how-tos/Advanced-Scripting.html#compiling-with-roslyn","statusCode":301},{"route":"/te2/Advanced-Scripting.html","redirect":"/en/how-tos/Advanced-Scripting.html","statusCode":301},{"route":"/te2/Best-Practice-Analyzer.html","redirect":"/en/features/Best-Practice-Analyzer.html","statusCode":301},{"route":"/te2/Getting-Started.html","redirect":"/en/getting-started/Getting-Started-te2.html","statusCode":301},{"route":"/te2/Importing-Tables.html","redirect":"/en/how-tos/Importing-Tables.html","statusCode":301},{"route":"/te2/Power-BI-Desktop-Integration.html","redirect":"/en/getting-started/Power-BI-Desktop-Integration.html","statusCode":301},{"route":"/te2/Useful-script-snippets.html","redirect":"/en/features/Useful-script-snippets.html","statusCode":301},{"route":"/te3/downloads.html","redirect":"/en/references/downloads.html","statusCode":301},{"route":"/te3/editions.html","redirect":"/en/getting-started/editions.html","statusCode":301},{"route":"/te3/features/csharp-scripts.html","redirect":"/en/features/csharp-scripts.html","statusCode":301},{"route":"/te3/features/dax-debugger.html","redirect":"/en/features/dax-debugger.html","statusCode":301},{"route":"/te3/features/dax-editor.html","redirect":"/en/features/dax-editor.html","statusCode":301},{"route":"/te3/features/dax-scripts.html","redirect":"/en/features/dax-scripts.html","statusCode":301},{"route":"/te3/features/tmdl.html","redirect":"/en/features/tmdl.html","statusCode":301},{"route":"/te3/getting-started.html","redirect":"/en/getting-started/getting-started.html","statusCode":301},{"route":"/te3/index.html","redirect":"/en/troubleshooting/licensing-activation.html","statusCode":301},{"route":"/te3/logo.svg","redirect":"/en/logo.svg","statusCode":301},{"route":"/te3/other/downloads.html","redirect":"/en/references/downloads.html","statusCode":301},{"route":"/te3/other/release-history.html","redirect":"/en/references/release-history.html","statusCode":301},{"route":"/te3/tutorials/workspace-mode.html","redirect":"/en/tutorials/workspace-mode.html","statusCode":301},{"route":"/tmdl","redirect":"/en/features/tmdl.html","statusCode":301},{"route":"/tmuo","redirect":"/en/references/user-options.html","statusCode":301},{"route":"/user-options.html","redirect":"/en/references/user-options.html","statusCode":301},{"route":"/workspace","redirect":"/en/tutorials/workspace-mode.html","statusCode":301}],"responseOverrides":{"404":{"rewrite":"/404.html"}}}
\ No newline at end of file
diff --git a/build-docs.py b/build-docs.py
index 30122c206..91920d985 100644
--- a/build-docs.py
+++ b/build-docs.py
@@ -18,6 +18,10 @@
     --serve         Build and serve locally (English only, for development)
     --skip-gen      Skip running gen_redirects.py (use existing configs)
     --no-api-copy   Skip copying API docs to localized sites
+    --skip-api      Reuse existing content/api instead of regenerating API metadata
+                    (~30-40% faster). LOCAL markdown iteration ONLY, with --serve/--lang;
+                    never for testing, CI/CD, or release builds.
+    --permissive    Don't fail the English build on DocFX warnings (local iteration)
 """
 
 import argparse
@@ -81,6 +85,62 @@ def run_command(cmd: list[str], description: str, check: bool = True, fail_on_wa
     return result.returncode
 
 
+DOCFX: list[str] = []          # cache; populated on first ensure_docfx()
+
+
+def _local_docfx_available() -> bool:
+    """True if a dotnet tool manifest in cwd or an ancestor declares docfx.
+
+    Mirrors dotnet's manifest discovery (cwd upward, `.config/` or legacy path,
+    stop at an isRoot manifest). Filesystem-only — does not verify the tool is
+    restored; a missing restore surfaces as a clear `dotnet docfx` error at build time.
+    """
+    for d in (Path.cwd(), *Path.cwd().parents):
+        manifest = next((m for m in (d / ".config" / "dotnet-tools.json",
+                                      d / "dotnet-tools.json") if m.is_file()), None)
+        if manifest is None:
+            continue
+        try:
+            data = json.loads(manifest.read_text(encoding="utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+        if "docfx" in {k.lower() for k in data.get("tools", {})}:
+            return True
+        if data.get("isRoot"):
+            break  # root manifest without docfx: dotnet stops searching here too
+    return False
+
+
+def resolve_docfx() -> list[str]:
+    """Resolve how to invoke docfx: $DOCFX override, then a repo-pinned local tool
+    (`dotnet docfx`), then a global/PATH `docfx`. Raises if none is available."""
+    override = os.environ.get("DOCFX")
+    if override:
+        return override.split()
+    if shutil.which("dotnet") and _local_docfx_available():
+        return ["dotnet", "docfx"]
+    if shutil.which("docfx"):
+        return ["docfx"]
+    raise SystemExit(
+        "Error: docfx not found.\n"
+        "  Local:  dotnet tool install docfx   (then `dotnet tool restore`)\n"
+        "  Global: dotnet tool install -g docfx"
+    )
+
+
+def ensure_docfx() -> list[str]:
+    """Return the docfx invocation prefix, resolving (and caching) it on first use."""
+    global DOCFX
+    if not DOCFX:
+        DOCFX = resolve_docfx()
+    return DOCFX
+
+
+def run_docfx(args: list[str], description: str, **kwargs) -> int:
+    """Run docfx with the resolved invocation prefix (global/PATH or `dotnet docfx`)."""
+    return run_command([*ensure_docfx(), *args], description, **kwargs)
+
+
 def get_available_languages() -> list[str]:
     """Get list of available languages from metadata/languages.json or scan localizedContent/."""
     manifest_path = Path("metadata/languages.json")
@@ -151,7 +211,7 @@ def prepare_localized_content(lang: str, sync: bool = False) -> int:
     )
 
 
-def build_language(lang: str, sync: bool = False) -> int:
+def build_language(lang: str, sync: bool = False, skip_api: bool = False, permissive: bool = False) -> int:
     """Build documentation for a specific language."""
     config_path = f"localizedContent/{lang}/docfx.json"
 
@@ -164,14 +224,20 @@ def build_language(lang: str, sync: bool = False) -> int:
     result = prepare_localized_content(lang, sync=sync)
     if result != 0:
         return result
-    
+
     # Build the documentation — fail on DocFX warnings only for English (the
     # authored source). Localized content is Crowdin-managed and may carry
-    # translation warnings that must not block deployment.
-    return run_command(
-        ["docfx", config_path],
+    # translation warnings that must not block deployment. `permissive` lifts the
+    # English gate too, for local iteration where transient warnings are expected
+    # (warnings are still printed, just not fatal); full/CI builds leave it off.
+    #
+    # `docfx build` skips API metadata regeneration and reuses the existing
+    # content/api/*.yml (the _apiSource DLLs don't change between content edits),
+    # which is ~30-40% faster; bare `docfx` regenerates metadata then builds.
+    return run_docfx(
+        [*(["build"] if skip_api else []), config_path],
         f"Building {lang} documentation",
-        fail_on_warnings=(lang == "en")
+        fail_on_warnings=(lang == "en" and not permissive)
     )
 
 
@@ -279,7 +345,9 @@ def main() -> int:
     parser.add_argument("--list", action="store_true", help="List available languages")
     parser.add_argument("--serve", action="store_true", help="Build English and serve locally")
     parser.add_argument("--skip-gen", action="store_true", help="Skip gen_redirects.py")
-    parser.add_argument("--no-api-copy", action="store_true", help="Skip copying API docs")
+    parser.add_argument("--no-api-copy", action="store_true", help="Skip copying API docs to localized sites")
+    parser.add_argument("--skip-api", action="store_true", help="LOCAL markdown iteration only (requires --serve/--lang): reuse existing content/api, ~30-40%% faster. NEVER for testing/CI/CD/releases")
+    parser.add_argument("--permissive", action="store_true", help="Don't treat English DocFX warnings as build failures (for local iteration; keep full/CI builds strict)")
     parser.add_argument("--sync", action="store_true", help="Sync English fallback for missing/outdated translations (for local dev)")
     
     args = parser.parse_args()
@@ -292,7 +360,39 @@ def main() -> int:
             suffix = " (default)" if lang == "en" else ""
             print(f"  {lang}{suffix}")
         return 0
-    
+
+    # Resolve docfx now so a missing install exits before any build work happens.
+    ensure_docfx()
+
+    # --skip-api is strictly a fast LOCAL iteration aid for editing markdown: it reuses
+    # the existing content/api/*.yml instead of regenerating API metadata. It must NEVER
+    # be used for full builds, testing, CI/CD, or releases (those must regenerate the API).
+    # Guard it conservatively: require an explicit single-target (--serve or --lang),
+    # forbid --all / the default all-languages build, and require API metadata to already
+    # exist so we never silently ship a site with missing or stale API docs.
+    if args.skip_api:
+        if args.all or not (args.serve or args.lang):
+            print(
+                "Error: --skip-api is for fast LOCAL iteration only and must target a single build.\n"
+                "       Use it with --serve or --lang (e.g. `--serve --skip-api`, `--lang en --skip-api`).\n"
+                "       Never use it for --all, testing, CI/CD, or release builds — omit it so API\n"
+                "       metadata is regenerated.",
+                file=sys.stderr,
+            )
+            return 1
+        if not list(Path("content/api").glob("*.yml")):
+            print(
+                "Error: --skip-api reuses existing API metadata, but content/api/*.yml is missing.\n"
+                "       Run a full build once (e.g. `python3 build-docs.py --lang en`) to generate it.",
+                file=sys.stderr,
+            )
+            return 1
+        print("\n" + "=" * 60)
+        print("  WARNING: --skip-api active — reusing existing content/api/*.yml.")
+        print("  Fast LOCAL markdown iteration ONLY; API docs may be stale.")
+        print("  NEVER use --skip-api for testing, CI/CD, or release builds.")
+        print("=" * 60)
+
     # Run gen_redirects.py first (unless skipped)
     if not args.skip_gen:
         result = run_command(
@@ -315,7 +415,7 @@ def main() -> int:
     
     if args.serve:
         # Build English only and serve
-        result = build_language("en", sync=True)
+        result = build_language("en", sync=True, skip_api=args.skip_api, permissive=args.permissive)
         if result != 0:
             return result
         
@@ -329,8 +429,8 @@ def main() -> int:
             shutil.copy(manifest_src, manifest_dest)
             print("Copied languages.json to _site/en/")
         
-        return run_command(
-            ["docfx", "serve", "_site/en"],
+        return run_docfx(
+            ["serve", "_site/en"],
             "Serving documentation locally"
         )
     
@@ -354,7 +454,7 @@ def main() -> int:
     
     # Build all requested languages
     for lang in build_langs:
-        result = build_language(lang, sync=args.sync)
+        result = build_language(lang, sync=args.sync, skip_api=args.skip_api, permissive=args.permissive)
         if result != 0:
             return result
         
diff --git a/build_scripts/README.md b/build_scripts/README.md
new file mode 100644
index 000000000..bd0a01370
--- /dev/null
+++ b/build_scripts/README.md
@@ -0,0 +1,238 @@
+# Build tools
+
+This document covers new build tools:
+- `te_script_runner.py`: standalone runner and module for other tools that need to execute C# scripts
+- `csharp_doctest.py`: compiles and runs annotated `csharp` code blocks in markdown files
+- `check_links.py`: dead link checker for built site
+
+Existing docfx and localization orchestration can be found in [../README.md](../README.md)
+
+## Prerequisites
+
+Required on PATH:
+
+- `python3` -- 3.10+ (the scripts use 3.10 syntax; validated on 3.14).
+- `uv` -- provides `uvx`, for lint and type-check.
+- `te` -- the Tabular Editor CLI, for the doc-validation scripts; you should use a build aligned with TE3 release for checking docs.
+- `docfx` -- or `dotnet` with the pinned local docfx tool, to build the site.
+
+Run all scripts from the docs repo root;
+paths like `_site` and `content/` resolve relative to the current directory.
+
+## Contributing and development notes
+
+Scripts have no build phase.
+All Python build scripts are linted and type-checked:
+
+```shell
+$ uvx ruff check --select F,B,SIM,I,UP  <python_sources>
+$ uvx mypy --strict  <python_sources>
+```
+
+Scripts named herein are all built with a functional core, imperative shell style.
+Build small components that deal in pure data, orchestrate these with command dispatch.
+Expose useful functions in the command dispatch for testing and future ad-hoc use cases.
+
+## Doc validation
+
+### Code block validation and output generation
+
+`te_script_runner.py` and `csharp_doctest.py` contribute to validating code blocks in docs.
+Both need `te` on PATH.
+
+Current state only validates semantic bridge docs.
+The code block annotations can be used in any doc.
+
+#### `te_script_runner.py` -- generic runner
+
+Runs (or compile-checks) C# snippets against a throwaway, empty `.bim` model.
+Output:
+- stdout: the snippets' `Output()` only (te messages at level `output`), newline-joined
+- stderr: te's own stderr stream (always passed through), plus the runner's diagnostics parsed from te's JSON -- `[compile-error]`, `[runtime-error]`, and `[<level>]` for other non-output messages
+
+```shell
+$ python3 build_scripts/te_script_runner.py run   -e '<expr>'    # execute (also -f <file>, or stdin)
+$ python3 build_scripts/te_script_runner.py check -e '<expr>'    # compile only (te --dry-run)
+$ python3 build_scripts/te_script_runner.py run -e '<expr1>' -f <file1> -e '<expr2>' # execute multiple scripts in order; also works for `check`
+```
+
+Operation:
+1. Creates a new temporary directory
+2. Inits a new empty model in that directory
+3. Creates files for all scripts in temp directory (this is necessary to enforce strict ordering)
+4. Executes all scripts in order with `te` binary; 1 execution of `te`, no `--save`, so all script results are transient
+5. Cleans up temp directory
+
+Additional sub-commands for testing, validation, and ad-hoc use cases:
+
+- `python3 build_scripts/te_script_runner.py init`: set up the temp directory and model, returning the path; does not automatically clean up: that's your responsibility if you use this
+- `python3 build_scripts/te_script_runner.py summarize`: parses and creates output based on `te`'s output
+
+Importable in other Python scripts: `run_snippets(snippets, dry_run=..., last_only=...) -> Result`.
+`last_only` reports only the final snippet's `Output()`, rather than all snippets outputs.
+
+#### `csharp_doctest.py` -- doc orchestrator
+
+Checks annotated C# fences in a markdown file.
+The annotation is invisible in rendered docfx output:
+
+```
+    ```csharp {compile}
+    ```csharp {run id=<slug> setup=<mv-sample|none> after=<id,...|none> output=<true|false>}
+```
+
+Commands (each validates first and bails on a malformed doc):
+
+```shell
+$ python3 build_scripts/csharp_doctest.py validate <file.md>   # check annotation grammar + coverage counts, no CLI calls
+$ python3 build_scripts/csharp_doctest.py compile  <file.md>   # compile every {compile}/{run} block
+$ python3 build_scripts/csharp_doctest.py compare  <file.md>   # diff each {run} Output() against its fence
+$ python3 build_scripts/csharp_doctest.py update   <file.md>   # run {run} blocks, rewrite output blocks in place
+```
+
+Dealing with C# code blocks in a markdown doc:
+
+- code block without `csharp` in fence: skipped, but an annotation on such a block is a validation error
+- code block with `csharp` and no annotation: skip
+- `{compile}`: compile-check only (catches API drift; never executes)
+- `{run ...}`: will execute the code block with `te` binary
+  - `id=<name>`: unique name for this block in the document
+  - `setup=<known setup>`: prepends a preamble (see `SETUP_SCRIPTS`, e.g. the sample Metric View); must be registered in the script before it can be used
+  - `output=<true|false>`: if true, then this code block must be followed by literal `**Output**` on its own line, followed by a fenced code block; will check or update the output to what the script generates
+  - `after=<name>`: replays earlier run blocks for their state only (not their output); for docs where many code blocks are provided and expected to be run in sequence
+
+The grammar for these `run` blocks is explicit:
+every option must be provided in every block.
+
+Exit codes:
+- `0`: all blocks in the doc pass
+- `1`: a block failed (output mismatch, compile error, runtime error)
+- `2`: malformed doc or bad usage (validate bails before any CLI calls).
+
+Output (note: the opposite split from `te_script_runner.py` -- here the whole report, errors included, is on stdout):
+- stdout: the full report -- per-block verdicts, diffs, and compile/runtime error detail
+- stderr: te's own stderr (passed through) and harness/operational errors (bad usage, unreadable file)
+
+Sweep all docs with annotated code blocks for valid annotations, bailing on first error:
+
+```shell
+$ (set -eu; rg '```csharp \{' --glob content/**/*.md --files-with-matches | while read f; do python3 build_scripts/csharp_doctest.py validate $f; done)
+```
+
+Substitute `compile`, `compare`, or `update` for `validate` in above to run in the same way (bailing on first error).
+
+This orchestrator uses a thread pool with a thread per code block.
+Each invocation of `te` as a sub-process takes ~1-2s,
+so parallelizing nets a significant performance gain.
+
+#### Test fixtures (`test-fixtures/`)
+
+Small, self-contained inputs that exercise each code path:
+a manual regression corpus you run by hand (there are no unit tests).
+Run a command against a fixture and eyeball the result.
+
+Markdown fixtures drive `csharp_doctest.py`:
+- `doc-valid.md`: one of every block kind (skip / `{compile}` / `{run}`); everything passes.
+- `doc-mismatch.md`: a `{run}` whose `Output()` differs from its fence, so `compare` fails (and `update` would rewrite it; don't call update and commit, instead revert if you do update).
+- `doc-compile-drift.md`: a `{run}` calling a nonexistent API, so `compile` fails.
+- `err-*.md`: each holds exactly one grammar error (missing option, no output fence, annotation on a non-csharp fence, unknown `after=`, unknown annotation), so `validate` bails.
+
+`te-*.json` are canned `te --output-format json` outputs that drive `te_script_runner.py summarize` (its pure parser, no `te` needed):
+the executed-run and `--dry-run` schemas, each in a success and a failure (compile / runtime) variant.
+
+```shell
+$ python3 build_scripts/csharp_doctest.py validate test-fixtures/doc-valid.md          # passes
+$ python3 build_scripts/csharp_doctest.py compare  test-fixtures/doc-mismatch.md       # fails with a diff (nonzero exit)
+$ python3 build_scripts/csharp_doctest.py compile  test-fixtures/doc-compile-drift.md  # fails on the drifted API
+$ python3 build_scripts/csharp_doctest.py validate test-fixtures/err-unknown-after.md  # bails with the grammar error
+$ python3 build_scripts/te_script_runner.py summarize test-fixtures/te-runtime-error.json
+```
+
+### Link validation
+
+`check_links.py` validates all links (`href`/`src`) in the built `_site`.
+It walks the generated HTML,
+resolves each reference to a local file or an external URL,
+visits every unique target once, and reports references to broken targets.
+
+Build the docs site first with `python3 build-docs.py --lang en` or `python3 build-docs.py --all`.
+
+```shell
+$ python3 build_scripts/check_links.py validate                  # check _site: authored content, on-disk + external; requires built _site/
+$ python3 build_scripts/check_links.py validate stats            # add per-host external-fetch diagnostics
+$ python3 build_scripts/check_links.py validate local            # on-disk checks only, skip external fetching
+$ python3 build_scripts/check_links.py validate _site under=en   # only check links from pages under _site/en
+$ python3 build_scripts/check_links.py validate all              # also include generated API and localized pages; noisy, likely unnecessary; requires build with `--all`
+```
+
+Broken link checks:
+- local links (to something defined in this docs repo): the target file must exist
+  - detect old root links (e.g. `<a href="/Advanced-Scripting" ...>`) and resolve against the live docs site to check redirects; a dead one is an error, not a warning
+- external links (to something not defined in this docs repo): must return a 2xx/3xx status; a bad status (e.g. 404) or a transport error (DNS, TLS/certificate, timeout, refused connection) fails
+- fragments: ensure the `#anchor` is defined in the body of the target page (local file or fetched external page)
+- text links: ensure the literal `:~:text=` string is in the body of the target page (local file or fetched external page)
+
+Internal failures are errors (nonzero exit):
+own-site links, i.e. local files and root-absolute links (the latter checked over HTTP).
+External failures are warnings (network issues may be transient, or the target blocks bots),
+listed at the end as URLs to verify by hand, each with two counts:
+how many docs reference it and how many total times it appears.
+Fragment/text failures keep their `#anchor` / `:~:text=` in that list (the bare URL works;
+the fragment is what broke); a wholly unreachable URL is listed bare.
+
+Exit codes: `1` if any internal (own-site) reference is broken, else `0`. External warnings never fail the run, so third-party link rot will not break CI.
+
+Options to modify output:
+
+- `local`: skip external URL fetching (on-disk checks only)
+- `all`: include generated API and localized pages (default: authored `content/*.md` only)
+- `stats`: print per-host external-fetch diagnostics
+- `under=<subpath>`: only check links from pages under `<root>/<subpath>`
+
+Every built HTML page under `_site` is walked (to index fragment anchors and collect links site-wide).
+But by default only *failures on authored English content* are reported:
+pages under `_site/en/` that map back to `content/*.md`,
+excluding generated API reference (`en/api/`).
+The other-language pages are near-duplicate translations,
+so they and the generated API are hidden unless you pass `all` (which floods the report with those duplicates).
+
+`extract`, `resolve`, `enumerate`, and `fetch` expose the internal stages for testing.
+
+This script uses a rudimentary scheduler to avoid flooding a single host and getting a 429 storm.
+We distribute work across a thread pool and the scheduler interleaves requests to different hosts.
+There is a per-host maximum for in-flight requests,
+and a per-host cooldown when we encounter 429s,
+to avoid slamming a host that has already told us to back off.
+On a 429 we honor `Retry-After` (otherwise exponential backoff: 1, 2, 4, ... seconds)
+and also decrement that host's in-flight cap as ongoing backpressure;
+after a per-URL retry limit we give up and record the last result.
+
+Reachability uses a `HEAD` request;
+a body-downloading `GET` runs only when a fragment or `:~:text=` directive must be verified,
+so it never pulls installers or images just to check a link.
+A failed `HEAD` falls back to `GET` (some hosts reject `HEAD`),
+and known HEAD-hostile hosts skip straight to `GET`.
+
+#### Reading the `stats` table
+
+`stats` prints one row per host, worst-first. Columns:
+
+- `total`: external URLs seen for the host
+- `ok`: reachable, and any `#anchor` / `:~:text=` check passed; `total == ok` means all links to this domain were good
+- `frag`: reachable (url+path), but a fragment or text check failed
+- `bad`: unreachable, total (`= 401 + 403 + 404 + oth + net`)
+- `reqs`: fetch attempts, including retries; `total == reqs` means everything succeeded on first fetch
+- `429`: rate-limited responses seen
+- `401` / `403` / `404`: per-host counts of those statuses
+- `oth`: other failing HTTP (5xx, and 4xx that is not 401/403/404)
+- `net`: non-HTTP failures (DNS, TLS, timeout, connection reset)
+- `wait(s)`: total cooldown time applied to the host (rate limiting on our side for 429s)
+- `fb`: HEAD requests that fell back to GET (candidates for the GET-only list)
+- `cap`: ending in-flight cap (below the start value means it was throttled down)
+
+#### Interactive control (long runs)
+
+A full external run takes minutes; the terminal can query or stop it:
+
+- Status line (phase, counts, in-flight, cooling hosts) on **Ctrl-T** (macOS/BSD `SIGINFO`), **Ctrl-\\** (`SIGQUIT`, Linux/macOS), or **Ctrl-Break** (Windows `SIGBREAK`).
+- **Ctrl-C** stops cleanly and prints a partial report over what was fetched; a second **Ctrl-C** force-quits.
diff --git a/build_scripts/check_links.py b/build_scripts/check_links.py
new file mode 100644
index 000000000..78ac8c717
--- /dev/null
+++ b/build_scripts/check_links.py
@@ -0,0 +1,944 @@
+#!/usr/bin/env python3
+"""
+Standalone dead-link checker for the generated `_site`.
+
+Walks the built HTML, resolves every href/src to a local file or an external
+URL, visits each unique target once, and reports references to broken targets
+(missing files, missing fragments). Local failures are errors (nonzero exit);
+external failures are warnings (network issues are often transient or the
+target blocks bots), emitted as a copy-paste list of URLs to verify by hand.
+
+The functional core (extract, resolve, validate) is pure; the imperative shell
+does filesystem, HTTP, and reporting.
+"""
+
+import http.client
+import os
+import signal
+import sys
+import urllib.error
+import urllib.request
+from collections import Counter, defaultdict, deque
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from html.parser import HTMLParser
+from pathlib import Path
+from queue import Empty, Queue
+from threading import Event, Thread
+from time import monotonic
+from types import FrameType
+from typing import Any, NamedTuple
+from urllib.parse import unquote, urldefrag, urlsplit
+
+import config_loader
+
+# Interactive control: a shared progress view that `main` reads for a Ctrl-T status line, and a stop flag it sets on
+# Ctrl-C so the running command can wind down and still emit a partial report. Commands populate the view as they go.
+
+_STOP_POLL = 1.0  # max seconds the fetch scheduler blocks between stop-flag checks, so Ctrl-C stays responsive
+
+# Terminal keys that print a status line, by platform: Ctrl-T (BSD/macOS), Ctrl-\ (POSIX; overrides the quit/core
+# dump), Ctrl-Break (Windows). We bind whichever the platform defines, so a status key exists everywhere.
+_STATUS_SIGNALS = ("SIGINFO", "SIGQUIT", "SIGBREAK")
+
+_SignalHandler = Callable[[int, FrameType | None], None]
+
+
+@dataclass
+class _Progress:
+    """Live counters for the running command. `main` reads them for the status signal and sets `stop` on Ctrl-C;
+    commands advance the phase, bump the counters, and check `stop` to bail out early for a partial report."""
+
+    phase: str = "starting"
+    pages: int = 0  # built HTML pages scanned (enumerate phase)
+    links: int = 0  # link references seen while scanning
+    targets: int = 0  # unique targets discovered to check
+    urls_total: int = 0  # external URLs queued to fetch
+    urls_done: int = 0  # external URLs fetched so far
+    dispatched: int = 0  # URLs handed to the queue but not yet resolved (>= the few workers actively fetching)
+    workers: int = 0  # size of the fetch worker pool
+    cooling: dict[str, float] = field(default_factory=dict)  # host -> monotonic deadline it is eligible again
+    started: float = 0.0  # monotonic start time, for elapsed
+    stop: Event = field(default_factory=Event)
+
+
+def _status_line(progress: _Progress, now: float) -> str:
+    """A one-line snapshot of our own work for the Ctrl-T status signal (about the run, not OS resource stats)."""
+    p = progress
+    head = f"[check_links] phase={p.phase} elapsed={now - p.started:.0f}s"
+    if p.phase != "fetching external":
+        return f"{head} pages={p.pages} links={p.links} targets={p.targets}"
+    cooling = sorted(
+        ((host, deadline - now) for host, deadline in p.cooling.items() if deadline > now),
+        key=lambda hw: hw[1],
+        reverse=True,
+    )
+    detail = "".join(f" {host}({wait:.1f}s)" for host, wait in cooling)  # wide when many hosts cool at once; fine
+    return (
+        f"{head} fetched={p.urls_done}/{p.urls_total} dispatched={p.dispatched} "
+        f"workers={p.workers} cooling={len(cooling)}{detail}"
+    )
+
+
+def _install_signal_handlers(on_stop: _SignalHandler, on_status: _SignalHandler) -> dict[int, Any]:
+    """Wire SIGINT (Ctrl-C, clean stop) and every available status signal (see `_STATUS_SIGNALS`), returning the
+    prior handlers for restoration. A no-op off the main thread, where handlers cannot be installed."""
+    previous: dict[int, Any] = {}
+    try:
+        previous[signal.SIGINT] = signal.signal(signal.SIGINT, on_stop)
+        for name in _STATUS_SIGNALS:
+            signum = getattr(signal, name, None)
+            if signum is not None:
+                previous[signum] = signal.signal(signum, on_status)
+    except ValueError:
+        pass  # not the main thread; interactive control is simply unavailable
+    return previous
+
+
+def _restore_signal_handlers(previous: dict[int, Any]) -> None:
+    for signum, handler in previous.items():
+        signal.signal(signum, handler)
+
+
+def _normalize_text(text: str) -> str:
+    """Collapse whitespace and case-fold, so text-fragment queries match the page regardless of layout or case."""
+    return " ".join(text.split()).casefold()
+
+
+class _LinkAnchorParser(HTMLParser):
+    """Collects href/src references and fragment targets (`id`, and `name` on `a`), and optionally the page text."""
+
+    def __init__(self, collect_text: bool = False) -> None:
+        super().__init__(convert_charrefs=True)
+        self.links: list[tuple[str, int]] = []  # (href, 1-based line in the source HTML)
+        self.anchors: set[str] = set()
+        self._collect_text = collect_text
+        self._chunks: list[str] = []
+        self._skip_depth = 0  # inside <script>/<style>, whose text is not visible content
+
+    def handle_starttag(self, tag: str, attrs: list[tuple[str, str | None]]) -> None:
+        attr = dict(attrs)
+        line = self.getpos()[0]
+        # <link> is head chrome (canonical/hreflang SEO tags, stylesheets), never authored content.
+        if tag != "link":
+            for key in ("href", "src"):
+                if value := attr.get(key):
+                    self.links.append((value, line))
+        if element_id := attr.get("id"):
+            self.anchors.add(element_id)
+        if tag == "a" and (name := attr.get("name")):
+            self.anchors.add(name)
+        if tag in ("script", "style"):
+            self._skip_depth += 1
+
+    def handle_endtag(self, tag: str) -> None:
+        if tag in ("script", "style") and self._skip_depth:
+            self._skip_depth -= 1
+
+    def handle_data(self, data: str) -> None:
+        if self._collect_text and not self._skip_depth:
+            self._chunks.append(data)
+
+    @property
+    def text(self) -> str:
+        return "".join(self._chunks)
+
+
+def extract(html: str) -> tuple[list[tuple[str, int]], set[str]]:
+    """Parse one page into (referenced (URL, line) pairs, fragment targets defined on the page)."""
+    parser = _LinkAnchorParser()
+    parser.feed(html)
+    return parser.links, parser.anchors
+
+
+def cmd_extract(args: list[str], progress: _Progress) -> int:
+    """Print the links (with line numbers) and fragment targets extracted from an HTML file."""
+    links, anchors = extract(Path(args[0]).read_text(encoding="utf-8"))
+    for href, line in links:
+        print(f"link\t{line}\t{href}")
+    for anchor in sorted(anchors):
+        print(f"anchor\t{anchor}")
+    return 0
+
+
+class Target(NamedTuple):
+    """A resolved link destination: a local file, an external URL, or a root-absolute site link."""
+
+    kind: str  # "local" (filesystem), "external" (HTTP), or "site" (root-absolute, resolved by resolve_site_targets)
+    resource: str  # local: normalized filesystem path; external: URL; site: root-absolute URL path
+    fragment: str  # decoded element-id anchor, or "" for none / page-top
+    text_targets: tuple[str, ...]  # decoded text segments of a `:~:text=` directive that must all be on the page
+    internal: bool = False  # a link to our own site; a failure is an error even when checked over HTTP
+
+
+_SKIP_SCHEMES = ("mailto:", "tel:", "javascript:", "data:")
+
+# API endpoints and the like that are documented in the docs but are not pages meant to be fetched. The `api.`
+# heuristic covers most (api.openai.com, *.api.daxoptimizer.com, ...); add other non-gettable hosts explicitly.
+_UNCHECKED_HOSTS: set[str] = set()
+
+# Any hosts where we observe 429s when we use `stats` get a lower max for
+# in-flight requests. Try to be a good citizen of the web.
+_HOST_MAX_IN_FLIGHT_OVERRIDES = {"github.com": 6}
+
+# Some encoders (DocFX/Markdig) percent-encode the ~ in the :~: text-fragment delimiter, so it must be normalized
+# before the split -- partitioning the still-encoded fragment would miss the delimiter entirely.
+_FRAGMENT_DELIMITER = ":~:"
+_ENCODED_DELIMITER_CHARS = {"%7e": "~", "%7E": "~"}
+
+
+def _is_skippable(href: str) -> bool:
+    """True for hrefs with nothing to check: empty, a bare '#', or a non-navigable scheme."""
+    return not href or href == "#" or href.lower().startswith(_SKIP_SCHEMES)
+
+
+def _is_external(url: str) -> bool:
+    """True for absolute or protocol-relative URLs, which are checked over HTTP rather than on disk."""
+    return url.lower().startswith(("http://", "https://", "//"))
+
+
+def _is_root_absolute(url: str) -> bool:
+    """True for site-root-relative links, resolved against the site root rather than the source page."""
+    return url.startswith("/")
+
+
+def _is_unchecked_host(host: str) -> bool:
+    """True for hosts we deliberately skip -- API endpoints and other documented-but-not-navigable URLs."""
+    return host in _UNCHECKED_HOSTS or host.startswith("api.") or ".api." in host
+
+
+def _split_fragment(raw_fragment: str) -> tuple[str, str]:
+    """Split a raw URL fragment into (element-id anchor, text directive), decoding an encoded delimiter first so
+    the :~: split is found even when the ~ arrives percent-encoded. Delimiters are decoded before the split; the
+    directive's own values stay encoded for `_parse_text_directive` to split and decode."""
+    normalized = raw_fragment
+    for encoded, decoded in _ENCODED_DELIMITER_CHARS.items():
+        normalized = normalized.replace(encoded, decoded)
+    anchor, _, directive = normalized.partition(_FRAGMENT_DELIMITER)
+    return anchor, directive
+
+
+def _parse_text_directive(directive: str) -> tuple[str, ...]:
+    """The decoded text segments of a `:~:text=` fragment directive (textStart and textEnd), all of which must be
+    present on the page. Empty if it is not a text directive. The optional prefix-/-suffix context is dropped."""
+    if not directive.startswith("text="):
+        return ()
+    # value is [prefix-,]textStart[,textEnd][,-suffix]; keep the non-context segments.
+    segments = [seg for seg in directive[len("text=") :].split(",") if seg]
+    return tuple(unquote(seg) for seg in segments if not seg.endswith("-") and not seg.startswith("-"))
+
+
+def resolve(href: str, source_page: Path, site_root: Path) -> Target | None:
+    """Classify and normalize a raw href into a checkable Target, or None when there is nothing to check."""
+    href = href.strip()
+    if _is_skippable(href):
+        return None
+    url, raw_fragment = urldefrag(href)
+    anchor, directive = _split_fragment(raw_fragment)
+    fragment = unquote(anchor)
+    if fragment == "top":  # browsers scroll to the page top for #top even with no matching element
+        fragment = ""
+    text_targets = _parse_text_directive(directive)
+    if _is_external(url):
+        return None if _is_unchecked_host(_host_of(url)) else Target("external", url, fragment, text_targets)
+    if not url:  # a same-page "#fragment" reference (nothing to check for a pure text directive)
+        return Target("local", str(source_page), fragment, text_targets) if fragment else None
+    if _is_root_absolute(url):  # a site link; resolve_site_targets decides on-disk vs live once the tree is known
+        return Target("site", url, fragment, text_targets)
+    base = source_page.parent / url
+    return Target("local", os.path.normpath(base), fragment, text_targets)
+
+
+def cmd_resolve(args: list[str], progress: _Progress) -> int:
+    """Print the resolved Target (or 'skip') for a raw href found in a source page."""
+    href, source_page = args[0], Path(args[1])
+    site_root = Path(args[2]) if len(args) > 2 else Path("_site")
+    target = resolve(href, source_page, site_root)
+    if target is None:
+        print("skip")
+    else:
+        print(f"{target.kind}\t{target.resource}\t{target.fragment}\t{target.text_targets}")
+    return 0
+
+
+def enumerate_site(
+    root: Path, source_prefix: str | None = None, progress: _Progress | None = None
+) -> tuple[dict[Target, dict[str, list[int]]], dict[str, set[str]]]:
+    """Walk the built site under `root`: return (target -> {referring page -> line numbers}) and (page -> anchors).
+
+    Anchors are indexed for every page so fragment targets anywhere resolve, but links are collected only from pages
+    whose path starts with `source_prefix` (when given) -- a way to check just a subset of the docs. Counts flow into
+    `progress` for the status signal, and a Ctrl-C (its stop flag) ends the walk early for a partial report."""
+    progress = progress or _Progress()
+    refs: dict[Target, dict[str, list[int]]] = {}
+    anchors_by_file: dict[str, set[str]] = {}
+    for page in root.rglob("*.html"):
+        if progress.stop.is_set():
+            break
+        progress.pages += 1
+        source = os.path.normpath(page)
+        links, anchors = extract(page.read_text(encoding="utf-8"))
+        anchors_by_file[source] = anchors
+        if source_prefix and not source.startswith(source_prefix):
+            continue  # index this page's anchors, but do not check its outgoing links
+        for href, line in links:
+            target = resolve(href, page, root)
+            if target is not None:
+                refs.setdefault(target, {}).setdefault(source, []).append(line)
+        progress.links += len(links)
+        progress.targets = len(refs)
+    return refs, anchors_by_file
+
+
+def cmd_enumerate(args: list[str], progress: _Progress) -> int:
+    """Print summary counts for the site's links and fragment targets."""
+    root = Path(args[0]) if args else Path("_site")
+    refs, anchors_by_file = enumerate_site(root, progress=progress)
+    local = sum(1 for target in refs if target.kind == "local")
+    external = sum(1 for target in refs if target.kind == "external")
+    site = sum(1 for target in refs if target.kind == "site")
+    total = sum(len(lines) for sources in refs.values() for lines in sources.values())
+    print(f"html files indexed: {len(anchors_by_file)}")
+    print(f"unique targets:     {len(refs)}  (local {local}, external {external}, site {site})")
+    print(f"total references:   {total}")
+    return 0
+
+
+# A real browser User-Agent: stdlib's default python-urllib string is 403'd by GitHub and Microsoft Learn.
+_USER_AGENT = (
+    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 "
+    "(KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+)
+
+# Cap the body we read for anchor/text checks. The 20s socket timeout bounds a stalled read, but not a server that
+# steadily streams an endless (or huge) body; this bounds it. HTML pages we check are far smaller.
+_MAX_BODY_BYTES = 10 * 1024 * 1024
+
+
+class FetchResult(NamedTuple):
+    """The outcome of visiting one external URL: reachability, status, any error detail, and page anchors (GET only)."""
+
+    ok: bool  # True when the server answered with a 2xx/3xx status
+    status: int  # HTTP status code, or 0 when the request never completed
+    detail: str  # human-readable error for the report, or "" on success
+    anchors: set[str]  # fragment targets found in the body (populated only on a body-parsing GET)
+    retry_after: int  # seconds requested by a 429 Retry-After header; 0 otherwise
+    method: str  # the request method that produced this result ("HEAD"/"GET"), or "" if none completed
+    text: str  # normalized visible page text for text-fragment checks (populated only on a body-parsing GET)
+
+
+# Hosts confirmed to 404 a HEAD they serve on GET; skip the doomed HEAD probe for them. Diagnostics
+# (`head_fallbacks`) surface further candidates to add here.
+_GET_ONLY_HOSTS = {"cdn.tabulareditor.com", "www.nuget.org"}
+
+
+def _host_of(url: str) -> str:
+    """The lowercased host of an external URL (with a scheme prepended for protocol-relative //host)."""
+    return urlsplit("https:" + url if url.startswith("//") else url).netloc.lower()
+
+
+def _parse_retry_after(value: str | None) -> int:
+    """Seconds from a 429 Retry-After header; 0 when absent or given as an HTTP-date we do not parse."""
+    return int(value) if value and value.isdigit() else 0
+
+
+def fetch_external(url: str, need_body: bool) -> FetchResult:
+    """Visit one external URL. HEAD is a cheap reachability probe; any HEAD failure is reconfirmed with a GET before
+    the URL is declared broken, because many hosts 404/405 a HEAD they would serve (known ones skip HEAD via
+    `_GET_ONLY_HOSTS`). GET downloads the body only when a fragment must be verified."""
+    target = "https:" + url if url.startswith("//") else url  # protocol-relative //host needs a scheme
+    get_only = need_body or _host_of(url) in _GET_ONLY_HOSTS
+    for method in (("GET",) if get_only else ("HEAD", "GET")):
+        request = urllib.request.Request(target, method=method, headers={"User-Agent": _USER_AGENT})
+        try:
+            with urllib.request.urlopen(request, timeout=20) as response:
+                anchors: set[str] = set()
+                text = ""
+                # Download the body only to verify a fragment; a reachability GET (the HEAD fallback) needs just the
+                # status, and reading it would pull whole binaries (installers, images) off the CDN.
+                if method == "GET" and need_body:
+                    charset = response.headers.get_content_charset() or "utf-8"
+                    parser = _LinkAnchorParser(collect_text=True)
+                    parser.feed(response.read(_MAX_BODY_BYTES).decode(charset, "replace"))
+                    anchors, text = parser.anchors, _normalize_text(parser.text)
+                return FetchResult(True, response.status, "", anchors, 0, method, text)
+        except urllib.error.HTTPError as error:
+            if method == "HEAD":
+                continue  # HEAD is only a probe; reconfirm the failure with a GET
+            retry_after = _parse_retry_after(error.headers.get("Retry-After")) if error.code == 429 else 0
+            return FetchResult(False, error.code, f"HTTP {error.code} {error.reason}", set(), retry_after, method, "")
+        except (OSError, http.client.HTTPException, ValueError) as error:
+            # OSError covers URLError/TimeoutError/connection resets; HTTPException covers a peer that closes
+            # mid-response (RemoteDisconnected), which urllib does not wrap when it happens during getresponse().
+            if method == "HEAD":
+                continue  # reconfirm transport failures with a GET too
+            return FetchResult(False, 0, str(getattr(error, "reason", error)), set(), 0, method, "")
+    return FetchResult(False, 0, "no request attempted", set(), 0, "", "")
+
+
+class _Task(NamedTuple):
+    """A queued fetch: the URL, whether its body is needed, its host (cached), and the 429 retry count so far."""
+
+    url: str
+    need_body: bool
+    host: str
+    attempt: int
+
+
+class HostStats(NamedTuple):
+    """Per-host fetch diagnostics for understanding timing and rate limiting."""
+
+    requests: int  # fetch attempts completed, including 429 retries
+    rate_limited: int  # 429 responses received
+    wait_seconds: float  # total cooldown time applied to the host
+    head_fallbacks: int  # reachability GETs after a failed HEAD (candidates for _GET_ONLY_HOSTS)
+    final_cap: int  # ending per-host in-flight cap (below the start value means it was throttled down)
+    retry_after_seen: frozenset[int]  # distinct Retry-After values seen on 429s (0 = header absent/unparsed)
+
+
+_MAX_RETRIES = 8  # per-URL: after this many 429 retries, give up on a URL and record the last result
+
+
+def _backoff(attempt: int) -> float:
+    """Seconds to wait before retrying a 429 that carried no Retry-After: 1, 2, 4, ..."""
+    return float(2**attempt)
+
+
+def _next_cooldown_wait(pending: dict[str, deque[_Task]], cooldown: dict[str, float], now: float) -> float | None:
+    """Seconds until the soonest cooling-down host with pending work becomes eligible, or None if none are cooling."""
+    waits = [cooldown[host] - now for host in pending if cooldown.get(host, 0.0) > now]
+    return min(waits) if waits else None
+
+
+def fetch_all_external(
+    refs: dict[Target, dict[str, list[int]]],
+    max_per_host: int = 8,
+    max_workers: int = 12,
+    progress: _Progress | None = None,
+) -> tuple[dict[str, FetchResult], dict[str, HostStats]]:
+    """Fetch every unique external URL once. `max_workers` threads drain a shared work queue kept as full as
+    eligibility allows; admission holds each host to its current cap (starting at `max_per_host`). A 429 cools the
+    host down (honoring Retry-After), drops its cap by one as backpressure, and re-queues its URLs for after the
+    wait. GET only when a fragment must be verified. Returns the results plus per-host diagnostics.
+
+    All scheduling state is owned by this thread alone (workers only pull tasks and push results), so it needs no
+    locks. On a 429 we also reclaim that host's not-yet-claimed tasks from the queue; any a worker already grabbed
+    slip through, which is a bounded, acceptable miss. Progress counts flow into `progress` for the status signal,
+    and a Ctrl-C (its stop flag) ends the loop early, returning whatever has been fetched for a partial report."""
+    progress = progress or _Progress()
+    need_body: dict[str, bool] = {}
+    for target in refs:
+        if target.kind == "external":
+            wants_body = bool(target.fragment) or bool(target.text_targets)
+            need_body[target.resource] = need_body.get(target.resource, False) or wants_body
+
+    pending: dict[str, deque[_Task]] = defaultdict(deque)
+    for url, body in need_body.items():
+        host = _host_of(url)
+        pending[host].append(_Task(url, body, host, 0))
+
+    work_q: Queue[_Task | None] = Queue()
+    done_q: Queue[tuple[_Task, FetchResult]] = Queue()
+    outstanding: dict[str, int] = defaultdict(int)
+    host_cap: dict[str, int] = defaultdict(lambda: max_per_host)
+    host_cap.update(_HOST_MAX_IN_FLIGHT_OVERRIDES)
+    cooldown: dict[str, float] = {}
+    results: dict[str, FetchResult] = {}
+
+    requests: dict[str, int] = defaultdict(int)
+    rate_limited: dict[str, int] = defaultdict(int)
+    wait_seconds: dict[str, float] = defaultdict(float)
+    head_fallbacks: dict[str, int] = defaultdict(int)
+    retry_after_seen: dict[str, set[int]] = defaultdict(set)
+
+    def worker() -> None:
+        while (task := work_q.get()) is not None:
+            try:
+                result = fetch_external(task.url, task.need_body)
+            except Exception as error:  # never die with a task in hand: that result would never come and hang us
+                result = FetchResult(False, 0, f"fetch crashed: {error!r}", set(), 0, "", "")
+            done_q.put((task, result))
+
+    def admit() -> None:
+        now = monotonic()
+        for host, queued in pending.items():
+            while queued and outstanding[host] < host_cap[host] and cooldown.get(host, 0.0) <= now:
+                outstanding[host] += 1
+                work_q.put(queued.popleft())
+
+    def reclaim(host: str) -> None:
+        """Pull the cooling host's not-yet-claimed tasks back out of the work queue so they wait for the cooldown."""
+        kept: list[_Task | None] = []
+        try:
+            while True:
+                task = work_q.get_nowait()
+                if task is not None and task.host == host:
+                    outstanding[host] -= 1
+                    pending[host].appendleft(task)
+                else:
+                    kept.append(task)
+        except Empty:
+            pass
+        for task in kept:
+            work_q.put(task)
+
+    # Daemon workers so a second Ctrl-C (which raises in the main thread) can abandon in-flight requests and exit.
+    workers = [Thread(target=worker, daemon=True) for _ in range(max_workers)]
+    for thread in workers:
+        thread.start()
+
+    remaining = len(need_body)
+    progress.urls_total = remaining
+    progress.workers = max_workers
+    progress.cooling = cooldown  # a live reference; the status handler reads it on the same thread, so no lock
+    admit()
+    while remaining and not progress.stop.is_set():
+        wait = _next_cooldown_wait(pending, cooldown, monotonic())
+        wait = _STOP_POLL if wait is None else min(wait, _STOP_POLL)  # cap the block so the stop flag is seen promptly
+        try:
+            task, result = done_q.get(timeout=wait)
+        except Empty:
+            admit()  # a cooldown expired (or the poll ticked); recheck eligibility
+            continue
+        outstanding[task.host] -= 1
+        requests[task.host] += 1
+        if result.method == "GET" and not task.need_body and task.host not in _GET_ONLY_HOSTS:
+            head_fallbacks[task.host] += 1
+        if result.status == 429:
+            rate_limited[task.host] += 1
+            retry_after_seen[task.host].add(result.retry_after)
+        if result.status == 429 and task.attempt < _MAX_RETRIES:
+            host_cap[task.host] = max(1, host_cap[task.host] - 1)  # adaptive backpressure
+            delay = result.retry_after or _backoff(task.attempt)
+            wait_seconds[task.host] += delay
+            cooldown[task.host] = monotonic() + delay
+            pending[task.host].appendleft(task._replace(attempt=task.attempt + 1))
+            reclaim(task.host)
+        else:
+            results[task.url] = result
+            remaining -= 1
+        admit()
+        progress.urls_done = len(results)
+        progress.dispatched = sum(outstanding.values())
+
+    if not progress.stop.is_set():  # normal completion: retire the workers cleanly
+        for _ in workers:
+            work_q.put(None)
+        for thread in workers:
+            thread.join()
+    # On Ctrl-C we skip the join: a daemon worker may be mid-request, and blocking on a slow socket would stall the
+    # partial report. The workers are abandoned and reaped at interpreter exit; `results` is the partial set.
+
+    stats = {
+        host: HostStats(
+            requests[host],
+            rate_limited[host],
+            wait_seconds[host],
+            head_fallbacks[host],
+            host_cap[host],
+            frozenset(retry_after_seen[host]),
+        )
+        for host in pending
+    }
+    return results, stats
+
+
+def cmd_fetch(args: list[str], progress: _Progress) -> int:
+    """Fetch a single external URL (pass a second arg to force a body-parsing GET) and print the result."""
+    url = args[0]
+    need_body = len(args) > 1
+    result = fetch_external(url, need_body)
+    print(
+        f"ok={result.ok} status={result.status} anchors={len(result.anchors)} "
+        f"retry_after={result.retry_after} detail={result.detail}"
+    )
+    return 0
+
+
+class Failure(NamedTuple):
+    """A broken target: the target, a short reason, and each referring page mapped to the lines it appears on."""
+
+    target: Target
+    reason: str
+    sources: dict[str, list[int]]
+
+
+def _find_local_file(resource: str, existing_files: set[str]) -> str | None:
+    """Map a resolved local path to an existing file, trying `.html` and `index.html` fallbacks; None if absent."""
+    if resource in existing_files:
+        return resource
+    if not resource.endswith(".html"):
+        for fallback in (f"{resource}.html", os.path.normpath(os.path.join(resource, "index.html"))):
+            if fallback in existing_files:
+                return fallback
+    return None
+
+
+def validate(
+    refs: dict[Target, dict[str, list[int]]],
+    anchors_by_file: dict[str, set[str]],
+    existing_files: set[str],
+    external_results: dict[str, FetchResult],
+) -> list[Failure]:
+    """Cross-reference every target against the filesystem snapshot and fetch results into a list of failures."""
+    failures: list[Failure] = []
+    for target, sources in refs.items():
+        if target.kind == "local":
+            resolved = _find_local_file(target.resource, existing_files)
+            if resolved is None:
+                failures.append(Failure(target, "missing file", sources))
+            elif target.fragment and target.fragment not in anchors_by_file.get(resolved, set()):
+                failures.append(Failure(target, "missing anchor", sources))
+        else:
+            result = external_results.get(target.resource)
+            if result is None:
+                failures.append(Failure(target, "not fetched", sources))
+            elif not result.ok:
+                failures.append(Failure(target, result.detail or f"unreachable (status {result.status})", sources))
+            elif target.text_targets and not all(_normalize_text(t) in result.text for t in target.text_targets):
+                failures.append(Failure(target, "missing text", sources))
+            elif target.fragment and target.fragment not in result.anchors:
+                failures.append(Failure(target, "missing anchor", sources))
+    return failures
+
+
+def _existing_files(root: Path) -> set[str]:
+    """Snapshot every file under `root` as a normalized path, for pure existence checks in `validate`."""
+    return {os.path.normpath(path) for path in root.rglob("*") if path.is_file()}
+
+
+def resolve_site_targets(
+    refs: dict[Target, dict[str, list[int]]], existing_files: set[str], site_root: Path, base_url: str
+) -> dict[Target, dict[str, list[int]]]:
+    """Resolve root-absolute ("site") links against the built tree: those present on disk become ordinary local
+    checks. When `base_url` is set (the deployed site root, from build-config), links absent on disk are checked
+    live at that domain -- its redirects usually make them valid -- and, being our own links, a failure there is an
+    error, not a warning. When `base_url` is empty (offline mode) absent links stay on-disk errors. Non-site targets
+    pass through unchanged."""
+    resolved: dict[Target, dict[str, list[int]]] = {}
+    for target, sources in refs.items():
+        reclassified = target
+        if target.kind == "site":
+            disk_path = os.path.normpath(site_root / target.resource.lstrip("/"))
+            if base_url and _find_local_file(disk_path, existing_files) is None:
+                url = base_url + target.resource
+                reclassified = Target("external", url, target.fragment, target.text_targets, internal=True)
+            else:
+                reclassified = target._replace(kind="local", resource=disk_path)
+        merged = resolved.setdefault(reclassified, {})
+        for source, lines in sources.items():
+            merged.setdefault(source, []).extend(lines)
+    return resolved
+
+
+def map_to_source(built: str, root: Path) -> str | None:
+    """Map a built HTML path back to its authored markdown under content/, or None for generated/localized pages."""
+    parts = Path(os.path.relpath(built, root)).parts  # e.g. ("en", "features", "foo.html")
+    if len(parts) >= 2 and parts[0] == "en" and parts[1] != "api":
+        return os.path.normpath(os.path.join("content", str(Path(*parts[1:]).with_suffix(".md"))))
+    return None
+
+
+def _anchor_member(type_stem: str, fragment: str) -> str:
+    """Best-effort member name from a DocFX member anchor; empty when the anchor scheme does not match."""
+    prefix = type_stem.replace(".", "_") + "_"
+    return fragment[len(prefix):].split("_", 1)[0] if fragment.startswith(prefix) else ""
+
+
+def _fragment_suffix(target: Target) -> str:
+    """The full URL fragment for display: the element-id anchor and/or the complete `:~:text=` directive, or ""."""
+    directive = ("text=" + ",".join(target.text_targets)) if target.text_targets else ""
+    if target.fragment and directive:
+        return f"#{target.fragment}:~:{directive}"
+    if target.fragment:
+        return f"#{target.fragment}"
+    return f"#:~:{directive}" if directive else ""
+
+
+def humanize(target: Target, base_url: str) -> str:
+    """A greppable rendering of the destination for finding it in the markdown source (best-effort for API anchors)."""
+    if target.kind == "external":
+        return _display_url(target, base_url) + _fragment_suffix(target)
+    stem = os.path.basename(target.resource).removesuffix(".html")
+    if not target.fragment:
+        return stem
+    member = _anchor_member(stem, target.fragment)
+    type_name = stem.rsplit(".", 1)[-1]  # last dotted segment of the type UID
+    return f"{type_name}.{member}" if member else f"{type_name} (#{target.fragment})"
+
+
+def _display_url(target: Target, base_url: str) -> str:
+    """The path or URL shown for a target. Internal (live-checked own-site) links show the authored root-absolute
+    path rather than the live URL; protocol-relative externals get an https scheme."""
+    if target.internal:
+        return target.resource.removeprefix(base_url)
+    if target.kind == "external" and target.resource.startswith("//"):
+        return "https:" + target.resource
+    return target.resource
+
+
+def report(failures: list[Failure], root: Path, base_url: str, content_only: bool = True) -> int:
+    """Print broken references grouped by source file and return an exit code (nonzero if any on-disk error).
+
+    On-disk breaks are errors; external breaks are warnings with a trailing copy-paste URL list. Each break shows
+    the greppable destination for the markdown, the exact built-HTML href, and clickable `path:line` locations. By
+    default only breaks on authored `content/*.md` pages are shown; `content_only=False` adds generated API and
+    localized pages. Groups sort by displayed path, so `content/` files lead:
+
+        ERRORS -- 2 broken on-disk reference(s) across 1 file(s)
+
+        content/features/semantic-bridge-metric-view-object-model.md
+          built: _site/en/features/semantic-bridge-metric-view-object-model.html
+          missing anchor  (x2)
+            md grep: DatabricksMetricViewService.Load
+            html:    ../../api/TabularEditor.SemanticBridge...DatabricksMetricViewService.html#..._Load_System_String_
+            at:      _site/en/features/semantic-bridge-metric-view-object-model.html:120  ...:145
+          missing file  (x3)
+            md grep: Advanced-features
+            html:    /Advanced-features
+            at:      _site/en/features/semantic-bridge-metric-view-object-model.html:12  ...:30  ...:88
+
+        WARNINGS -- 1 broken external reference(s) across 1 file(s)
+        ...
+        External URLs to verify (url, docs, instances):
+          https://example.com/gone  3  5
+    """
+    errors: dict[str, list[tuple[Failure, list[int]]]] = {}
+    warnings: dict[str, list[tuple[Failure, list[int]]]] = {}
+    for failure in failures:
+        is_error = failure.target.kind == "local" or failure.target.internal  # our own content vs third-party
+        bucket = errors if is_error else warnings
+        for source, lines in failure.sources.items():
+            if content_only and map_to_source(source, root) is None:
+                continue
+            bucket.setdefault(source, []).append((failure, sorted(lines)))
+
+    if not errors and not warnings:
+        print("No broken references found.")
+        return 0
+
+    for label, bucket in (("ERRORS", errors), ("WARNINGS", warnings)):
+        if not bucket:
+            continue
+        kind = "internal" if label == "ERRORS" else "external"
+        total = sum(len(breaks) for breaks in bucket.values())
+        print(f"{label} -- {total} broken {kind} reference(s) across {len(bucket)} file(s)")
+        for source in sorted(bucket, key=lambda s: map_to_source(s, root) or s):
+            md = map_to_source(source, root)
+            print(f"\n{md or source}")
+            print(f"  built: {source}" if md else "  (generated or localized page; no direct .md source)")
+            for failure, lines in sorted(bucket[source], key=lambda fl: (fl[0].reason, fl[0].target.resource)):
+                # A missing file makes any fragment/text directive moot, so drop it from what we display.
+                target = failure.target
+                if failure.reason == "missing file":
+                    target = target._replace(fragment="", text_targets=())
+                locations = "  ".join(f"{source}:{line}" for line in lines)
+                print(f"  {failure.reason}  (x{len(lines)})")
+                print(f"    md grep: {humanize(target, base_url)}")
+                print(f"    html:    {_display_url(target, base_url)}{_fragment_suffix(target)}")
+                print(f"    at:      {locations}")
+        print()
+
+    if warnings:
+        files: dict[str, set[str]] = defaultdict(set)
+        instances: dict[str, int] = defaultdict(int)
+        for source, breaks in warnings.items():
+            for failure, lines in breaks:
+                # For a reachable-but-fragment/text failure the bare URL works, so keep the fragment that broke;
+                # for an unreachable URL the fragment is moot, so show it bare.
+                shown = _display_url(failure.target, base_url)
+                if failure.reason in ("missing anchor", "missing text"):
+                    shown += _fragment_suffix(failure.target)
+                files[shown].add(source)
+                instances[shown] += len(lines)
+        print("External URLs to verify (url, docs, instances):")
+        for url in sorted(files):
+            print(f"{url}  {len(files[url])}  {instances[url]}")
+
+    return 1 if errors else 0
+
+
+_FEATURED_STATUS = (401, 403, 404)  # broken out as their own per-host columns; the rest fold into "5xx/other"
+
+
+class Outcome(NamedTuple):
+    """Per-host validation outcomes for external URLs."""
+
+    ok: int  # reachable, and any fragment/text check passed
+    partial: int  # reachable (url+path), but a fragment or text check on it failed
+    status: Counter[int]  # failing HTTP status code -> count (e.g. 404 -> 3)
+    transport: int  # non-HTTP failures: DNS, TLS, timeout, connection reset (no HTTP status)
+
+    @property
+    def total(self) -> int:
+        """Every external URL seen for this host: successes, fragment/text issues, and unreachable."""
+        return self.ok + self.partial + self.broken
+
+    @property
+    def broken(self) -> int:
+        """Total unreachable: every failing HTTP status plus the transport failures."""
+        return sum(self.status.values()) + self.transport
+
+    @property
+    def other_http(self) -> int:
+        """Failing HTTP statuses beyond the featured columns (5xx, and any 4xx that is not 401/403/404)."""
+        return sum(count for code, count in self.status.items() if code not in _FEATURED_STATUS)
+
+
+def summarize_outcomes(external_results: dict[str, FetchResult], failures: list[Failure]) -> dict[str, Outcome]:
+    """Reduce fetch results and validation failures to a per-host Outcome. Partial hangs off `failures` because a
+    missing fragment/text is only knowable after validation, not from the fetch alone."""
+    frag_urls = {
+        f.target.resource
+        for f in failures
+        if f.target.kind == "external" and f.reason in ("missing anchor", "missing text")
+    }
+    ok: Counter[str] = Counter()
+    partial: Counter[str] = Counter()
+    transport: Counter[str] = Counter()
+    status: defaultdict[str, Counter[int]] = defaultdict(Counter)
+    for url, result in external_results.items():
+        host = _host_of(url)
+        if not result.ok:
+            if result.status == 0:
+                transport[host] += 1  # DNS, TLS, timeout, connection reset -- no HTTP status to bucket
+            else:
+                status[host][result.status] += 1
+        elif url in frag_urls:
+            partial[host] += 1
+        else:
+            ok[host] += 1
+    hosts = set(ok) | set(partial) | set(transport) | set(status)
+    return {h: Outcome(ok[h], partial[h], status.get(h, Counter()), transport[h]) for h in hosts}
+
+
+def print_diagnostics(stats: dict[str, HostStats], outcomes: dict[str, Outcome], elapsed: float) -> None:
+    """Print the combined per-host stats table: validation outcomes (ok/frag/bad, per-status failures, non-HTTP
+    failures) alongside fetch mechanics (reqs/429s/cooldown/HEAD fallbacks/cap). Hosts sort worst-first."""
+    active = {host: stat for host, stat in stats.items() if stat.requests}
+    if not active:  # interrupted before any fetch happened; a header with no rows is just noise
+        return
+    empty = Outcome(0, 0, Counter(), 0)
+
+    def rank(item: tuple[str, HostStats]) -> tuple[int, int, int, float]:
+        host, stat = item
+        outcome = outcomes.get(host, empty)
+        return outcome.broken, outcome.partial, stat.rate_limited, stat.wait_seconds
+
+    print(f"\n--- stats ({elapsed:.1f}s, {len(active)} hosts) ---")
+    print(f"{'total':>5} {'ok':>5} {'frag':>5} {'bad':>5} {'reqs':>5} {'429':>4} {'401':>4} {'403':>4} {'404':>4} "
+          f"{'oth':>4} {'net':>4} {'wait(s)':>8} {'fb':>4} {'cap':>4}  host  [retry-after seen]")
+    for host, stat in sorted(active.items(), key=rank, reverse=True):
+        oc = outcomes.get(host, empty)
+        seen = sorted(stat.retry_after_seen)
+        tail = f"  {seen}" if stat.rate_limited else ""
+        print(f"{oc.total:>5} {oc.ok:>5} {oc.partial:>5} {oc.broken:>5} {stat.requests:>5} {stat.rate_limited:>4} "
+              f"{oc.status.get(401, 0):>4} {oc.status.get(403, 0):>4} {oc.status.get(404, 0):>4} "
+              f"{oc.other_http:>4} {oc.transport:>4} {stat.wait_seconds:>8.1f} "
+              f"{stat.head_fallbacks:>4} {stat.final_cap:>4}  {host}{tail}")
+
+
+def cmd_validate(args: list[str], progress: _Progress, base_url: "Callable[[], str]") -> int:
+    """Validate a built site and report broken references.
+
+    Usage: validate [root] [local] [all] [stats] [under=<subpath>]
+      local           skip external fetching (on-disk checks only)
+      all             include generated API and localized pages (default: authored content/*.md only)
+      stats           print per-host fetch diagnostics
+      under=<subpath> check only links from pages under root/<subpath> (anchors are still indexed site-wide)
+    """
+    flags = {arg for arg in args if arg in ("local", "all", "stats")}
+    under = next((arg[len("under=") :] for arg in args if arg.startswith("under=")), None)
+    positional = [arg for arg in args if arg not in flags and not arg.startswith("under=")]
+    root = Path(positional[0]) if positional else Path("_site")
+    source_prefix = os.path.normpath(root / under) if under else None
+
+    progress.phase = "enumerating"
+    refs, anchors_by_file = enumerate_site(root, source_prefix, progress)
+    existing = _existing_files(root)
+    progress.phase = "resolving"
+    # Resolve the base URL only when needed: local mode never checks live, so it stays offline and config-free.
+    site_base = "" if "local" in flags else base_url()
+    refs = resolve_site_targets(refs, existing, root, site_base)
+    stats: dict[str, HostStats] = {}
+    started = monotonic()
+    if "local" in flags:
+        refs = {target: sources for target, sources in refs.items() if target.kind == "local"}
+        external: dict[str, FetchResult] = {}
+    else:
+        progress.phase = "fetching external"
+        external, stats = fetch_all_external(refs, progress=progress)
+    elapsed = monotonic() - started
+
+    if progress.stop.is_set():  # Ctrl-C: drop the not-yet-fetched externals and flag the report as partial
+        external_urls = {target.resource for target in refs if target.kind == "external"}
+        print(
+            f"\nInterrupted: fetched {len(external)}/{len(external_urls)} external URL(s); report is partial.",
+            file=sys.stderr,
+        )
+        refs = {t: s for t, s in refs.items() if t.kind != "external" or t.resource in external}
+
+    progress.phase = "validating"
+    failures = validate(refs, anchors_by_file, existing, external)
+    exit_code = report(failures, root, site_base, content_only="all" not in flags)
+    if "stats" in flags:
+        print_diagnostics(stats, summarize_outcomes(external, failures), elapsed)
+    return exit_code
+
+
+class Plain(NamedTuple):
+    """A command needing only args + progress."""
+
+    run: Callable[[list[str], _Progress], int]
+
+
+class Site(NamedTuple):
+    """A command that resolves links against the live site, so it also gets a base-URL provider (called lazily,
+    so a command that turns out not to need it -- e.g. `validate local` -- never triggers the config read)."""
+
+    run: Callable[[list[str], _Progress, Callable[[], str]], int]
+
+
+Command = Plain | Site
+
+COMMANDS: dict[str, Command] = {
+    "extract": Plain(cmd_extract),
+    "resolve": Plain(cmd_resolve),
+    "enumerate": Plain(cmd_enumerate),
+    "fetch": Plain(cmd_fetch),
+    "validate": Site(cmd_validate),
+}
+
+
+def main(argv: list[str]) -> int:
+    if not argv or argv[0] not in COMMANDS:
+        print(f"usage: {Path(sys.argv[0]).name} <{'|'.join(COMMANDS)}> [args]", file=sys.stderr)
+        return 2
+
+    progress = _Progress(started=monotonic())
+
+    def on_stop(signum: int, frame: FrameType | None) -> None:
+        # Ctrl-C: ask the running command to wind down for a partial report; a second Ctrl-C force-quits.
+        if progress.stop.is_set():
+            os._exit(130)  # 128 + SIGINT: abandon in-flight work and exit now, no traceback
+        progress.stop.set()
+        print("\nstopping (Ctrl-C again to force-quit)...", file=sys.stderr)
+
+    def on_status(signum: int, frame: FrameType | None) -> None:
+        print(_status_line(progress, monotonic()), file=sys.stderr)
+
+    previous_handlers = _install_signal_handlers(on_stop, on_status)
+    try:
+        # Match by capability, not per-command: a new Plain command needs no new arm. A future variant with no
+        # arm here falls through without returning, so mypy flags the missing return -- exhaustiveness for free.
+        match COMMANDS[argv[0]]:
+            case Plain(run):
+                return run(argv[1:], progress)
+            case Site(run):
+                return run(argv[1:], progress, config_loader.get_base_url)
+    finally:
+        _restore_signal_handlers(previous_handlers)
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/build_scripts/config_loader.py b/build_scripts/config_loader.py
index 1e28d22a2..28d0468ff 100644
--- a/build_scripts/config_loader.py
+++ b/build_scripts/config_loader.py
@@ -19,8 +19,8 @@
 LANGUAGE_METADATA_PATH = "metadata/language-metadata.json"
 
 # Cached configs
-_build_config: dict | None = None
-_redirects_config: dict | None = None
+_build_config: dict[str, Any] | None = None
+_redirects_config: dict[str, Any] | None = None
 
 
 def load_build_config(config_path: Path | str | None = None) -> dict[str, Any]:
@@ -45,7 +45,7 @@ def load_build_config(config_path: Path | str | None = None) -> dict[str, Any]:
         raise FileNotFoundError(f"Build config not found: {config_path}")
     
     with open(config_path, encoding="utf-8") as f:
-        config = json.load(f)
+        config: dict[str, Any] = json.load(f)
     
     if config_path == Path(BUILD_CONFIG_PATH):
         _build_config = config
@@ -74,7 +74,7 @@ def load_redirects_config(config_path: Path | str | None = None) -> dict[str, An
         raise FileNotFoundError(f"Redirects config not found: {config_path}")
     
     with open(config_path, encoding="utf-8") as f:
-        config = json.load(f)
+        config: dict[str, Any] = json.load(f)
     
     if config_path == Path(REDIRECTS_CONFIG_PATH):
         _redirects_config = config
@@ -82,28 +82,31 @@ def load_redirects_config(config_path: Path | str | None = None) -> dict[str, An
     return config
 
 
-def get_content_directories(config: dict | None = None) -> list[str]:
+def get_content_directories(config: dict[str, Any] | None = None) -> list[str]:
     """Get list of content directories that should be localized."""
     if config is None:
         config = load_build_config()
-    return config.get("contentDirectories", {}).get("directories", [])
+    directories: list[str] = config.get("contentDirectories", {}).get("directories", [])
+    return directories
 
 
-def get_shared_directories(config: dict | None = None) -> list[str]:
+def get_shared_directories(config: dict[str, Any] | None = None) -> list[str]:
     """Get list of shared directories (assets, api) that aren't translated."""
     if config is None:
         config = load_build_config()
-    return config.get("sharedDirectories", {}).get("directories", [])
+    directories: list[str] = config.get("sharedDirectories", {}).get("directories", [])
+    return directories
 
 
-def get_root_files(config: dict | None = None) -> list[str]:
+def get_root_files(config: dict[str, Any] | None = None) -> list[str]:
     """Get list of root-level files to copy/localize."""
     if config is None:
         config = load_build_config()
-    return config.get("rootFiles", {}).get("files", [])
+    files: list[str] = config.get("rootFiles", {}).get("files", [])
+    return files
 
 
-def get_legacy_shortcuts(config: dict | None = None) -> dict[str, str]:
+def get_legacy_shortcuts(config: dict[str, Any] | None = None) -> dict[str, str]:
     """Get legacy shortcut redirects (old URL → new URL).
     
     These are server-side 301 redirects for high-priority/vanity URLs.
@@ -116,7 +119,7 @@ def get_legacy_shortcuts(config: dict | None = None) -> dict[str, str]:
     return {k: v for k, v in redirects.items() if not k.startswith("_")}
 
 
-def get_client_redirects(config: dict | None = None) -> dict[str, str]:
+def get_client_redirects(config: dict[str, Any] | None = None) -> dict[str, str]:
     """Get client-side redirects for legacy content URLs.
     
     These are meta-refresh HTML redirects for content migration.
@@ -130,7 +133,7 @@ def get_client_redirects(config: dict | None = None) -> dict[str, str]:
     return {k: v for k, v in redirects.items() if not k.startswith("_")}
 
 
-def get_all_redirects(config: dict | None = None) -> dict[str, str]:
+def get_all_redirects(config: dict[str, Any] | None = None) -> dict[str, str]:
     """Get all redirects (both server and client) merged together.
     
     Returns a combined dict of all redirects. Server redirects take precedence
@@ -145,14 +148,15 @@ def get_all_redirects(config: dict | None = None) -> dict[str, str]:
     return all_redirects
 
 
-def get_default_language(config: dict | None = None) -> str:
+def get_default_language(config: dict[str, Any] | None = None) -> str:
     """Get the default language code."""
     if config is None:
         config = load_build_config()
-    return config.get("defaultLanguage", "en")
+    language: str = config.get("defaultLanguage", "en")
+    return language
 
 
-def get_base_url(config: dict | None = None) -> str:
+def get_base_url(config: dict[str, Any] | None = None) -> str:
     """Get the canonical base URL of the published site, without trailing slash.
 
     Used for canonical/hreflang tags, per-language sitemap baseUrls, and the
@@ -160,7 +164,7 @@ def get_base_url(config: dict | None = None) -> str:
     """
     if config is None:
         config = load_build_config()
-    base_url = config.get("baseUrl")
+    base_url: str | None = config.get("baseUrl")
     if not base_url:
         raise KeyError(
             '"baseUrl" is missing from metadata/build-config.json'
@@ -168,7 +172,7 @@ def get_base_url(config: dict | None = None) -> str:
     return base_url.rstrip("/")
 
 
-def get_sitemap_downrank(config: dict | None = None) -> list[dict]:
+def get_sitemap_downrank(config: dict[str, Any] | None = None) -> list[dict[str, Any]]:
     """Get sitemap downrank rules: a list of {match, priority} dicts.
 
     Each rule lowers the <priority> of sitemap URLs whose path contains the
@@ -176,10 +180,11 @@ def get_sitemap_downrank(config: dict | None = None) -> list[dict]:
     """
     if config is None:
         config = load_build_config()
-    return config.get("sitemap", {}).get("downrank", [])
+    downrank: list[dict[str, Any]] = config.get("sitemap", {}).get("downrank", [])
+    return downrank
 
 
-def get_sitemap_exclude(config: dict | None = None) -> list[dict]:
+def get_sitemap_exclude(config: dict[str, Any] | None = None) -> list[dict[str, Any]]:
     """Get sitemap exclude rules: a list of {match} dicts.
 
     Each rule removes sitemap URLs whose path contains the 'match' substring.
@@ -187,7 +192,8 @@ def get_sitemap_exclude(config: dict | None = None) -> list[dict]:
     """
     if config is None:
         config = load_build_config()
-    return config.get("sitemap", {}).get("exclude", [])
+    exclude: list[dict[str, Any]] = config.get("sitemap", {}).get("exclude", [])
+    return exclude
 
 
 def compute_file_hash(file_path: Path | str) -> str:
@@ -220,7 +226,7 @@ def get_all_content_files(content_dir: Path | str) -> list[Path]:
     if not content_dir.exists():
         return []
     
-    files = []
+    files: list[Path] = []
     for pattern in ["**/*.md", "**/*.yml", "**/*.yaml"]:
         files.extend(content_dir.glob(pattern))
     
diff --git a/build_scripts/csharp_doctest.py b/build_scripts/csharp_doctest.py
new file mode 100644
index 000000000..220c1be57
--- /dev/null
+++ b/build_scripts/csharp_doctest.py
@@ -0,0 +1,510 @@
+#!/usr/bin/env python3
+"""Validate the C# code blocks in the semantic-bridge how-to docs against the live TE CLI.
+
+Code blocks opt in via a fenced-code annotation (invisible in rendered docfx output):
+
+    ```csharp {compile}
+    ```csharp {run id=<slug> setup=<mv-sample|none> after=<id,...|none> output=<true|false>}
+
+Semantics:
+  - no annotation        -> skip (the only implicit behavior)
+  - {compile}            -> compile-only (te --dry-run); catches API drift, never executes
+  - {run ...}            -> execute; all four options are always required (no defaults)
+        id      unique slug, names the block for after= and for reporting
+        setup   a key in SETUP_SCRIPTS whose C# is prepended, or 'none'
+        after   comma-separated run ids replayed (flat, in order) before this block, or 'none'
+        output  'true' means the immediately-following plain fence is this block's
+                documented output -- compared in compare mode, rewritten in update mode
+
+Design: fences are parsed once into typed Block objects (the base Block is a skipped
+block; CompileBlock and RunBlock add behavior). Only the parser (_classify_fence) and
+the ref validator know the concrete kinds. Every command runs the same validate-first
+gate (_validate); validate then reports coverage, while compile/compare/update call
+block.check(mode) on every block -- each does its own work for that mode (skip: nothing;
+compile: compile-check; run: compile / execute-and-compare / execute-and-update) and
+reports an Outcome, which may carry an in-place fence edit (update mode). The functional
+core (parsing, plan, normalize, RunBlock._diff) is pure and independently testable; the
+imperative shell (Block.check, _run_mode, _write_with_edits, _report, main) does
+subprocess and file IO.
+
+Usage:
+    csharp_doctest.py <validate|compile|compare|update> <file>
+"""
+
+import difflib
+import re
+import sys
+from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
+from dataclasses import dataclass
+from pathlib import Path
+from typing import ClassVar, NamedTuple
+
+from te_script_runner import Result, Snippet, run_snippets
+
+# Setup scripts prepended before a {run setup=<key>} block. Hard-coded here for now;
+# a future revision may derive them differently. The mv-sample script deserializes the
+# sample Metric View from the how-to include, read at import so there is a single source
+# of truth (the doc's own sample) rather than a drift-prone embedded copy.
+_INCLUDE_DIR = Path(__file__).resolve().parent.parent / "content" / "how-tos" / "includes"
+
+
+def _deserialize_from(yaml_path: Path) -> str:
+    """A C# snippet that deserializes a Metric View from the given yaml file's contents."""
+    yaml = yaml_path.read_text(encoding="utf-8")
+    return f'SemanticBridge.MetricView.Deserialize("""\n{yaml}""");'
+
+
+SETUP_SCRIPTS = {
+    "mv-sample": _deserialize_from(_INCLUDE_DIR / "sample-metricview.yaml"),
+}
+
+# A {run} block must set exactly these options, in this order (no defaults).
+RUN_OPTIONS = ("id", "setup", "after", "output")
+_ALLOWED_SETUPS = {*SETUP_SCRIPTS, "none"}
+
+# Subcommands. compile/compare/update execute against te and double as the modes passed
+# to Block.check; validate only parses and reports coverage.
+_EXECUTE_MODES = ("compile", "compare", "update")
+_COMMANDS = ("validate", *_EXECUTE_MODES)
+
+
+class Fence(NamedTuple):
+    """One fenced code block: language, {...} annotation, body, 1-based opening line, and body line span."""
+
+    lang: str
+    annotation: str
+    code: str
+    line: int
+    body_start: int  # 1-based first body line (exceeds body_end when the body is empty)
+    body_end: int  # 1-based last body line
+
+
+class Edit(NamedTuple):
+    """An in-place rewrite of a fence body: replace 1-based lines [start, end] with text."""
+
+    start: int
+    end: int
+    text: str
+
+
+class Outcome(NamedTuple):
+    """Result of a block's check() for a subcommand: what to print, whether it passed, and any file edit."""
+
+    block: "Block"
+    action: str  # verb shown in the report: "compile" | "compare" | "update"
+    passed: bool
+    detail: list[str]  # failure detail (diffs, compile/runtime errors) printed under the report line on stdout
+    note: str = ""  # short status shown inline on the report line (e.g. "updated")
+    edit: "Edit | None" = None  # a fence rewrite, applied in update mode
+
+
+@dataclass(frozen=True)
+class Block:
+    """A classified code block. The base behavior is a skipped block; subclasses add
+    compile/run behavior. Callers other than the parser and ref validator use this
+    interface (label, summary, register_refs, check) rather than inspecting the kind."""
+
+    code: str
+    line: int
+    kind: ClassVar[str] = "skip"
+
+    @property
+    def label(self) -> str:
+        """Identifier shown in reports; blank when the line already identifies the block."""
+        return ""
+
+    def summary(self) -> str:
+        """One-line description for the validate report."""
+        return f"L{self.line}\t{self.kind}"
+
+    def register_refs(self, seen: set[str]) -> None:
+        """Validate this block's cross-references against ids seen so far, and record its own."""
+        return None
+
+    def check(self, mode: str, runs: "dict[str, RunBlock]") -> "Outcome | None":
+        """Do this block's work for the subcommand mode; return an Outcome, or None if nothing to do. Imperative shell."""
+        return None
+
+
+@dataclass(frozen=True)
+class CompileBlock(Block):
+    """A {compile} block: compile-checked in every mode (compare/update imply compile), never executed."""
+
+    kind: ClassVar[str] = "compile"
+
+    def check(self, mode: str, runs: "dict[str, RunBlock]") -> "Outcome | None":
+        # Compiled in every mode that implies compilation; strict otherwise, so an
+        # unrecognized mode fails loudly rather than silently skipping the block.
+        if mode in _EXECUTE_MODES:
+            return _compile_check(self)
+        raise ValueError(f"unknown mode: {mode}")
+
+
+@dataclass(frozen=True)
+class RunBlock(Block):
+    """A fully-specified {run} block. documented is the following plain fence's text when output is true."""
+
+    id: str
+    setup: str
+    after: tuple[str, ...]
+    output: bool
+    documented: str | None
+    documented_span: tuple[int, int] | None  # (start, end) 1-based body lines of the documented fence
+    kind: ClassVar[str] = "run"
+
+    @property
+    def label(self) -> str:
+        return self.id
+
+    def summary(self) -> str:
+        after = ",".join(self.after) or "none"
+        has_documented = "yes" if self.documented is not None else "no"
+        return (
+            f"L{self.line}\trun\tid={self.id} setup={self.setup} "
+            f"after={after} output={str(self.output).lower()} documented={has_documented}"
+        )
+
+    def register_refs(self, seen: set[str]) -> None:
+        if self.id in seen:
+            raise ValueError(f"duplicate run id: {self.id}")
+        for ref in self.after:
+            if ref not in seen:
+                raise ValueError(f"run {self.id!r} after={ref!r} is not a run id defined earlier")
+        seen.add(self.id)
+
+    def plan(self, runs: "dict[str, RunBlock]") -> list[str]:
+        """The ordered C# scripts to execute for this block: setup + replayed after-blocks + own code. Pure.
+
+        after is flat: only the listed blocks' own code is replayed, in order. This
+        block's setup (not the referenced blocks') governs the preamble.
+        """
+        scripts: list[str] = []
+        if self.setup != "none":
+            scripts.append(SETUP_SCRIPTS[self.setup])
+        scripts.extend(runs[ref].code for ref in self.after)
+        scripts.append(self.code)
+        return scripts
+
+    def check(self, mode: str, runs: "dict[str, RunBlock]") -> "Outcome | None":
+        if mode == "compile":
+            return _compile_check(self)
+        # last_only: report only this block's Output(), not the setup/after replay that
+        # shares its te session (otherwise a dependency's output leaks into the diff).
+        result = run_snippets([Snippet("expr", script) for script in self.plan(runs)], last_only=True)
+        if mode == "compare":
+            return self._compare(result)
+        if mode == "update":
+            return self._update(result)
+        raise ValueError(f"unknown mode: {mode}")
+
+    def _diff(self, result: Result) -> tuple[bool, str, list[str]]:
+        """Compare produced output against documented output. Pure given result.
+
+        Returns (matches, produced, diff_lines). The only place that pairs the documented
+        (in-doc) and produced (fresh) outputs; both compare and update consume it.
+        """
+        documented = normalize(self.documented or "")
+        produced = normalize(result.output)
+        if produced == documented:
+            return True, produced, []
+        diff = difflib.unified_diff(
+            documented.splitlines(),
+            produced.splitlines(),
+            fromfile="documented",
+            tofile="produced",
+            lineterm="",
+        )
+        return False, produced, list(diff)
+
+    def _compare(self, result: Result) -> Outcome:
+        """compare-mode verdict: produced output must match the documented fence. Pure given result."""
+        if not result.success:
+            return Outcome(self, "compare", False, result.diagnostics)
+        if not self.output:
+            return Outcome(self, "compare", True, [])
+        matches, _, diff = self._diff(result)
+        return Outcome(self, "compare", matches, diff)
+
+    def _update(self, result: Result) -> Outcome:
+        """update-mode verdict plus a fence edit; the command applies the edit. Pure given result.
+
+        A failed run is reported without touching the doc. A matching or output=false
+        block needs no edit; otherwise the documented fence is rewritten with produced output.
+        """
+        if not result.success:
+            return Outcome(self, "update", False, result.diagnostics)
+        if not self.output or self.documented_span is None:
+            return Outcome(self, "update", True, [], note="no output")
+        matches, produced, _ = self._diff(result)
+        if matches:
+            return Outcome(self, "update", True, [], note="unchanged")
+        start, end = self.documented_span
+        return Outcome(self, "update", True, [], note="updated", edit=Edit(start, end, produced))
+
+
+def _annotation(info: str) -> str:
+    """The text inside the first {...} of a fence info string, or '' if there is none. Pure."""
+    open_brace = info.find("{")
+    close_brace = info.rfind("}")
+    if open_brace != -1 and close_brace > open_brace:
+        return info[open_brace + 1 : close_brace].strip()
+    return ""
+
+
+def parse_fences(markdown: str) -> list[Fence]:
+    """Extract every fenced code block from markdown, in order. Pure.
+
+    A line whose first non-space content is ``` toggles a fence. The opening fence's
+    remaining text is its info string; its first token is the language ('' for a plain
+    fence) and any {...} is the annotation.
+    """
+    fences: list[Fence] = []
+    lines = markdown.splitlines()
+    index = 0
+    while index < len(lines):
+        if not lines[index].lstrip().startswith("```"):
+            index += 1
+            continue
+        info = lines[index].lstrip()[3:].strip()
+        open_line = index + 1
+        body: list[str] = []
+        index += 1
+        body_start = index + 1  # 1-based first body line
+        while index < len(lines) and not lines[index].lstrip().startswith("```"):
+            body.append(lines[index])
+            index += 1
+        body_end = index  # 1-based last body line (< body_start when the body is empty)
+        lang = "" if not info or info.startswith("{") else info.split(None, 1)[0]
+        fences.append(Fence(lang, _annotation(info), "\n".join(body), open_line, body_start, body_end))
+        index += 1  # step past the closing fence
+    return fences
+
+
+def _parse_run_options(annotation: str) -> dict[str, str]:
+    """Parse and validate a {run ...} annotation's four options into a dict. Pure.
+
+    Every option is required with a valid value -- there are no defaults, so an
+    incompletely specified block is an error rather than a silent assumption.
+    """
+    params: dict[str, str] = {}
+    for token in annotation.split()[1:]:  # [0] is "run"
+        if "=" not in token:
+            raise ValueError(f"run option is not key=value: {token!r}")
+        key, value = token.split("=", 1)
+        if key in params:
+            raise ValueError(f"run block has duplicate option: {key}")
+        params[key] = value
+    missing = [opt for opt in RUN_OPTIONS if opt not in params]
+    if missing:
+        raise ValueError(f"run block missing required options: {', '.join(missing)}")
+    unknown = [key for key in params if key not in RUN_OPTIONS]
+    if unknown:
+        raise ValueError(f"run block has unknown options: {', '.join(unknown)}")
+    if params["id"] == "none":
+        raise ValueError("run block id must not be 'none' (reserved sentinel for after=none)")
+    # A slug id keeps ids clean and, by excluding commas, avoids colliding with the
+    # after= separator (a comma'd id would be unreferenceable). Also rejects empty ids.
+    if not re.fullmatch(r"[A-Za-z0-9_-]+", params["id"]):
+        raise ValueError(f"run block id must be a slug of letters, digits, - or _, got {params['id']!r}")
+    if params["setup"] not in _ALLOWED_SETUPS:
+        raise ValueError(f"run block setup={params['setup']} is not a known setup key")
+    if params["output"] not in ("true", "false"):
+        raise ValueError(f"run block output must be true or false, got {params['output']!r}")
+    return params
+
+
+def _make_run_block(annotation: str, code: str, line: int, following: Fence | None) -> RunBlock:
+    """Build a validated RunBlock, resolving documented output from the following plain fence. Pure."""
+    params = _parse_run_options(annotation)
+    output = params["output"] == "true"
+    documented: str | None = None
+    documented_span: tuple[int, int] | None = None
+    if output:
+        if following is None or following.lang != "":
+            raise ValueError(
+                f"run block {params['id']!r} (line {line}) has output=true "
+                "but is not immediately followed by a plain output fence"
+            )
+        documented = following.code
+        documented_span = (following.body_start, following.body_end)
+    after = () if params["after"] == "none" else tuple(params["after"].split(","))
+    return RunBlock(
+        code=code,
+        line=line,
+        id=params["id"],
+        setup=params["setup"],
+        after=after,
+        output=output,
+        documented=documented,
+        documented_span=documented_span,
+    )
+
+
+def _classify_fence(fence: Fence, following: Fence | None) -> Block | None:
+    """Turn one fence into its typed Block, or None if it is not an actionable block. Pure.
+
+    This and _make_run_block are the only places that map annotations to kinds.
+    """
+    if fence.lang != "csharp":
+        # compile/run are only meaningful on csharp; flag them elsewhere rather than
+        # silently ignoring a block the author expected to be executed.
+        first = fence.annotation.split(None, 1)[0] if fence.annotation else ""
+        if first in ("compile", "run"):
+            raise ValueError(
+                f"{first} annotation is only valid on a csharp block "
+                f"(line {fence.line}, lang={fence.lang or 'plain'})"
+            )
+        return None
+    annotation = fence.annotation
+    if annotation == "":
+        return Block(fence.code, fence.line)  # untagged -> base block (skip)
+    if annotation == "compile":
+        return CompileBlock(fence.code, fence.line)
+    if annotation == "run" or annotation.startswith("run "):
+        return _make_run_block(annotation, fence.code, fence.line, following)
+    raise ValueError(f"unknown code-block annotation: {{{annotation}}}")
+
+
+def build_blocks(fences: list[Fence]) -> list[Block]:
+    """Classify the csharp fences into typed Blocks and validate cross-references. Pure."""
+    blocks: list[Block] = []
+    for position, fence in enumerate(fences):
+        following = fences[position + 1] if position + 1 < len(fences) else None
+        block = _classify_fence(fence, following)
+        if block is not None:
+            blocks.append(block)
+    seen: set[str] = set()
+    for block in blocks:
+        block.register_refs(seen)
+    return blocks
+
+
+def kind_counts(blocks: list[Block]) -> Counter[str]:
+    """Count blocks by kind. Pure."""
+    return Counter(block.kind for block in blocks)
+
+
+def index_runs(blocks: list[Block]) -> dict[str, RunBlock]:
+    """Map each run block's id to itself, in document order. Pure.
+
+    This is the one place that selects run blocks by type; callers use the map so an
+    after= reference resolves to the block whose code should be replayed.
+    """
+    return {block.id: block for block in blocks if isinstance(block, RunBlock)}
+
+
+def normalize(text: str) -> str:
+    """Normalize output for comparison. Pure.
+
+    Strict but forgiving of incidental whitespace: strip trailing whitespace from each
+    line and drop trailing blank lines. Interior content must match exactly.
+    """
+    lines = [line.rstrip() for line in text.splitlines()]
+    while lines and not lines[-1]:
+        lines.pop()
+    return "\n".join(lines)
+
+
+def _compile_check(block: Block) -> Outcome:
+    """Compile-check a single block's code via te --dry-run (no execution). Imperative shell."""
+    result = run_snippets([Snippet("expr", block.code)], dry_run=True)
+    return Outcome(block, "compile", result.success, [] if result.success else result.diagnostics)
+
+
+def _report(outcomes: list[Outcome]) -> int:
+    """Print each outcome and a summary; return 1 if any failed. Imperative shell.
+
+    Verdicts, failure detail (diffs, compile/runtime errors), and the summary are the
+    report -- all on stdout. Only harness-operational problems go to stderr (raised and
+    handled in main), matching how test runners like pytest/go test stream results.
+    """
+    failures = 0
+    for outcome in outcomes:
+        status = "PASS" if outcome.passed else "FAIL"
+        tail = f" {outcome.block.label}" if outcome.block.label else ""
+        note = f" ({outcome.note})" if outcome.note else ""
+        print(f"L{outcome.block.line}\t{status}\t{outcome.action}{tail}{note}")
+        if not outcome.passed:
+            failures += 1
+            for line in outcome.detail:
+                print(f"    {line}")
+    print(f"# {len(outcomes)} block(s): {len(outcomes) - failures} pass, {failures} fail")
+    return 1 if failures else 0
+
+
+def _validate(path: str) -> tuple[str, list[Fence], list[Block]]:
+    """Parse and validate a doc's code-block annotations. Returns (text, fences, blocks). Imperative shell (reads the file).
+
+    build_blocks raises on any malformed block, so this is the gate every command runs
+    first -- compile/compare/update never touch te for a doc whose annotations are invalid.
+    """
+    text = Path(path).read_text(encoding="utf-8")
+    fences = parse_fences(text)
+    blocks = build_blocks(fences)
+    return text, fences, blocks
+
+
+def _run_mode(path: str, text: str, blocks: list[Block], mode: str) -> int:
+    """Run compile/compare/update over already-validated blocks; apply edits; report. Imperative shell.
+
+    Each block shells out to te against its own isolated model, so blocks are checked
+    concurrently (one thread per block -- a doc has few). Results are gathered in
+    document order; any fence edits (update mode) are then applied to the file in place,
+    single-threaded.
+    """
+    runs = index_runs(blocks)
+    with ThreadPoolExecutor(max_workers=max(1, len(blocks))) as pool:
+        results = list(pool.map(lambda block: block.check(mode, runs), blocks))
+    outcomes = [outcome for outcome in results if outcome is not None]
+    edits = [outcome.edit for outcome in outcomes if outcome.edit is not None]
+    if edits:
+        _write_with_edits(path, text, edits)
+    return _report(outcomes)
+
+
+def _write_with_edits(path: str, text: str, edits: list[Edit]) -> None:
+    """Apply fence-body rewrites to the file in place, bottom-up so line numbers stay valid. Imperative shell."""
+    lines = text.splitlines()
+    for edit in sorted(edits, key=lambda e: e.start, reverse=True):
+        lines[edit.start - 1 : edit.end] = edit.text.split("\n") if edit.text else []
+    Path(path).write_text("\n".join(lines) + ("\n" if text.endswith("\n") else ""), encoding="utf-8")
+
+
+def _coverage(fences: list[Fence], blocks: list[Block]) -> None:
+    """Print the validate report: one line per block plus coverage counts. Imperative shell."""
+    for block in blocks:
+        print(block.summary())
+    counts = kind_counts(blocks)
+    csharp = sum(1 for fence in fences if fence.lang == "csharp")
+    breakdown = ", ".join(f"{counts[kind]} {kind}" for kind in ("run", "compile", "skip"))
+    print(f"# {len(fences)} code blocks found ({csharp} csharp) | valid: {breakdown}")
+
+
+def main(argv: list[str]) -> int:
+    # One dispatcher for every subcommand. They share the single-path contract, the
+    # filename header (so batch runs like `xargs -n1` attribute each result to its file),
+    # and the validate-first gate. validate stops after the coverage report; the execute
+    # commands pass their own name to _run_mode as the block.check() mode.
+    if not argv or argv[0] not in _COMMANDS:
+        print(f"usage: {Path(sys.argv[0]).name} <{'|'.join(_COMMANDS)}> <file>", file=sys.stderr)
+        return 2
+    command, rest = argv[0], argv[1:]
+    if len(rest) != 1:
+        print(f"{command} requires exactly one markdown file path", file=sys.stderr)
+        return 2
+    path = rest[0]
+    print(path)
+    try:
+        text, fences, blocks = _validate(path)
+        if command == "validate":
+            _coverage(fences, blocks)
+            return 0
+        return _run_mode(path, text, blocks, command)
+    except (OSError, ValueError, RuntimeError) as exc:
+        print(f"csharp_doctest: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/build_scripts/te_script_runner.py b/build_scripts/te_script_runner.py
new file mode 100755
index 000000000..98f7f2f24
--- /dev/null
+++ b/build_scripts/te_script_runner.py
@@ -0,0 +1,381 @@
+#!/usr/bin/env python3
+"""Run C# script snippets against a throwaway, empty semantic model via the TE CLI.
+
+Two uses:
+
+1. Standalone CLI (a subcommand is required):
+       te_script_runner.py run -e '<C# expr>'                # execute
+       te_script_runner.py run -f a.cs -e '<expr>' -f b.cs   # many, in order
+       te_script_runner.py check -f a.cs                     # compile-check only, no execution
+       cat snippet.cs | te_script_runner.py run              # one snippet on stdin
+   run and check take the same script arguments.
+
+2. Importable by an orchestrator (e.g. a semantic-bridge doc runner):
+       from te_script_runner import Snippet, run_snippets
+       result = run_snippets([Snippet("expr", preamble), Snippet("file", "block.cs")])
+
+The functional core (summarize and its helpers) is pure and independently
+testable; the imperative shell (init_model, run_snippets, the cmd_* wrappers)
+does subprocess, filesystem, and printing. Every layer is exposed as a COMMANDS
+subcommand so it can be exercised on its own.
+
+Snippets always run against a fresh empty model with no --save: nothing is
+persisted and nothing outside the throwaway directory is touched. Callers that
+need setup (e.g. a loaded Metric View) pass it as the first snippet.
+
+Usage:
+    te_script_runner.py <command> [args]
+"""
+
+import json
+import shutil
+import subprocess
+import sys
+import tempfile
+from collections.abc import Sequence
+from pathlib import Path
+from typing import Any, NamedTuple
+
+DEFAULT_TE_BIN = "te"
+_WORKDIR_PREFIX = "te-script-run."
+# Emitted between the next-to-last and last script when last_only is set, so the runner
+# can report only the final script's output. Chosen to be absent from any real output.
+_OUTPUT_BOUNDARY = "<<<te-script-runner-output-boundary>>>"
+
+
+class Result(NamedTuple):
+    """Outcome of a script run, distilled from te's --output-format json stdout.
+
+    output is the snippets' Output() text (newline-joined) -- what a caller
+    compares against expected. diagnostics are tagged non-output lines (compile
+    errors, runtime error, other messages) derived from the json. te's own stderr
+    is never captured -- it inherits the parent's stderr and always prints in full
+    -- so it does not appear here.
+    """
+
+    exit_code: int
+    success: bool
+    output: str
+    diagnostics: list[str]
+
+
+class Snippet(NamedTuple):
+    """One C# snippet: an inline expression (kind='expr') or a path to a file (kind='file')."""
+
+    kind: str
+    value: str
+
+
+def _parse_json(stdout: str) -> dict[str, Any] | None:
+    """te's json object, or None if stdout is empty or not a json object. Pure."""
+    if not stdout.strip():
+        return None
+    try:
+        parsed = json.loads(stdout)
+    except json.JSONDecodeError:
+        return None
+    return parsed if isinstance(parsed, dict) else None
+
+
+def _output_lines(data: dict[str, Any]) -> list[str]:
+    """The text of every output-level message, in order. Pure."""
+    messages = data.get("messages") or []
+    return [
+        str(m.get("text", ""))
+        for m in messages
+        if isinstance(m, dict) and m.get("level") == "output"
+    ]
+
+
+def _diagnostic_lines(data: dict[str, Any]) -> list[str]:
+    """Tagged non-output diagnostics: compile errors, runtime error, other messages. Pure.
+
+    te reports failures in three shapes -- compileErrors[], a runtimeError string,
+    and non-output messages[] -- and any of them can be present, so all three are
+    surfaced rather than only the first.
+    """
+    lines = [f"[compile-error] {e}" for e in data.get("compileErrors") or []]
+    runtime_error = data.get("runtimeError")
+    if runtime_error:
+        lines.append(f"[runtime-error] {runtime_error}")
+    lines += [
+        f"[{m.get('level')}] {m.get('text')}"
+        for m in data.get("messages") or []
+        if isinstance(m, dict) and m.get("level") != "output"
+    ]
+    return lines
+
+
+def _summarize_dry_run(data: dict[str, Any], exit_code: int) -> Result:
+    """Compile-only (--dry-run) results into a Result. Pure.
+
+    --dry-run reports a different shape than an executed run: a per-script
+    success/errors list under "scripts" and no messages, because nothing runs.
+    There is therefore no output; a compile failure in any script fails the whole.
+    """
+    scripts = data.get("scripts") or []
+    diagnostics: list[str] = []
+    all_ok = True
+    for script in scripts:
+        if not isinstance(script, dict):
+            continue
+        all_ok = all_ok and bool(script.get("success", False))
+        source = str(script.get("source", "<script>"))
+        diagnostics += [f"[compile-error] {source}: {e}" for e in script.get("errors") or []]
+    return Result(exit_code=exit_code, success=all_ok, output="", diagnostics=diagnostics)
+
+
+def summarize(stdout: str, exit_code: int) -> Result:
+    """Turn te's json stdout and exit code into a Result. Pure functional core.
+
+    Handles both te json shapes: an executed run (messages/compileErrors/
+    runtimeError) and a compile-only --dry-run (dryRun/scripts). When te emits no
+    json but failed, that fact is itself surfaced as a diagnostic so a failure is
+    never silently swallowed.
+    """
+    data = _parse_json(stdout)
+    if data is None:
+        diagnostics = (
+            [f"[te] failed with exit {exit_code} and no json output"]
+            if exit_code != 0
+            else []
+        )
+        return Result(exit_code, exit_code == 0, "", diagnostics)
+    if data.get("dryRun"):
+        return _summarize_dry_run(data, exit_code)
+    return Result(
+        exit_code=exit_code,
+        success=bool(data.get("success", exit_code == 0)),
+        output="\n".join(_output_lines(data)),
+        diagnostics=_diagnostic_lines(data),
+    )
+
+
+def parse_snippet_args(args: Sequence[str]) -> list[Snippet]:
+    """Parse repeated -e/-f arguments into ordered Snippets. Pure.
+
+    Order across -e and -f is preserved because the run relies on handing te one
+    ordered --script list (te otherwise runs all --script before all -e).
+    """
+    snippets: list[Snippet] = []
+    index = 0
+    while index < len(args):
+        flag = args[index]
+        if flag in ("-e", "--expression"):
+            kind = "expr"
+        elif flag in ("-f", "--file"):
+            kind = "file"
+        else:
+            raise ValueError(f"unexpected argument: {flag}")
+        if index + 1 >= len(args):
+            raise ValueError(f"{flag} requires a value")
+        snippets.append(Snippet(kind, args[index + 1]))
+        index += 2
+    return snippets
+
+
+def _emit(result: Result) -> int:
+    """Write a Result to the real streams the way the standalone CLI should. Imperative shell.
+
+    te's own stderr has already streamed through (it is never captured), so this
+    only adds the snippets' Output() to stdout and the derived diagnostics to stderr.
+    """
+    if result.output:
+        print(result.output)
+    if result.diagnostics:
+        print("\n".join(result.diagnostics), file=sys.stderr)
+    return result.exit_code
+
+
+def init_model(model_path: Path, *, te_bin: str = DEFAULT_TE_BIN) -> Path:
+    """Create an empty single-file .bim model at model_path and return its path. Imperative shell.
+
+    Adds no output of its own: te init's stdout summary is discarded (the throwaway
+    model is an implementation detail). Its stderr inherits the parent's and prints
+    in full. Raises on failure; the detail has already printed on stderr.
+    """
+    proc = subprocess.run(
+        [te_bin, "init", str(model_path), "--serialization", "bim"],
+        stdout=subprocess.DEVNULL,
+        text=True,
+    )
+    if proc.returncode != 0:
+        raise RuntimeError(f"te init failed (exit {proc.returncode}); see stderr above")
+    return model_path
+
+
+def materialize(snippets: Sequence[Snippet], snippet_dir: Path) -> list[Path]:
+    """Write every snippet to a .cs file under snippet_dir, preserving order. Imperative shell.
+
+    Inline expressions become numbered files; file snippets are used in place after
+    an existence check. All are handed to te as --script (see parse_snippet_args).
+    """
+    snippet_dir.mkdir(parents=True, exist_ok=True)
+    files: list[Path] = []
+    for index, snippet in enumerate(snippets, start=1):
+        if snippet.kind == "expr":
+            path = snippet_dir / f"{index:02d}-inline.cs"
+            path.write_text(snippet.value + "\n", encoding="utf-8")
+        else:
+            path = Path(snippet.value)
+            if not path.is_file():
+                raise FileNotFoundError(f"script file not found: {snippet.value}")
+        files.append(path)
+    return files
+
+
+def run_te_script(
+    model_path: Path,
+    script_files: Sequence[Path],
+    *,
+    te_bin: str = DEFAULT_TE_BIN,
+    dry_run: bool = False,
+) -> tuple[int, str]:
+    """Run script files in order against model_path in one te session. Imperative shell.
+
+    Returns (exit_code, json_stdout). One session means mutations carry across the
+    files. With dry_run, te compiles the scripts and reports errors without executing
+    them (a different json shape; summarize handles both). stdout is captured for
+    summarize; stderr inherits the parent's and prints in full. No --save, so nothing
+    is persisted.
+    """
+    cmd = [te_bin, "--output-format", "json", "script", str(model_path)]
+    for path in script_files:
+        cmd += ["--script", str(path)]
+    if dry_run:
+        cmd.append("--dry-run")
+    proc = subprocess.run(cmd, stdout=subprocess.PIPE, text=True)
+    return proc.returncode, proc.stdout
+
+
+def _keep_after_boundary(result: Result) -> Result:
+    """Drop everything up to and including the last-only boundary marker. Pure.
+
+    The scripts run in one te session (the only way shared state, e.g. a loaded Metric
+    View, survives), so te reports every script's output in one flat list. To report
+    only the final script's output, a boundary marker is emitted just before it and
+    everything up to it is dropped here.
+
+    A failed run (any script errors -> te stops) is returned unchanged, with the full
+    output and diagnostics -- the whole invocation failed. If the run succeeded but the
+    marker is missing, that is also treated as a failure rather than silently trusted.
+    """
+    if not result.success:
+        return result
+    lines = result.output.split("\n") if result.output else []
+    if _OUTPUT_BOUNDARY not in lines:
+        return result._replace(
+            exit_code=result.exit_code or 1,
+            success=False,
+            diagnostics=[*result.diagnostics, "[harness] output boundary marker missing"],
+        )
+    cut = len(lines) - 1 - lines[::-1].index(_OUTPUT_BOUNDARY)  # last occurrence is ours
+    return result._replace(output="\n".join(lines[cut + 1 :]))
+
+
+def run_snippets(
+    snippets: Sequence[Snippet],
+    *,
+    te_bin: str = DEFAULT_TE_BIN,
+    keep_workdir: bool = False,
+    dry_run: bool = False,
+    last_only: bool = False,
+) -> Result:
+    """Run snippets in order against one fresh, empty .bim model; return a Result. Imperative shell.
+
+    This is the importable entry point. With dry_run the snippets are compiled but not
+    executed (Result.output is empty; compile errors land in Result.diagnostics). With
+    last_only, only the final snippet's Output() is reported (earlier snippets are setup
+    whose output is noise); this is done by emitting a boundary marker before the last
+    script and dropping everything up to it -- necessary because the snippets share one
+    te session and te reports all their output in one flat list. It adds no output of its
+    own (only te's inherited stderr streams through), so an orchestrator can consume the
+    Result as data. The throwaway directory is always removed unless keep_workdir. Raises
+    if te is missing or the model cannot be created.
+    """
+    if not snippets:
+        raise ValueError("run_snippets requires at least one snippet")
+    if shutil.which(te_bin) is None:
+        raise FileNotFoundError(f"{te_bin!r} (Tabular Editor CLI) not found on PATH")
+    workdir = Path(tempfile.mkdtemp(prefix=_WORKDIR_PREFIX))
+    try:
+        model_path = init_model(workdir / "model.bim", te_bin=te_bin)
+        snippet_dir = workdir / "snippets"
+        script_files = materialize(snippets, snippet_dir)
+        bounded = last_only and not dry_run and len(script_files) > 1
+        if bounded:
+            boundary = snippet_dir / "00-boundary.cs"
+            boundary.write_text(f'Output("{_OUTPUT_BOUNDARY}");\n', encoding="utf-8")
+            script_files = [*script_files[:-1], boundary, script_files[-1]]
+        exit_code, stdout = run_te_script(model_path, script_files, te_bin=te_bin, dry_run=dry_run)
+        result = summarize(stdout, exit_code)
+        return _keep_after_boundary(result) if bounded else result
+    finally:
+        if keep_workdir:
+            print(f"[keep] throwaway dir retained: {workdir}", file=sys.stderr)
+        else:
+            shutil.rmtree(workdir, ignore_errors=True)
+
+
+def _gather_snippets(args: list[str]) -> tuple[list[Snippet], bool]:
+    """Parse the shared -e/-f/--keep args (or read one snippet from stdin). Returns (snippets, keep).
+
+    run and check take identical script arguments; this is where that shared parse lives.
+    """
+    keep = "--keep" in args
+    snippets = parse_snippet_args([a for a in args if a != "--keep"])
+    if not snippets:
+        if sys.stdin.isatty():
+            raise ValueError("no snippet provided; use -e, -f, or pipe C# on stdin")
+        snippets = [Snippet("expr", sys.stdin.read())]
+    return snippets, keep
+
+
+def cmd_run(args: list[str]) -> int:
+    """Execute snippets from -e/-f (in order) or stdin against a throwaway model. --keep retains the dir."""
+    snippets, keep = _gather_snippets(args)
+    return _emit(run_snippets(snippets, keep_workdir=keep))
+
+
+def cmd_check(args: list[str]) -> int:
+    """Compile-check snippets from -e/-f (in order) or stdin without executing them. --keep retains the dir."""
+    snippets, keep = _gather_snippets(args)
+    return _emit(run_snippets(snippets, keep_workdir=keep, dry_run=True))
+
+
+def cmd_init(args: list[str]) -> int:
+    """Create an empty .bim model at <path> and print the path (for testing the init step)."""
+    if not args:
+        raise ValueError("init requires a model path")
+    print(init_model(Path(args[0])))
+    return 0
+
+
+def cmd_summarize(args: list[str]) -> int:
+    """Summarize te json from <file> (or stdin if '-'), at optional [exit_code] (default 0)."""
+    stdout = sys.stdin.read() if not args or args[0] == "-" else Path(args[0]).read_text(encoding="utf-8")
+    exit_code = int(args[1]) if len(args) > 1 else 0
+    return _emit(summarize(stdout, exit_code))
+
+
+COMMANDS = {
+    "run": cmd_run,
+    "check": cmd_check,
+    "init": cmd_init,
+    "summarize": cmd_summarize,
+}
+
+
+def main(argv: list[str]) -> int:
+    if not argv or argv[0] not in COMMANDS:
+        print(f"usage: {Path(sys.argv[0]).name} <{'|'.join(COMMANDS)}> [args]", file=sys.stderr)
+        return 2
+    try:
+        return COMMANDS[argv[0]](argv[1:])
+    except (OSError, ValueError, RuntimeError) as exc:
+        print(f"te_script_runner: {exc}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/build_scripts/test-fixtures/doc-compile-drift.md b/build_scripts/test-fixtures/doc-compile-drift.md
new file mode 100644
index 000000000..0af2190b9
--- /dev/null
+++ b/build_scripts/test-fixtures/doc-compile-drift.md
@@ -0,0 +1,13 @@
+# Compile drift
+
+Good compile block:
+
+```csharp {compile}
+var view = SemanticBridge.MetricView.Model;
+```
+
+Run block that calls a nonexistent API (compile FAIL):
+
+```csharp {run id=bad setup=none after=none output=false}
+SemanticBridge.MetricView.NoSuchMethod();
+```
diff --git a/build_scripts/test-fixtures/doc-mismatch.md b/build_scripts/test-fixtures/doc-mismatch.md
new file mode 100644
index 000000000..6a756b5cf
--- /dev/null
+++ b/build_scripts/test-fixtures/doc-mismatch.md
@@ -0,0 +1,9 @@
+# Mismatch
+
+```csharp {run id=wrong setup=none after=none output=true}
+Output("actual text");
+```
+**Output:**
+```
+expected text
+```
diff --git a/build_scripts/test-fixtures/doc-valid.md b/build_scripts/test-fixtures/doc-valid.md
new file mode 100644
index 000000000..d79dd1352
--- /dev/null
+++ b/build_scripts/test-fixtures/doc-valid.md
@@ -0,0 +1,35 @@
+# Valid doc
+
+Untagged csharp block is skipped:
+
+```csharp
+Output("ignored by the harness");
+```
+
+Compile-only block:
+
+```csharp {compile}
+var view = SemanticBridge.MetricView.Model;
+```
+
+Run block with expected output:
+
+```csharp {run id=first setup=mv-sample after=none output=true}
+Output("hello from a run block");
+```
+**Output:**
+```
+hello from a run block
+```
+
+Chained run block, no output assertion:
+
+```csharp {run id=second setup=none after=first output=false}
+Output("chained after first");
+```
+
+A non-csharp block is ignored:
+
+```yaml
+version: 1.1
+```
diff --git a/build_scripts/test-fixtures/err-missing-option.md b/build_scripts/test-fixtures/err-missing-option.md
new file mode 100644
index 000000000..115488fa2
--- /dev/null
+++ b/build_scripts/test-fixtures/err-missing-option.md
@@ -0,0 +1,3 @@
+```csharp {run id=x setup=none output=true}
+Output(1);
+```
diff --git a/build_scripts/test-fixtures/err-no-output-fence.md b/build_scripts/test-fixtures/err-no-output-fence.md
new file mode 100644
index 000000000..704629e03
--- /dev/null
+++ b/build_scripts/test-fixtures/err-no-output-fence.md
@@ -0,0 +1,5 @@
+```csharp {run id=x setup=none after=none output=true}
+Output(1);
+```
+
+No output fence follows this run block.
diff --git a/build_scripts/test-fixtures/err-run-on-yaml.md b/build_scripts/test-fixtures/err-run-on-yaml.md
new file mode 100644
index 000000000..21cb44cbe
--- /dev/null
+++ b/build_scripts/test-fixtures/err-run-on-yaml.md
@@ -0,0 +1,3 @@
+```yaml {compile}
+version: 1
+```
diff --git a/build_scripts/test-fixtures/err-unknown-after.md b/build_scripts/test-fixtures/err-unknown-after.md
new file mode 100644
index 000000000..c689fa424
--- /dev/null
+++ b/build_scripts/test-fixtures/err-unknown-after.md
@@ -0,0 +1,3 @@
+```csharp {run id=x setup=none after=nope output=false}
+Output(1);
+```
diff --git a/build_scripts/test-fixtures/err-unknown-annotation.md b/build_scripts/test-fixtures/err-unknown-annotation.md
new file mode 100644
index 000000000..5db65c4df
--- /dev/null
+++ b/build_scripts/test-fixtures/err-unknown-annotation.md
@@ -0,0 +1,3 @@
+```csharp {check}
+Output(1);
+```
diff --git a/build_scripts/test-fixtures/te-compile-error.json b/build_scripts/test-fixtures/te-compile-error.json
new file mode 100644
index 000000000..2b6ecbf7a
--- /dev/null
+++ b/build_scripts/test-fixtures/te-compile-error.json
@@ -0,0 +1 @@
+{"success":false,"compileErrors":["error: ; expected"],"messages":[]}
diff --git a/build_scripts/test-fixtures/te-dryrun-fail.json b/build_scripts/test-fixtures/te-dryrun-fail.json
new file mode 100644
index 000000000..95ae1b8a0
--- /dev/null
+++ b/build_scripts/test-fixtures/te-dryrun-fail.json
@@ -0,0 +1 @@
+{"dryRun":true,"scripts":[{"source":"01-inline.cs","success":false,"errors":["error: no method 'Foo'"]},{"source":"02-inline.cs","success":true,"errors":[]}]}
diff --git a/build_scripts/test-fixtures/te-dryrun-ok.json b/build_scripts/test-fixtures/te-dryrun-ok.json
new file mode 100644
index 000000000..ad720b1ae
--- /dev/null
+++ b/build_scripts/test-fixtures/te-dryrun-ok.json
@@ -0,0 +1 @@
+{"dryRun":true,"scripts":[{"source":"01-inline.cs","success":true,"errors":[]}]}
diff --git a/build_scripts/test-fixtures/te-run-ok.json b/build_scripts/test-fixtures/te-run-ok.json
new file mode 100644
index 000000000..23377318d
--- /dev/null
+++ b/build_scripts/test-fixtures/te-run-ok.json
@@ -0,0 +1 @@
+{"success":true,"durationMs":10,"scriptsExecuted":1,"messages":[{"level":"output","text":"line1"},{"level":"output","text":"line2"}],"saved":false}
diff --git a/build_scripts/test-fixtures/te-runtime-error.json b/build_scripts/test-fixtures/te-runtime-error.json
new file mode 100644
index 000000000..8d1ad623e
--- /dev/null
+++ b/build_scripts/test-fixtures/te-runtime-error.json
@@ -0,0 +1 @@
+{"success":false,"runtimeError":"boom","compileErrors":[],"messages":[{"level":"info","text":"note"}]}
diff --git a/configuration/filterConfig.yml b/configuration/filterConfig.yml
index a7f328cb6..e5a14ebba 100644
--- a/configuration/filterConfig.yml
+++ b/configuration/filterConfig.yml
@@ -32,6 +32,10 @@ apiRules:
 - exclude:
     uidRegex: ^TabularEditor\.SemanticBridge\.Platforms\.Databricks\.Mapping
     type: Namespace
+# ANTLR-generated SQL lexer/parser/visitor types (public by generation, not public API)
+- exclude:
+    uidRegex: ^TabularEditor\.SemanticBridge\.Platforms\.Databricks\.Sql
+    type: Namespace
 - exclude:
     uidRegex: ^TabularEditor\.SemanticBridge\.Platforms\.Databricks\.MetricView\.Extensions
     type: Namespace
diff --git a/content/_apiSource/SemanticBridge.dll b/content/_apiSource/SemanticBridge.dll
index bc51edf82..1ab106850 100644
Binary files a/content/_apiSource/SemanticBridge.dll and b/content/_apiSource/SemanticBridge.dll differ
diff --git a/content/_apiSource/SemanticBridge.xml b/content/_apiSource/SemanticBridge.xml
index b62ada949..f86b782e2 100644
--- a/content/_apiSource/SemanticBridge.xml
+++ b/content/_apiSource/SemanticBridge.xml
@@ -4,272 +4,419 @@
         <name>SemanticBridge</name>
     </assembly>
     <members>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.BaseModelObject">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression">
             <summary>
-                Base record for model objects with common properties
+                Structural surface for a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" /> body. Lives
+                alongside the platform-keyed <c>Expressions</c> dict on
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" />: the AAST is the structural shape;
+                the dict carries the per-platform source text that the AAST does not
+                yet model. <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> wraps any shape the AAST
+                doesn't yet model structurally.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.BaseModelObject.#ctor(System.String,System.String,System.String)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
             <summary>
-                Base record for model objects with common properties
+                Double-dispatch hook. Each concrete subtype calls
+                <c>visitor.Visit(this)</c>, routing to the visitor overload that
+                accepts that specific type.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.BaseModelObject.Name">
-            <inheritdoc />
-        </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.BaseModelObject.TechnicalName">
-            <inheritdoc />
-        </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.BaseModelObject.Description">
-            <inheritdoc />
-        </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Builder.BuildResultKind">
-             <summary>
-            
-             </summary>
-             <remarks>
-             These are defined such that the success case is the lowest integral value.
-             </remarks>
-        </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Builder.DimensionFragment.PrimaryKeyFieldKey">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef">
             <summary>
-                Key of the field fragment that represents the primary key for this dimension.
-                If not set, no field will be marked as a key.
+                A reference to another measure. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" /> is the
+                resolved <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId" />; the cross-reference is opaque
+                for equivalency (consistent with model-wide convention that
+                NodeIds are not <c>[EquivalencyComponent]</c>). Two
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef" /> nodes are therefore always structurally
+                equivalent regardless of which measure they target — the
+                differentiator across two such measures is the
+                platform-keyed <c>Expressions</c> dict on
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" />.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Builder.DimensionReferenceFragment.Resolve">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId)">
             <summary>
-                Ensure FactKey, DimensionKey, and RelationshipKey are all set, and that
-                the relationships are valid according to cardinality constraints:
-                fact to dim is N:1 and left-to-right. Additionally ensure that the
-                referenced fact knows about this dimension reference.
+                A reference to another measure. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" /> is the
+                resolved <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId" />; the cross-reference is opaque
+                for equivalency (consistent with model-wide convention that
+                NodeIds are not <c>[EquivalencyComponent]</c>). Two
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef" /> nodes are therefore always structurally
+                equivalent regardless of which measure they target — the
+                differentiator across two such measures is the
+                platform-keyed <c>Expressions</c> dict on
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" />.
             </summary>
-            <returns></returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Builder.DummySource">
-            <summary>
-                Used as a placeholder source for dummy fact
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Builder.DummyFact">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured">
             <summary>
-                Used as a placeholder for dimension references during construction.
-                Since Fact is a record, this creates a minimal instance rather than inheriting.
+                Catch-all for expression shapes the AAST does not yet model
+                structurally. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured.Verbatim" /> is structural — two
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> nodes are equivalent iff their
+                payload matches.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Builder.DummyTable">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured.#ctor(System.String)">
             <summary>
-                Used as a placeholder for fields during construction of an ITableLike
+                Catch-all for expression shapes the AAST does not yet model
+                structurally. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured.Verbatim" /> is structural — two
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> nodes are equivalent iff their
+                payload matches.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Builder.FactFragment.ResolveDimensionReferences">
-            <summary>
-                Always call after resolving fields
-            </summary>
-            <returns></returns>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Builder.FieldFragment.Expression">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal">
             <summary>
-                Platform-specific expression for derived fields.
-                When set, the fragment builds to a DerivedField instead of a Field.
+                Constant-valued expression. The intermediate is abstract; the
+                concrete leaves carry their typed payload. Each platform emitter
+                renders per its target language's literal syntax (DAX uses
+                <c>"..."</c> for strings, <c>BLANK()</c> for null, etc.).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Builder.IHasFieldsFragment.FieldKeys">
-            <summary>
-            Gets the keys of all fields in this table-like fragment.
-            </summary>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.String">
+            <summary>A string literal payload.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Builder.IModelFragment.Resolve">
-            <summary>
-            Ensure fragment is a valid part of a model.
-            </summary>
-            <returns>A collection of build errors found during resolution.</returns>
-            <remarks>
-            Intended to be used as part of the model build process.
-            If errors are returned, then the model cannot have a fully successful
-            build; partial success is possible
-            </remarks>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.String.#ctor(System.String)">
+            <summary>A string literal payload.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Builder.RelationshipFragment.Resolve">
-            <summary>
-                Resolve left and right fields, check that cardinalities, kind, and
-                direction are set. If direction is not set, check whether sides are
-                fact and dimension: set to dimension filters fact.
-            </summary>
-            <returns>
-                Build errors:
-                - if missing or nonexistent field references
-                - if not a fact and dimension
-                - if any property is unset that is required for an Root.Relationship
-            </returns>
-            <exception cref="T:System.NotImplementedException"></exception>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.String.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Numeric">
             <summary>
-                A field derived from a platform-specific expression.
-                Similar to CalculatedMeasure, this represents a computed value
-                that cannot be directly translated to DAX.
+                A numeric literal payload. Single decimal-valued shape covers
+                both integer and fractional source literals — the emitter
+                formats per the value (no trailing zeros for whole numbers).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Expressions">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Numeric.#ctor(System.Decimal)">
             <summary>
-                Mapping of platforms to platform-specific expressions implementing
-                the field calculation.
+                A numeric literal payload. Single decimal-valued shape covers
+                both integer and fractional source literals — the emitter
+                formats per the value (no trailing zeros for whole numbers).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.DataType">
-            <summary>
-                Data type of the derived field.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Numeric.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Table">
-            <summary>
-                The table containing this field.
-            </summary>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Boolean">
+            <summary>A boolean literal payload.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DerivedField.#ctor(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.ITableLike,TabularEditor.SemanticBridge.AbstractModel.DataType,System.Collections.Generic.IReadOnlyDictionary{System.String,System.String})">
-            <summary>
-                Constructor for DerivedField.
-            </summary>
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use by the OLAP engine</param>
-            <param name="description">Prose describing the object</param>
-            <param name="table">The table containing this field</param>
-            <param name="dataType">Data type of the field</param>
-            <param name="expressions">
-                Mapping of platforms to platform-specific expressions implementing
-                the calculation
-            </param>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Boolean.#ctor(System.Boolean)">
+            <summary>A boolean literal payload.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Equals(TabularEditor.SemanticBridge.AbstractModel.DerivedField)">
-            <summary>
-                Determines equality by comparing scalar properties and Expressions
-                dictionary contents. Excludes parent Table to avoid circular references.
-            </summary>
-            <param name="other">The other DerivedField to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent Expressions
-            </returns>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Boolean.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DerivedField.GetHashCode">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Null">
             <summary>
-                Generates hash code based on scalar properties and Expressions
-                dictionary contents. Excludes parent Table to avoid circular references.
+                The null literal. Carries no payload; emitter renders per
+                target-language null form (DAX <c>BLANK()</c>, SQL <c>NULL</c>).
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Null.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp">
             <summary>
-                Accepts a visitor for processing this DerivedField.
+                Binary arithmetic operation. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Op" /> is constrained to
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.BinaryOperator" /> values that have direct cross-platform
+                equivalents; richer operator sets (comparison, logical, etc.) wait
+                for future slices. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Left" /> and <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Right" /> are
+                recursive AAST children — structural equivalence walks into them via
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence.EquivalentTo``1(``0,``0)" />.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Dimension">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.#ctor(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,TabularEditor.SemanticBridge.AbstractModel.BinaryOperator,TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)">
             <summary>
-                Context for analysis
+                Binary arithmetic operation. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Op" /> is constrained to
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.BinaryOperator" /> values that have direct cross-platform
+                equivalents; richer operator sets (comparison, logical, etc.) wait
+                for future slices. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Left" /> and <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Right" /> are
+                recursive AAST children — structural equivalence walks into them via
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence.EquivalentTo``1(``0,``0)" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.Attributes">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Paren">
             <summary>
-                Collection of descriptive properties
+                Explicit parenthesization. Preserves user-written grouping that the
+                tree shape alone wouldn't capture. The emitter renders
+                <c>(Inner)</c> verbatim — no precedence smarts; the AAST is
+                trusted to carry the intended grouping.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.PrimaryKeyFieldName">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Paren.#ctor(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)">
             <summary>
-                Technical name of the primary key field for this dimension.
-                Null if no primary key is explicitly defined.
+                Explicit parenthesization. Preserves user-written grouping that the
+                tree shape alone wouldn't capture. The emitter renders
+                <c>(Inner)</c> verbatim — no precedence smarts; the AAST is
+                trusted to carry the intended grouping.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.Hierarchies">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Paren.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount">
             <summary>
-                Collection of hierarchies
+                Count of all rows in <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" /> — DAX
+                <c>COUNTROWS('Table')</c>. Produced by the SQL→AAST translator for
+                <c>COUNT(*)</c> and <c>COUNT(&lt;non-null literal&gt;)</c>; these
+                shapes are semantically equivalent (both count every row) and
+                collapse to a single AAST form. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" /> is typed as
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" /> so the same node serves fact and (future)
+                dim row counts; it is opaque for equivalency — the cross-reference
+                follows the same convention as <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.Source">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId)">
             <summary>
-                Reference to source system and queryable or embedded query
+                Count of all rows in <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" /> — DAX
+                <c>COUNTROWS('Table')</c>. Produced by the SQL→AAST translator for
+                <c>COUNT(*)</c> and <c>COUNT(&lt;non-null literal&gt;)</c>; these
+                shapes are semantically equivalent (both count every row) and
+                collapse to a single AAST form. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" /> is typed as
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" /> so the same node serves fact and (future)
+                dim row counts; it is opaque for equivalency — the cross-reference
+                follows the same convention as <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" />.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Dimension.Equals(TabularEditor.SemanticBridge.AbstractModel.Dimension)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation">
+            <summary>
+                Aggregation of a single column — DAX
+                <c>SUM('Fact'[col])</c>, <c>COUNT('Fact'[col])</c>, etc. Produced
+                by the SQL→AAST translator for <c>SUM</c>/<c>AVG</c>/<c>MIN</c>/
+                <c>MAX</c>/<c>COUNT</c>/<c>COUNT(DISTINCT)</c> over a single
+                column reference. Unlike <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount" />, this aggregates
+                a specific field rather than the whole table.
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation.AggregationType" /> is structural (different aggregation
+                functions produce structurally-distinct expressions);
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation.Target" /> is opaque for equivalency — same convention
+                as <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" /> and
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation.#ctor(TabularEditor.SemanticBridge.AbstractModel.AggregationType,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId)">
+            <summary>
+                Aggregation of a single column — DAX
+                <c>SUM('Fact'[col])</c>, <c>COUNT('Fact'[col])</c>, etc. Produced
+                by the SQL→AAST translator for <c>SUM</c>/<c>AVG</c>/<c>MIN</c>/
+                <c>MAX</c>/<c>COUNT</c>/<c>COUNT(DISTINCT)</c> over a single
+                column reference. Unlike <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount" />, this aggregates
+                a specific field rather than the whole table.
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation.AggregationType" /> is structural (different aggregation
+                functions produce structurally-distinct expressions);
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation.Target" /> is opaque for equivalency — same convention
+                as <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" /> and
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.BinaryOperator">
             <summary>
-                Determines equality by comparing scalar properties and collection
-                contents order-independently.
+                Operators allowed in <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp" />.
+                Restricted to the basic arithmetic set that has direct equivalents
+                in both Databricks SQL and DAX.
             </summary>
-            <param name="other">The other Dimension to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent collections.
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Dimension.GetHashCode">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AggregationType">
             <summary>
-                Generates hash code based on scalar properties and collection contents.
-                Fields property is not included since it's computed from Attributes.
+                Aggregation types for measures
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField">
             <summary>
-                Descriptive property in a dimension
+                A computed column on an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />. Carries one or more
+                platform-keyed source expressions (e.g., the Databricks SQL the field
+                was authored as). Target-platform emitters consult their key to obtain
+                the expression to translate. Doesn't reference a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> — derived fields exist only at the
+                dimensional-model level.
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerId">
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />; resolve via
+                <c>Root.GetTable</c>.
+            </param>
+            <param name="DataType">The data type of this field's computed values.</param>
+            <param name="Format">
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>,
+                <c>"yyyy-MM-dd"</c>); empty string when no format opinion.
+            </param>
+            <param name="Expressions">
+                Platform-keyed source expressions for this field. <c>null</c> coalesces
+                to <c>ImmutableDictionary.Empty</c> at construction.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.#ctor(TabularEditor.SemanticBridge.AbstractModel.IField,TabularEditor.SemanticBridge.AbstractModel.Dimension,System.Boolean)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DerivedField.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,TabularEditor.SemanticBridge.AbstractModel.DataType,System.String,System.Collections.Immutable.ImmutableDictionary{System.String,System.String})">
             <summary>
-                Creates a DimensionAttribute from any IField, setting the dimension as the parent table.
+                A computed column on an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />. Carries one or more
+                platform-keyed source expressions (e.g., the Databricks SQL the field
+                was authored as). Target-platform emitters consult their key to obtain
+                the expression to translate. Doesn't reference a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> — derived fields exist only at the
+                dimensional-model level.
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerId">
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />; resolve via
+                <c>Root.GetTable</c>.
+            </param>
+            <param name="DataType">The data type of this field's computed values.</param>
+            <param name="Format">
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>,
+                <c>"yyyy-MM-dd"</c>); empty string when no format opinion.
+            </param>
+            <param name="Expressions">
+                Platform-keyed source expressions for this field. <c>null</c> coalesces
+                to <c>ImmutableDictionary.Empty</c> at construction.
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.DataType">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Description">
             <summary>
-                Data type of the attribute
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.SourceField">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.OwnerId">
             <summary>
-                Field reference in the source; the TechnicalName of the source field.
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />; resolve via
+                <c>Root.GetTable</c>.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.IsKey">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.DataType">
+            <summary>The data type of this field's computed values.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Format">
             <summary>
-                Indicates if this attribute is a key
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>,
+                <c>"yyyy-MM-dd"</c>); empty string when no format opinion.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.UnderlyingField">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Expressions">
+            <summary>Platform-keyed source expressions; never <c>null</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Dimension">
             <summary>
-                The underlying field this attribute wraps.
-                Used by visitors to determine if special handling is needed (e.g., DerivedField).
+                A categorical, descriptive context table joined to a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />.
+                References its data source by <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.SourceId" />. Fields on the
+                dimension live in <c>Root.Fields</c> with their <c>OwnerId</c> set to
+                this dimension's id; relationships between this dimension and a fact
+                are first-class objects on <c>Root</c> (future).
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="SourceId">
+                Reference to the dimension's data source; resolve via
+                <c>Root.GetSource</c>.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.Equals(TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Dimension.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.DimensionId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)">
             <summary>
-                Determines equality by comparing scalar properties and underlying field type,
-                excluding parent Dimension to avoid circular references.
+                A categorical, descriptive context table joined to a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />.
+                References its data source by <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.SourceId" />. Fields on the
+                dimension live in <c>Root.Fields</c> with their <c>OwnerId</c> set to
+                this dimension's id; relationships between this dimension and a fact
+                are first-class objects on <c>Root</c> (future).
             </summary>
-            <param name="other">The other DimensionAttribute to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties (excluding parent reference)
-            </returns>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="SourceId">
+                Reference to the dimension's data source; resolve via
+                <c>Root.GetSource</c>.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute.GetHashCode">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.Description">
             <summary>
-                Generates hash code based on scalar properties excluding parent
-                Dimension to avoid circular references.
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DimensionReference.Equals(TabularEditor.SemanticBridge.AbstractModel.DimensionReference)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.SourceId">
             <summary>
-                Determines equality by comparing scalar properties and child references,
-                excluding parent Fact to avoid circular references.
+                Reference to the dimension's data source; resolve via
+                <c>Root.GetSource</c>.
             </summary>
-            <param name="other">The other DimensionReference to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent child references
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.DimensionReference.GetHashCode">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Dimension.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Dimension.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Cardinality">
             <summary>
-                Generates hash code based on scalar properties and child references,
-                excluding parent Fact to avoid circular references.
+                Cardinality of a field in a join/relationship
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
         <member name="T:TabularEditor.SemanticBridge.AbstractModel.DataType">
             <summary>
@@ -281,772 +428,1495 @@
                 Permission levels for object rules
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Fact">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.EquivalencyComponentAttribute">
             <summary>
-                Represents a business event or measurement context
+                Marks a property as a structural component of equivalence comparison.
+                Properties without this attribute are ignored by
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence.EquivalentTo``1(``0,``0)" /> — typically the
+                object's own identity and any cross-reference NodeIds it carries.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.Measures">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Fact">
             <summary>
-                Collection of quantifiable values
+                A business event or measurement context. The central table in a
+                dimensional model. References its data source by <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Fact.SourceId" />
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="FactType">Categorization of the fact (Transactional, Snapshot, etc.).</param>
+            <param name="SourceId">
+                Reference to the fact's data source; resolve via <c>Root.GetSource</c>.
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.Dimensions">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Fact.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.FactType,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)">
             <summary>
-                Collection of dimension references
+                A business event or measurement context. The central table in a
+                dimensional model. References its data source by <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Fact.SourceId" />
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="FactType">Categorization of the fact (Transactional, Snapshot, etc.).</param>
+            <param name="SourceId">
+                Reference to the fact's data source; resolve via <c>Root.GetSource</c>.
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.FactType">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.Description">
             <summary>
-                Type of fact
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.Source">
-            <summary>
-                Reference to source system and queryable or embedded query
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.FactType">
+            <summary>Categorization of the fact (Transactional, Snapshot, etc.).</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Fact.Equals(TabularEditor.SemanticBridge.AbstractModel.Fact)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.SourceId">
             <summary>
-                Determines equality by comparing scalar properties and collection contents order-independently.
+                Reference to the fact's data source; resolve via <c>Root.GetSource</c>.
             </summary>
-            <param name="other">The other Fact to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent collections</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Fact.GetHashCode">
-            <summary>
-                Generates hash code based on scalar properties and collection contents.
-            </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.FactType">
-            <summary>
-                Type of fact table
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Additivity">
-            <summary>
-                Additivity types for measures
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Fact.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.AggregationType">
-            <summary>
-                Aggregation types for measures
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Fact.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Field.Equals(TabularEditor.SemanticBridge.AbstractModel.Field)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1">
             <summary>
-                Determines equality by comparing scalar properties excluding parent
-                Table to avoid circular references.
+                Default base for <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor`1" />
+                implementations that want the standard abort-and-fallback semantics:
+                unimplemented <c>Visit</c> overloads throw
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" />, and the outermost emit catches
+                once at the root and invokes <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Fallback" />.
+                <para>
+                    New-platform minimum viable emitter: derive, override
+                    <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Fallback" />, ship. Incrementally override per-shape
+                    <c>Visit</c> overloads as structural emission for each construct
+                    is implemented; unoverridden ones fall through to the fallback
+                    automatically.
+                </para>
+                <para>
+                    Recursive code in concrete overloads should call
+                    <c>Visit(child)</c>, not <c>child.Accept(this)</c> — the
+                    <c>Visit(AbstractExpression)</c> override routes through Accept,
+                    keeping the dispatch detail in one place. An <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" />
+                    raised from any nested call propagates freely; do not catch.
+                </para>
             </summary>
-            <param name="other">The other Field to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties (excluding
-                parent reference)
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Field.GetHashCode">
-            <summary>
-                Generates hash code based on scalar properties excluding parent
-                Table to avoid circular references.
-            </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Fallback">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor`1.Fallback" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Hierarchy">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)">
             <summary>
-                Logical path for drill-down analysis
+                Polymorphic-dispatch entry. Routes through the node's
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor{``0})" /> to the matching
+                concrete-typed Visit overload.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Hierarchy.Levels">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)">
             <summary>
-                Ordered collection of dimension attributes
+                Default abort. Overridden by derived classes that can render this
+                construct structurally; otherwise the emit is unwound to the root
+                and <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Fallback" /> takes over.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Hierarchy.IsRagged">
-            <summary>
-                Indicates if hierarchy has inconsistent depth
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Hierarchy.Equals(TabularEditor.SemanticBridge.AbstractModel.Hierarchy)">
-            <summary>
-                Determines equality by comparing scalar properties and Levels
-                collection contents.
-            </summary>
-            <param name="other">The other Hierarchy to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent Levels</returns>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Hierarchy.GetHashCode">
-            <summary>
-                Generates hash code based on scalar properties and Levels
-                collection contents.
-            </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Numeric)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.IModelObject">
-            <summary>
-                Common properties for all model objects
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Boolean)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.IModelObject.Name">
-            <summary>
-                Friendly name for display to users
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Null)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.IModelObject.TechnicalName">
-            <summary>
-                Name for internal use in formulas by the OLAP engine, potentially the same as Name
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.IModelObject.Description">
-            <summary>
-                Prose describing the object
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Paren)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.ISourceSystem">
-            <summary>
-                Represents a data source system that can be referenced by model objects
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)" />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ISourceSystem.SystemIdentifier">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.EmitWithFallback(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)">
             <summary>
-                Type-specific identifier for this source system
+                Run the visitor over <paramref name="body" />, catching any
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" /> raised at any depth and
+                returning <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.Fallback" /> instead. The single place
+                where the abort signal is consumed — concrete Visit overloads
+                should propagate, not catch.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.ISource">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException">
             <summary>
-                Represents a source reference with query information
+                Thrown by an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor`1" /> Visit
+                method to abort the in-progress emission and trigger the visitor's
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor`1.Fallback" />. Used to
+                unwind partial work from deeply-nested constructs (e.g., a BinaryOp
+                whose right operand cannot be emitted cleanly) so the final output is
+                either fully structural or the platform-appropriate fallback placeholder
+                — never a mix of the two.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ISource.SourceSystem">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor`1">
             <summary>
-                Reference to the source system
+                Double-dispatch visitor over <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression" /> nodes.
+                New AAST node types add a <c>Visit</c> overload here and every
+                implementation must update — compile-time enforcement that all
+                emitters / analyzers handle every node shape. Mirrors the
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1" /> pattern: the inherited
+                <c>Visit(AbstractExpression)</c> entry method is the polymorphic
+                dispatcher (implementations forward through the node's <c>Accept</c>);
+                concrete overloads do the per-shape work. Recursive code in concrete
+                overloads should call <c>Visit(child)</c>, never <c>child.Accept(this)</c>.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ISource.Database">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractExpressionVisitor`1.Fallback">
             <summary>
-                Database or catalog name
+                Target-platform-appropriate placeholder produced when emission
+                aborts. Typically wraps the whole original source in a comment so
+                the user sees their intent preserved while the emitted body is
+                functionally inert. Invoked once at the root by
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1.EmitWithFallback(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)" />
+                when any nested <c>Visit</c> raises an
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" />.
             </summary>
         </member>
         <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitable">
             <summary>
-                Marker interface for Abstract Model objects that can accept visitors.
-                All Abstract Model domain objects (Root, Fact, Dimension, Measure, etc.)
-                implement this. This interface enables the visitor pattern for
-                traversing the Abstract Model object graph.
+                The <c>Accept</c> half of the abstract-model visitor pattern.
+                Implementers route a visitor's polymorphic dispatch through their
+                concrete-typed <c>Visit</c> overload by the double-dispatch
+                convention <c>visitor.Visit(this)</c>.
             </summary>
         </member>
         <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitable.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
             <summary>
-                Accepts a visitor that produces a result of type TResult.
-                The concrete type dispatches to the appropriate Visit overload on
-                the visitor based on its runtime type.
+                Dispatches <paramref name="visitor" /> to the concrete-typed
+                <c>Visit</c> overload that matches this record's runtime type.
             </summary>
-            <typeparam name="TResult">The type of value produced by the visitor</typeparam>
-            <param name="visitor">The visitor to accept</param>
-            <returns>The result produced by the visitor</returns>
         </member>
         <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1">
             <summary>
-                Visitor interface for the Abstract Model object graph.
-                Extends the generic IVisitor pattern with Abstract Model-specific
-                visitation methods. This interface enables type-safe transformation of
-                Abstract Model objects while supporting generic orchestration through
-                the base IVisitor interface.
+                Visitor over <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitable" /> records. One
+                <c>Visit</c> overload per concrete record type, which gives
+                compile-time exhaustiveness across every implementer: a new record
+                type cannot be processed without first adding a <c>Visit</c> overload
+                here. The inherited <c>Visit(IModelObject)</c> from
+                <see cref="T:TabularEditor.SemanticBridge.Orchestration.IVisitor`2" /> is the polymorphic-dispatch
+                entry point — implementations forward through the visitable's
+                <c>Accept</c> to the appropriate concrete <c>Visit</c> overload.
             </summary>
             <typeparam name="TResult">
-                The type of value produced by visiting Abstract Model objects
+                The value each <c>Visit</c> overload returns — e.g., a TOM
+                <c>Model</c> for the abstract-to-TOM emitter, or a diagnostic-bearing
+                result for a validator.
             </typeparam>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Root)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IEquivalent`1">
             <summary>
-                Visits a Root (the top-level Abstract Model container).
+                Marker indicating a type supports structural equivalence. The comparison
+                itself is provided by the extension method
+                <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence.EquivalentTo``1(``0,``0)" />, which reflects over
+                properties tagged with <see cref="T:TabularEditor.SemanticBridge.AbstractModel.EquivalencyComponentAttribute" />.
+                Implementers carry no boilerplate beyond declaring this interface.
             </summary>
+            <remarks>
+                Structural equivalence compares own scalar properties only; it
+                deliberately ignores both the object's own <c>Id</c> and any
+                cross-reference NodeIds it carries (e.g., <c>OwnerSourceId</c>,
+                <c>SourceSystemId</c>) — those are allocation-specific to a particular
+                Root and don't carry meaning across independently-built trees.
+                Contrast with default record equality (<c>==</c>), which compares
+                everything. Cross-reference resolution (verifying that two records'
+                <c>SourceSystemId</c>s point at equivalent SourceSystems across two
+                Roots) is a graph-level concern handled by <c>Root.EquivalentTo</c>;
+                a single <c>IEquivalent</c> instance has no Root context.
+                The <c>where TSelf : IEquivalent&lt;TSelf&gt;</c> constraint is the
+                closest C# gets to a <c>Self</c> type and is what restricts the
+                extension method to legitimate self-comparisons. Family interfaces
+                (e.g., <c>ISource</c>) declare <c>IEquivalent&lt;self-interface&gt;</c>
+                so that interface-typed references can be compared polymorphically
+                without any per-concrete-type boilerplate — the extension method
+                dispatches on <em>runtime</em> type.
+            </remarks>
+            <typeparam name="TSelf">
+                The implementing type — by convention, the record's own type or the
+                family interface for polymorphic comparison.
+            </typeparam>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Fact)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence">
             <summary>
-                Visits a Fact (business event or measurement context).
+                Reflection-driven equivalence operation. The marked-property list per
+                <em>runtime</em> type is computed once and cached; per-call cost is one
+                <c>PropertyInfo.GetValue</c> + value comparison pair per component.
+                Runtime-type dispatch makes a single extension overload work for both
+                concrete-typed and family-interface-typed call sites.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Dimension)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence.EquivalentTo``1(``0,``0)">
             <summary>
-                Visits a Dimension (context for analysis).
+                True when <paramref name="self" /> and <paramref name="other" />
+                have the same runtime type and agree on every property of that
+                type tagged with <see cref="T:TabularEditor.SemanticBridge.AbstractModel.EquivalencyComponentAttribute" />.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.DimensionReference)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.Equivalence.ValueEquals(System.Object,System.Object)">
             <summary>
-                Visits a DimensionReference (link between Fact and Dimension).
+                Equality for property values participating in equivalence. Handles
+                dictionary content comparison (order-independent, key + value
+                equality) so records carrying <c>IReadOnlyDictionary</c>-shaped
+                properties (e.g., <c>DerivedField.Expressions</c>) get sensible
+                value-equality without per-type custom <c>EquivalentTo</c>.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject">
             <summary>
-                Visits a SimpleMeasure (quantifiable value with simple aggregation).
+                Capability shared by every concrete abstract-model record: typed
+                identity plus descriptive metadata. Each implementer declares its own
+                typed <c>*Id</c> property in its primary constructor and satisfies
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" /> via explicit interface implementation.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id">
             <summary>
-                Visits a CalculatedMeasure (quantifiable value with
-                platform-specific calculation).
+                The typed identity of this object, boxed as <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId" />
+                for polymorphic access. Concrete records expose this as their own
+                typed id (e.g., <c>FactId</c>, <c>SourceId</c>).
             </summary>
+            <remarks>
+                <c>Id</c> is immutable: set once at construction by Root and never
+                changed afterward. Implementers expose <c>Id</c> as a get-only
+                property with no <c>init</c> accessor, so
+                <c>record with { Id = ... }</c> is a compile error. To modify other
+                properties of a model object, use <c>Root.UpdateX</c> with a lambda
+                that preserves the original <c>Id</c>.
+            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.SimpleRelationship)">
-            <summary>
-                Visits a SimpleRelationship.
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name">
+            <summary>Friendly name for display.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.RolePlayingRelationship)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName">
             <summary>
-                Visits a RolePlayingRelationship.
+                Name for internal use by the OLAP engine, potentially the same as
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" />.
             </summary>
+            <remarks>
+                If a platform does not distinguish between technical and friendly
+                names, then we expect that <c>TechnicalName</c> will be set with
+                the value of the friendly name.
+            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute)">
-            <summary>
-                Visits a DimensionAttribute (descriptive property in a dimension).
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description">
+            <summary>Prose describing the object.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Hierarchy)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId">
             <summary>
-                Visits a Hierarchy (logical drill-down path).
+                Identity capability shared by every typed <c>*Id</c> value-struct
+                record. The underlying integer is sequentially allocated per
+                collection by Root's <c>AddX</c> methods (the first Fact receives
+                <c>FactId(0)</c>, the second <c>FactId(1)</c>, and so on) and
+                exists only within the scope of a single Root's lifecycle.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Field)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value">
             <summary>
-                Visits a Field.
+                Opaque integer identity, unique among ids of the same type within
+                the lifetime of a single Root. Allocated sequentially by Root's
+                <c>AddX</c> methods, starting from 0 per collection; treat as an
+                identifier, not a meaningful number. The typed <c>*Id</c> wrapper
+                (e.g., <c>FactId</c> vs <c>SourceId</c>) prevents cross-collection
+                confusion at the type level; ids do not need to be globally unique.
+                Stable across <c>with</c> updates of the owning record.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.DerivedField)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId">
             <summary>
-                Visits a DerivedField (field with platform-specific expression).
+                Identifies an <c>ISource</c> (e.g., QueryableSource or QuerySource)
+                within a Root.
             </summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId.#ctor(System.Int32)">
             <summary>
-                Visits a QueryableSource (source referring to a table/view).
+                Identifies an <c>ISource</c> (e.g., QueryableSource or QuerySource)
+                within a Root.
             </summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId.Value">
             <summary>
-                Visits a QuerySource (source using custom query).
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Perspective)">
-            <summary>
-                Visits a Perspective (named subset of model objects).
-            </summary>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId">
+            <summary>Identifies an <c>ISourceSystem</c> within a Root.</summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.SecurityModel)">
-            <summary>
-                Visits a SecurityModel (access control specifications).
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId.#ctor(System.Int32)">
+            <summary>Identifies an <c>ISourceSystem</c> within a Root.</summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor`1.Visit(TabularEditor.SemanticBridge.AbstractModel.Role)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId.Value">
             <summary>
-                Visits a Role (security role definition).
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Measure">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId">
             <summary>
-                Base record for measures with common properties
+                Marker for any id that identifies an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> within a
+                Root. Per-kind concrete types (<see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId" />, future
+                <c>DimensionId</c>) implement this so cross-references to "any table"
+                can be typed polymorphically while each table kind keeps its own dense
+                collection and allocation counter.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Format">
-            <summary>
-                Display formatting
-            </summary>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId">
+            <summary>Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" /> within a Root.</summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Measure.#ctor(System.String,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.DataType)">
-            <summary>
-                Constructor for base Measure record
-            </summary>
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use in formulas by the OLAP engine</param>
-            <param name="description">Prose describing the object</param>
-            <param name="format">Display formatting</param>
-            <param name="dataType">Data type of the measure</param>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId.#ctor(System.Int32)">
+            <summary>Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" /> within a Root.</summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Measure.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId.Value">
             <summary>
-                Accepts a visitor for the appropriate measure subtype.
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure">
-            <summary>
-                Quantifiable value in a fact, with a simple aggregation
-            </summary>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.DimensionId">
+            <summary>Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Dimension" /> within a Root.</summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.FieldName">
-            <summary>
-                Field reference
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.DimensionId.#ctor(System.Int32)">
+            <summary>Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Dimension" /> within a Root.</summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.TableName">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.DimensionId.Value">
             <summary>
-                Table containing the field
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.Additive">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId">
             <summary>
-                Additivity type
+                Identifies an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField" /> (SourceField, ReferenceField, or
+                DerivedField) within a Root. All field kinds share one
+                <c>FieldId</c> space and one <c>Root.Fields</c> collection.
             </summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.AdditiveOverDimensions">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId.#ctor(System.Int32)">
             <summary>
-                Collection of dimensions over which a semi-additive measure is additive
+                Identifies an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField" /> (SourceField, ReferenceField, or
+                DerivedField) within a Root. All field kinds share one
+                <c>FieldId</c> space and one <c>Root.Fields</c> collection.
             </summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.AggregationType">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId.Value">
             <summary>
-                Aggregation type
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.#ctor(System.String,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.DataType,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Additivity,System.Collections.Generic.IReadOnlyCollection{TabularEditor.SemanticBridge.AbstractModel.Dimension},TabularEditor.SemanticBridge.AbstractModel.AggregationType)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.RootId">
             <summary>
-                Constructor for SimpleMeasure
+                Identifies the <c>Root</c> of an abstract semantic model. Singleton in
+                practice — there is one Root per model and nothing cross-references it
+                by id — but typed for consistency with other model objects.
             </summary>
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use in formulas by the OLAP engine</param>
-            <param name="description">Prose describing the object</param>
-            <param name="format">Display formatting</param>
-            <param name="dataType">Data type of the measure</param>
-            <param name="fieldName">Field reference</param>
-            <param name="tableName">Table containing the field</param>
-            <param name="additive">Additivity type</param>
-            <param name="additiveOverDimensions">
-                Collection of dimensions over which a semi-additive measure is additive
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </param>
-            <param name="aggregationType">Aggregation type</param>
-        </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.Equals(TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure)">
-            <summary>
-                Determines equality by comparing scalar properties and
-                AdditiveOverDimensions collection contents.
-            </summary>
-            <param name="other">The other SimpleMeasure to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent collections
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure.GetHashCode">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.RootId.#ctor(System.Int32)">
             <summary>
-                Generates hash code based on scalar properties and
-                AdditiveOverDimensions collection contents.
+                Identifies the <c>Root</c> of an abstract semantic model. Singleton in
+                practice — there is one Root per model and nothing cross-references it
+                by id — but typed for consistency with other model objects.
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.RootId.Value">
             <summary>
-                Quantifiable value in a fact, with a platform-specific calculation
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
-            <remarks>Currently no parsing, validation, or attempted translation for these</remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure.Expressions">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId">
             <summary>
-                Mapping of platforms to platform-specific expressions implementing
-                the calculation
+                Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure" /> (Simple or Calculated) within a
+                Root. All measure kinds share one <c>MeasureId</c> space and one
+                <c>Root.Measures</c> collection.
             </summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure.#ctor(System.String,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.DataType,System.Collections.Generic.IReadOnlyDictionary{System.String,System.String})">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId.#ctor(System.Int32)">
             <summary>
-                Constructor for CalculatedMeasure
+                Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure" /> (Simple or Calculated) within a
+                Root. All measure kinds share one <c>MeasureId</c> space and one
+                <c>Root.Measures</c> collection.
             </summary>
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use in formulas by the OLAP engine</param>
-            <param name="description">Prose describing the object</param>
-            <param name="format">Display formatting</param>
-            <param name="dataType">Data type of the measure</param>
-            <param name="expressions">
-                Mapping of platforms to platform-specific expressions implementing
-                the calculation
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure.Equals(TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId.Value">
             <summary>
-                Determines equality by comparing scalar properties and Expressions
-                dictionary contents.
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
-            <param name="other">The other CalculatedMeasure to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent Expressions
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure.GetHashCode">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.RelationshipId">
             <summary>
-                Generates hash code based on scalar properties and Expressions
-                dictionary contents.
+                Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> within a Root. The model
+                holds a flat collection of relationships on <c>Root.Relationships</c>
+                — role-playing and snowflake patterns express themselves as
+                multiple <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> entries rather than as
+                polymorphic id types.
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Perspective">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Interfaces.RelationshipId.#ctor(System.Int32)">
             <summary>
-                Named subset of model objects for specific usage
+                Identifies a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> within a Root. The model
+                holds a flat collection of relationships on <c>Root.Relationships</c>
+                — role-playing and snowflake patterns express themselves as
+                multiple <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> entries rather than as
+                polymorphic id types.
             </summary>
+            <param name="Value">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Perspective.ModelObjects">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.RelationshipId.Value">
             <summary>
-                Collection of included model objects
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.INodeId.Value" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Perspective.TargetAudience">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem">
             <summary>
-                Documentation of intended users
+                Represents a data source system that a source connects to. Source
+                systems are platform-specific and represent the connection details
+                necessary for that system.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Perspective.Equals(TabularEditor.SemanticBridge.AbstractModel.Perspective)">
-            <summary>
-                Determines equality by comparing scalar properties and ModelObjects
-                collection contents.
-            </summary>
-            <param name="other">The other Perspective to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent ModelObjects
-            </returns>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem.Id">
+            <summary>Typed identity narrowing <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" />.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Perspective.GetHashCode">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem.SystemIdentifier">
             <summary>
-                Generates hash code based on scalar properties and ModelObjects
-                collection contents.
+                Type-specific identifier for this source system. Used as the
+                dispatch key for cross-platform source-rendering strategies.
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Cardinality">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource">
             <summary>
-                Cardinality of a field in a join/relationship
+                A data source referenced by a Fact or Dimension. This is roughly
+                equivalent to a partition definition.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Root">
-            <summary>
-                Abstract representation of a dimensional model
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.Id">
+            <summary>Typed identity, narrowing <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" />.</summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.Facts">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId">
             <summary>
-                Collection of facts in the model
+                Reference to the source system this source connects to.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.Dimensions">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable">
             <summary>
-                Collection of dimensions in the model
+                A table-like object in the dimensional model: a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" /> or
+                Dimension. Each concrete kind has its own dense collection on
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" /> and its own typed id (<see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId" />, etc.),
+                but cross-references to "any table" use the <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" />
+                marker so they remain polymorphic over kinds. No <c>IEquivalent</c>
+                declaration here — Tables collections are split-typed, so equivalence
+                compares concrete-typed elements directly.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.Perspectives">
-            <summary>
-                Collection of perspectives in the model
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable.Id">
+            <summary>Typed identity, narrowing <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" />.</summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.SecurityModel">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField">
             <summary>
-                Security model
+                A column-like object: a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> (a source's physical
+                column), a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> (a table column that maps to a
+                source column), or a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> (a computed table
+                column). All field kinds share one <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId" /> space and one
+                <c>Root.Fields</c> collection.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.Equals(TabularEditor.SemanticBridge.AbstractModel.Root)">
-            <summary>
-                Determines equality by comparing scalar properties and collection contents order-independently.
-            </summary>
-            <param name="other">The other Root to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent collections</returns>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField.Id">
+            <summary>Typed identity, narrowing <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" />.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetHashCode">
-            <summary>
-                Generates hash code based on scalar properties and collection contents.
-            </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField.DataType">
+            <summary>The data type of this field's values.</summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddDimensionToFact(System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.IField,TabularEditor.SemanticBridge.AbstractModel.IField,TabularEditor.SemanticBridge.AbstractModel.FilterDirection)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Measure">
             <summary>
-                Creates a dimension reference between a fact and dimension with a
-                simple equi-join relationship.
+                A quantitative computation on a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />. 
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" /> is the only measure type, with
+                expressions carried for downstream translation. An empty
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions" /> collection signals the
+                "no expression" / placeholder case; the Abstract→TOM emitter
+                materializes it as a placeholder body plus a diagnostic.
             </summary>
-            <param name="factName">Name of the fact to add the dimension reference to</param>
-            <param name="dimensionName">Name of the dimension to reference</param>
-            <param name="factForeignKey">Foreign key field in the fact</param>
-            <param name="dimensionPrimaryKey">Primary key field in the dimension</param>
-            <param name="filterDirection">
-                Filter direction for the relationship (defaults to RightFiltersLeft)
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
             </param>
-            <returns>The created dimension reference</returns>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerId">
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />; resolve via
+                <c>Root.GetFact</c>.
+            </param>
+            <param name="Format">
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>);
+                empty string when the caller has no opinion.
+            </param>
+            <param name="DataType">The data type of this measure's result.</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddDimensionToFact(System.String,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.FilterDirection)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Measure.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,System.String,TabularEditor.SemanticBridge.AbstractModel.DataType)">
             <summary>
-                Creates a dimension reference between a fact and dimension with a
-                simple equi-join relationship, looking up fields by name.
+                A quantitative computation on a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />. 
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" /> is the only measure type, with
+                expressions carried for downstream translation. An empty
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions" /> collection signals the
+                "no expression" / placeholder case; the Abstract→TOM emitter
+                materializes it as a placeholder body plus a diagnostic.
             </summary>
-            <param name="factName">Name of the fact to add the dimension reference to</param>
-            <param name="dimensionName">Name of the dimension to reference</param>
-            <param name="factFieldName">Name of the foreign key field in the fact</param>
-            <param name="dimensionFieldName">Name of the primary key field in the dimension</param>
-            <param name="filterDirection">
-                Filter direction for the relationship (defaults to RightFiltersLeft)
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
             </param>
-            <returns>The created dimension reference</returns>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerId">
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />; resolve via
+                <c>Root.GetFact</c>.
+            </param>
+            <param name="Format">
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>);
+                empty string when the caller has no opinion.
+            </param>
+            <param name="DataType">The data type of this measure's result.</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddDimensionToFact(System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.IRelationship)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Description">
             <summary>
-                Creates a dimension reference between a fact and dimension with the
-                specified relationship.
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
-            <param name="factName">Name of the fact to add the dimension reference to</param>
-            <param name="dimensionName">Name of the dimension to reference</param>
-            <param name="relationship">The relationship defining how fact and dimension connect</param>
-            <returns>The created dimension reference</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.RowRule">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.OwnerId">
             <summary>
-                Row level security rule
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" />; resolve via
+                <c>Root.GetFact</c>.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.RowRule.#ctor(TabularEditor.SemanticBridge.AbstractModel.IModelObject,System.String)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Format">
             <summary>
-                Row level security rule
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>);
+                empty string when the caller has no opinion.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.RowRule.Target">
-            <summary>
-                Target table or dimension
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.DataType">
+            <summary>The data type of this measure's result.</summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.RowRule.FilterExpression">
-            <summary>
-                Filter expression
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.ObjectRule">
-            <summary>
-                Object level security rule
-            </summary>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.ObjectRule.#ctor(TabularEditor.SemanticBridge.AbstractModel.IModelObject,TabularEditor.SemanticBridge.AbstractModel.PermissionLevel)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Measure.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated">
             <summary>
-                Object level security rule
+                A measure expressed as a platform-keyed expression string. Target
+                emitters consult their platform key to obtain the source to
+                translate (or carry verbatim with a warning). An empty
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions" /> collection signals the placeholder
+                case — the emitter materializes a placeholder body and emits a
+                diagnostic.
             </summary>
+            <param name="Expressions">
+                Platform-keyed source expressions for this measure. <c>null</c>
+                coalesces to <c>ImmutableDictionary.Empty</c> at construction.
+            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ObjectRule.Target">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,System.String,TabularEditor.SemanticBridge.AbstractModel.DataType,System.Collections.Immutable.ImmutableDictionary{System.String,System.String},TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,System.String)">
             <summary>
-                Target object
+                A measure expressed as a platform-keyed expression string. Target
+                emitters consult their platform key to obtain the source to
+                translate (or carry verbatim with a warning). An empty
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions" /> collection signals the placeholder
+                case — the emitter materializes a placeholder body and emits a
+                diagnostic.
             </summary>
+            <param name="Expressions">
+                Platform-keyed source expressions for this measure. <c>null</c>
+                coalesces to <c>ImmutableDictionary.Empty</c> at construction.
+            </param>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions">
+            <summary>Platform-keyed source expressions; never <c>null</c>.</summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ObjectRule.Permission">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Body">
             <summary>
-                Permission level
+                Structural AAST body produced by the platform's
+                SQL→AAST translator. Downstream emitters render via the AAST
+                when its shape is structural; otherwise they fall back to
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions" /> for verbatim text. Null at
+                construction coalesces to <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" />
+                with empty verbatim — the safest default when a caller hasn't
+                supplied a structural body.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Role">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.UnsupportedWindowSpec">
             <summary>
-                Security role definition
+                Pre-rendered, platform-specific representation of an unsupported
+                windowing / cumulative / semiadditive specification carried
+                verbatim from the source measure (e.g. the Databricks window spec
+                re-serialized to its source YAML). <c>null</c> when the source
+                declares no such spec.
+                <para>
+                    When set, the windowing semantics are not representable in the
+                    target language, so the target emitter must <b>not</b> emit
+                    <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Body" /> as a live expression. Instead it documents
+                    the original source, the (window-unaware) attempted
+                    translation, and this spec as an inert comment, leaving the
+                    measure for the user to author manually.
+                </para>
+                TODO (#6347): replace this carry-through with real windowed /
+                cumulative / semiadditive measure translation.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Role.RowRules">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Names">
             <summary>
-                Expressions restricting data access by dimension values
+                Construction-time validation and defaulting for the
+                <c>Name</c> / <c>TechnicalName</c> contract shared by every
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject" /> record. Target visitors are responsible
+                for canonicalizing both values to their target's identifier rules;
+                the abstract model imposes no syntax requirements beyond non-empty
+                <c>TechnicalName</c>.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Role.ObjectRules">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Names.Required(System.String,System.String)">
             <summary>
-                Settings controlling object visibility
+                Returns <paramref name="value" /> when it is non-empty and
+                non-whitespace; throws <see cref="T:System.ArgumentException" /> otherwise.
+                Caller name is captured automatically for the exception message.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Role.Members">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Names.Or(System.String,System.String)">
             <summary>
-                Users who belong to a given role
+                Returns <paramref name="preferred" /> when non-empty/whitespace;
+                otherwise returns <paramref name="fallback" />.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Role.Equals(TabularEditor.SemanticBridge.AbstractModel.Role)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource">
             <summary>
-                Determines equality by comparing scalar properties and collection contents.
+                A source that refers to a specific named queryable object in a source
+                system, e.g., a table or view. Contrast with <c>QuerySource</c> (custom
+                query text).
             </summary>
-            <param name="other">The other Role to compare with</param>
-            <returns>
-                True if both objects have equal scalar properties and equivalent collections
-            </returns>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="SourceSystemId">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId" path="/summary/node()" />
+            </param>
+            <param name="Database">The database or catalog name within the source system.</param>
+            <param name="Schema">The schema name within the database.</param>
+            <param name="ObjectName">
+                The name of the queryable object (table or view) within the schema.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Role.GetHashCode">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId,System.String,System.String,System.String)">
             <summary>
-                Generates hash code based on scalar properties and collection contents.
+                A source that refers to a specific named queryable object in a source
+                system, e.g., a table or view. Contrast with <c>QuerySource</c> (custom
+                query text).
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="SourceSystemId">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId" path="/summary/node()" />
+            </param>
+            <param name="Database">The database or catalog name within the source system.</param>
+            <param name="Schema">The schema name within the database.</param>
+            <param name="ObjectName">
+                The name of the queryable object (table or view) within the schema.
+            </param>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.SecurityModel">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Description">
             <summary>
-                Access control specifications
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SecurityModel.Roles">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.SourceSystemId">
             <summary>
-                Collection of roles
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId" path="/summary/node()" />
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SecurityModel.Equals(TabularEditor.SemanticBridge.AbstractModel.SecurityModel)">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Database">
+            <summary>The database or catalog name within the source system.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Schema">
+            <summary>The schema name within the database.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.ObjectName">
             <summary>
-                Determines equality by comparing scalar properties and Roles
-                collection contents.
+                The name of the queryable object (table or view) within the schema.
             </summary>
-            <param name="other">The other SecurityModel to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent Roles</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SecurityModel.GetHashCode">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.QuerySource">
             <summary>
-                Generates hash code based on scalar properties and Roles
-                collection contents.
+                A source whose contents are defined by a query expression rather than a
+                named object in the source system. Contrast with
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource" /> (a named table or view).
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="SourceSystemId">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId" path="/summary/node()" />
+            </param>
+            <param name="Query">The query expression that produces this source's rows.</param>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QuerySource.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId,System.String)">
+            <summary>
+                A source whose contents are defined by a query expression rather than a
+                named object in the source system. Contrast with
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource" /> (a named table or view).
+            </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="SourceSystemId">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId" path="/summary/node()" />
+            </param>
+            <param name="Query">The query expression that produces this source's rows.</param>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QuerySource.Description">
+            <summary>
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QuerySource.SourceSystemId">
+            <summary>
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource.SourceSystemId" path="/summary/node()" />
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QuerySource.Query">
+            <summary>The query expression that produces this source's rows.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QuerySource.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QuerySource.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.QuerySource.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QuerySource.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField">
             <summary>
-                Represents a source that refers to a specific queryable object (table/view)
+                A column on an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> (Fact or Dimension) that maps to a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" />. The reference is by typed
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId" />; the legacy stringly-typed wiring via
+                <c>TechnicalName</c> matching is gone. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.DataType" /> defaults
+                to the referenced source field's data type at construction time when
+                not specified explicitly; type-compatibility validation is a downstream
+                analyzer concern, not enforced here.
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerId">
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> (Fact or Dimension);
+                resolve via <c>Root.GetTable</c>.
+            </param>
+            <param name="SourceFieldId">
+                Reference to the underlying <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> this field maps
+                to; resolve via <c>Root.GetField</c>.
+            </param>
+            <param name="DataType">The data type of this field.</param>
+            <param name="Format">
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>,
+                <c>"yyyy-MM-dd"</c>); empty string when no format opinion.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.Equals(TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.DataType,System.String)">
             <summary>
-                Determines equality by comparing scalar properties and Fields
-                dictionary contents.
+                A column on an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> (Fact or Dimension) that maps to a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" />. The reference is by typed
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId" />; the legacy stringly-typed wiring via
+                <c>TechnicalName</c> matching is gone. <see cref="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.DataType" /> defaults
+                to the referenced source field's data type at construction time when
+                not specified explicitly; type-compatibility validation is a downstream
+                analyzer concern, not enforced here.
             </summary>
-            <param name="other">The other QueryableSource to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent Fields</returns>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerId">
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> (Fact or Dimension);
+                resolve via <c>Root.GetTable</c>.
+            </param>
+            <param name="SourceFieldId">
+                Reference to the underlying <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> this field maps
+                to; resolve via <c>Root.GetField</c>.
+            </param>
+            <param name="DataType">The data type of this field.</param>
+            <param name="Format">
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>,
+                <c>"yyyy-MM-dd"</c>); empty string when no format opinion.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QueryableSource.GetHashCode">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.Description">
             <summary>
-                Generates hash code based on scalar properties and Fields
-                dictionary contents.
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.QuerySource">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.OwnerId">
+            <summary>
+                Reference to the owning <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> (Fact or Dimension);
+                resolve via <c>Root.GetTable</c>.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.SourceFieldId">
+            <summary>
+                Reference to the underlying <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> this field maps
+                to; resolve via <c>Root.GetField</c>.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.DataType">
+            <summary>The data type of this field.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.Format">
+            <summary>
+                Platform-format string applied at emit time (e.g., <c>"#,##0.00"</c>,
+                <c>"yyyy-MM-dd"</c>); empty string when no format opinion.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Relationship">
             <summary>
-                Represents a source that uses a custom query
+                An edge between two <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />s — typically a fact's
+                foreign key and a dimension's primary key. The model holds a flat
+                collection of relationships on <c>Root.Relationships</c>; role-playing
+                and snowflake patterns express themselves as multiple
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> entries in this collection rather than as
+                polymorphic relationship variants.
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="LeftFieldId">
+                The "left side" of the edge. For a conventional fact ↔ dim
+                relationship, this is the fact-side foreign-key
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />.
+            </param>
+            <param name="RightFieldId">
+                The "right side" of the edge. For a conventional fact ↔ dim
+                relationship, this is the dim-side primary-key
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />.
+            </param>
+            <param name="LeftCardinality">
+                Multiplicity of the left side. <see cref="F:TabularEditor.SemanticBridge.AbstractModel.Cardinality.Many" /> for
+                the conventional fact-side FK.
+            </param>
+            <param name="RightCardinality">
+                Multiplicity of the right side. <see cref="F:TabularEditor.SemanticBridge.AbstractModel.Cardinality.One" /> for
+                the conventional dim-side PK.
+            </param>
+            <param name="FilterDirection">
+                Which side filters which.
+                <see cref="F:TabularEditor.SemanticBridge.AbstractModel.FilterDirection.RightFiltersLeft" /> for the
+                conventional dim-filters-fact.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QuerySource.Equals(TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Relationship.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.RelationshipId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.Cardinality,TabularEditor.SemanticBridge.AbstractModel.Cardinality,TabularEditor.SemanticBridge.AbstractModel.FilterDirection)">
             <summary>
-                Determines equality by comparing scalar properties and Fields
-                dictionary contents.
+                An edge between two <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />s — typically a fact's
+                foreign key and a dimension's primary key. The model holds a flat
+                collection of relationships on <c>Root.Relationships</c>; role-playing
+                and snowflake patterns express themselves as multiple
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> entries in this collection rather than as
+                polymorphic relationship variants.
             </summary>
-            <param name="other">The other QuerySource to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent Fields</returns>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="LeftFieldId">
+                The "left side" of the edge. For a conventional fact ↔ dim
+                relationship, this is the fact-side foreign-key
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />.
+            </param>
+            <param name="RightFieldId">
+                The "right side" of the edge. For a conventional fact ↔ dim
+                relationship, this is the dim-side primary-key
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />.
+            </param>
+            <param name="LeftCardinality">
+                Multiplicity of the left side. <see cref="F:TabularEditor.SemanticBridge.AbstractModel.Cardinality.Many" /> for
+                the conventional fact-side FK.
+            </param>
+            <param name="RightCardinality">
+                Multiplicity of the right side. <see cref="F:TabularEditor.SemanticBridge.AbstractModel.Cardinality.One" /> for
+                the conventional dim-side PK.
+            </param>
+            <param name="FilterDirection">
+                Which side filters which.
+                <see cref="F:TabularEditor.SemanticBridge.AbstractModel.FilterDirection.RightFiltersLeft" /> for the
+                conventional dim-filters-fact.
+            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.QuerySource.GetHashCode">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.Description">
             <summary>
-                Generates hash code based on scalar properties and Fields
-                dictionary contents.
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.LeftFieldId">
             <summary>
-                Databricks source system
+                The "left side" of the edge. For a conventional fact ↔ dim
+                relationship, this is the fact-side foreign-key
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.#ctor(System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.Int32)">
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use by the OLAP engine</param>
-            <param name="description">Description of the source system</param>
-            <param name="host">Databricks host address</param>
-            <param name="httpPath">HTTP path for the Databricks workspace</param>
-            <param name="database">Optional database name</param>
-            <param name="schema">Optional schema name</param>
-            <param name="port">Optional port number (default is 443)</param>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.RightFieldId">
+            <summary>
+                The "right side" of the edge. For a conventional fact ↔ dim
+                relationship, this is the dim-side primary-key
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />.
+            </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.Host">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.LeftCardinality">
             <summary>
-                Host name or IP address
+                Multiplicity of the left side. <see cref="F:TabularEditor.SemanticBridge.AbstractModel.Cardinality.Many" /> for
+                the conventional fact-side FK.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.HttpPath">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.RightCardinality">
             <summary>
-                HTTP path for the Databricks workspace
+                Multiplicity of the right side. <see cref="F:TabularEditor.SemanticBridge.AbstractModel.Cardinality.One" /> for
+                the conventional dim-side PK.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.Port">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.FilterDirection">
             <summary>
-                Port number (default is 443)
+                Which side filters which.
+                <see cref="F:TabularEditor.SemanticBridge.AbstractModel.FilterDirection.RightFiltersLeft" /> for the
+                conventional dim-filters-fact.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.SystemIdentifier">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Relationship.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
             <inheritdoc />
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.GenerateMExpression(TabularEditor.SemanticBridge.AbstractModel.ISource)">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.Root">
             <summary>
-                Generates an M (Power Query) expression for the specified source.
-                Dispatches to type-specific generation methods based on ISource implementation.
+                The top-level container of an abstract semantic model. Holds every
+                model object in flat top-level collections keyed only by typed
+                <c>*Id</c> references — there are no parent-owned child collections;
+                navigation across the graph is via Root's lookup methods
+                (<see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetFact(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId)" />, <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetSource(TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)" />, etc.).
             </summary>
-            <param name="source">
-                The source to generate an M expression for (QueryableSource or QuerySource)
-            </param>
-            <returns>M expression string that can be used in a Tabular Model partition</returns>
-            <exception cref="T:System.NotSupportedException">
-                Thrown when the source type is not supported
+            <remarks>
+                Root is an immutable record. "Mutation" methods (<see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddFact(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.FactType,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)" />
+                et al.) are pure functions returning a tuple of
+                <c>(newRoot, addedObject)</c>. Cross-collection invariants are checked
+                at the construction site; violations throw an exception which a
+                platform-level wrapper catches and converts to a
+                <c>TransformationResult</c> diagnostic at the public-API boundary.
+                Storage is dense per-collection: each <c>AddX</c> allocates the next id
+                as <c>new TId(Collection.Length)</c> before appending, so ids equal
+                array indices and lookups are direct indexing. The typed <c>*Id</c>
+                structs prevent cross-collection confusion at the type level; ids are
+                not globally unique. Deletion is not a part of the current API.
+            </remarks>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.RootId,System.String,System.String,System.String,System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem},System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource},System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Fact},System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Dimension},System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField},System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Measure},System.Collections.Immutable.ImmutableArray{TabularEditor.SemanticBridge.AbstractModel.Relationship})">
+            <summary>
+                The top-level container of an abstract semantic model. Holds every
+                model object in flat top-level collections keyed only by typed
+                <c>*Id</c> references — there are no parent-owned child collections;
+                navigation across the graph is via Root's lookup methods
+                (<see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetFact(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId)" />, <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetSource(TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)" />, etc.).
+            </summary>
+            <remarks>
+                Root is an immutable record. "Mutation" methods (<see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddFact(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.FactType,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)" />
+                et al.) are pure functions returning a tuple of
+                <c>(newRoot, addedObject)</c>. Cross-collection invariants are checked
+                at the construction site; violations throw an exception which a
+                platform-level wrapper catches and converts to a
+                <c>TransformationResult</c> diagnostic at the public-API boundary.
+                Storage is dense per-collection: each <c>AddX</c> allocates the next id
+                as <c>new TId(Collection.Length)</c> before appending, so ids equal
+                array indices and lookups are direct indexing. The typed <c>*Id</c>
+                structs prevent cross-collection confusion at the type level; ids are
+                not globally unique. Deletion is not a part of the current API.
+            </remarks>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.Root.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.AbstractModel.Root.Empty">
+            <summary>
+                The empty Root. Use as the starting point for incremental
+                construction: <c>(root, var fact) = Root.Empty.AddFact(...)</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddQueryableSource(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId,System.String,System.String,System.String)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource" /> to this Root. Returns the new
+                Root and the newly-allocated source with its assigned
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddQuerySource(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId,System.String)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QuerySource" /> to this Root. Returns the new Root
+                and the newly-allocated source with its assigned
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddFact(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.FactType,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)">
+            <summary>Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" /> to this Root.</summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="sourceId" /> does not yet exist in
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Root.Sources" />.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddDimension(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)">
+            <summary>Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Dimension" /> to this Root.</summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="sourceId" /> does not yet exist in
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Root.Sources" />.
             </exception>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.GenerateMExpression(TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddSourceSystem``1(System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId,``0})">
             <summary>
-                Generates M expression for a QueryableSource (table/view reference).
-                Creates Power Query M code that references a Databricks catalog object.
+                Add an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem" /> to this Root via a factory that
+                receives the newly-allocated <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId" />. Open to
+                any concrete <c>ISourceSystem</c> implementation — source platforms
+                (Databricks, Snowflake, etc.) supply the factory.
             </summary>
-            <param name="source">
-                The queryable source containing database, schema, and object names
-            </param>
-            <returns>M expression referencing the Databricks object</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.DatabricksSourceSystem.GenerateMExpression(TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddSourceField(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.DataType)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> to this Root. Owns by the supplied
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId" />.
+            </summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="ownerSourceId" /> does not yet exist in
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Root.Sources" />.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddReferenceField(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.Nullable{TabularEditor.SemanticBridge.AbstractModel.DataType},System.String)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> to this Root mapping the
+                specified table column to a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" />. When
+                <paramref name="dataType" /> is omitted, the resulting field's
+                <c>DataType</c> defaults to the referenced source field's
+                <c>DataType</c>; compatibility validation is a downstream concern.
+            </summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="ownerId" /> does not resolve to a table
+                in this Root, or when <paramref name="sourceFieldId" /> does not
+                exist in <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Root.Fields" />.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddDerivedField(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,TabularEditor.SemanticBridge.AbstractModel.DataType,System.Collections.Immutable.ImmutableDictionary{System.String,System.String},System.String)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> (computed table column) to this
+                Root.
+            </summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="ownerId" /> does not resolve to a table
+                in this Root.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddCalculatedMeasure(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,System.String,TabularEditor.SemanticBridge.AbstractModel.DataType,System.Collections.Immutable.ImmutableDictionary{System.String,System.String},TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,System.String)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" /> — an expression-based
+                measure — to this Root. An empty or <c>null</c>
+                <paramref name="expressions" /> signals the placeholder case; the
+                Abstract→TOM emitter materializes it as a placeholder body plus a
+                diagnostic.
+            </summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="ownerId" /> does not resolve to a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Fact" /> in this Root.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AddRelationship(System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.Cardinality,TabularEditor.SemanticBridge.AbstractModel.Cardinality,TabularEditor.SemanticBridge.AbstractModel.FilterDirection)">
+            <summary>
+                Add a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> to this Root. The model holds a
+                flat collection of edges; role-playing and snowflake chains express
+                themselves as multiple <c>Relationship</c> entries with distinct
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.LeftFieldId" />/
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.RightFieldId" /> pairs.
+            </summary>
+            <exception cref="T:System.ArgumentException">
+                Thrown when <paramref name="leftFieldId" /> or
+                <paramref name="rightFieldId" /> does not exist in
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Root.Fields" />.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.UpdateField``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.Func{``0,``0})">
+            <summary>
+                Update an existing field by id via a typed updater lambda. Replaces
+                the field at its dense-array slot and returns the new Root. Enforces
+                that the field at <paramref name="id" /> is of type
+                <typeparamref name="T" /> and that the updater preserves the original
+                <c>Id</c> (see <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" />).
+            </summary>
+            <typeparam name="T">
+                The concrete <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField" /> kind expected at
+                <paramref name="id" />. Constrained to <c>class</c> because all
+                field records are reference types.
+            </typeparam>
+            <exception cref="T:System.Collections.Generic.KeyNotFoundException">
+                Thrown when <paramref name="id" /> does not resolve in
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Root.Fields" />.
+            </exception>
+            <exception cref="T:System.InvalidOperationException">
+                Thrown when the field at <paramref name="id" /> is not of type
+                <typeparamref name="T" />, or when the updater returns a field with
+                a different <c>Id</c>.
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetTable(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId)">
             <summary>
-                Generates M expression for a QuerySource (custom SQL query).
-                Wraps a SQL query in Databricks connection context.
+                Resolve a polymorphic <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" /> reference to its
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />. Dispatches on the id's concrete kind.
             </summary>
-            <param name="source">The query source containing the SQL query text</param>
-            <returns>M expression that executes the query against Databricks</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.GenericSourceSystem.Equals(TabularEditor.SemanticBridge.AbstractModel.SourceSystems.GenericSourceSystem)">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.HasTable(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId)">
+            <summary>True when the polymorphic id resolves to a table in this Root.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetFieldsOf(TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId)">
+            <summary>
+                Fields owned by <paramref name="sourceId" /> — only
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> instances live under a source.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetFieldsOf(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId)">
             <summary>
-                Determines equality by comparing scalar properties and Properties dictionary contents.
+                Fields owned by <paramref name="tableId" /> — a mix of
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> and <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" />.
             </summary>
-            <param name="other">The other GenericSourceSystem to compare with</param>
-            <returns>True if both objects have equal scalar properties and equivalent Properties</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.GenericSourceSystem.GetHashCode">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.GetMeasuresOf(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId)">
             <summary>
-                Generates hash code based on scalar properties and Properties dictionary contents.
+                Measures owned by <paramref name="factId" />.
             </summary>
-            <returns>A hash code that remains consistent for equivalent objects</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.OdbcSourceSystem">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.EquivalentTo(TabularEditor.SemanticBridge.AbstractModel.Root)">
             <summary>
-                ODBC source system
+                Structural equivalence with another Root. Two Roots are equivalent
+                if their collections contain pairwise-equivalent objects and all
+                scalar root-level properties are equal.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.OdbcSourceSystem.#ctor(System.String,System.String,System.String,System.String)">
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use by the OLAP engine</param>
-            <param name="description">Description of the source system</param>
-            <param name="connectionIdentifier">DSN name or connection identifier</param>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.BodyCrossRefsEquivalent(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,TabularEditor.SemanticBridge.AbstractModel.Root)">
+            <summary>
+                Cross-reference walk over an AAST body. Mirrors the pointer
+                resolution that <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.RelationshipsEquivalent(TabularEditor.SemanticBridge.AbstractModel.Relationship,TabularEditor.SemanticBridge.AbstractModel.Relationship,TabularEditor.SemanticBridge.AbstractModel.Root)" /> does for
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.LeftFieldId" />/<see cref="P:TabularEditor.SemanticBridge.AbstractModel.Relationship.RightFieldId" />:
+                each opaque <c>Target</c> on the body resolves through its owning
+                Root, and the resolved <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure" />, <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" />,
+                or <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IField" /> on each side is compared structurally
+                via its own <c>EquivalentTo</c>. Body shape was already validated
+                by the caller's <see cref="M:TabularEditor.SemanticBridge.AbstractModel.Root.EquivalentTo(TabularEditor.SemanticBridge.AbstractModel.Root)" /> — this
+                pass only verifies that the AAST pointers point at equivalent
+                records.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.TablesEquivalent(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable)">
+            <summary>
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITable" /> does not declare
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IEquivalent`1" /> at the family level (its concrete
+                kinds live in split-typed collections), so equivalence between two
+                ITable values dispatches on concrete kind.
+            </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.OdbcSourceSystem.ConnectionIdentifier">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.AllHaveEquivalentMatchIn``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.Func{``0,``0,System.Boolean})">
             <summary>
-                DSN name or connection identifier
+                True when every item in <paramref name="expected" /> finds at least
+                one item in <paramref name="actual" /> for which
+                <paramref name="equivalentTo" /> returns true. O(n^2) by design:
+                scale-appropriate for the abstract model's collection sizes, and
+                keeps the implementation honestly dependent on the production
+                <c>EquivalentTo</c> rather than on any external key.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.OdbcSourceSystem.SystemIdentifier">
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.Root.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
             <inheritdoc />
         </member>
-        <member name="T:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.SqlServerSourceSystem">
+        <member name="T:TabularEditor.SemanticBridge.AbstractModel.SourceField">
             <summary>
-                SQL Server source system
+                A physical column on an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource" />. A leaf field — it
+                doesn't reference any other field. Table-side fields
+                (<see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />) map to a SourceField via
+                <c>SourceFieldId</c>.
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerSourceId">
+                Reference to the owning source; resolve via <c>Root.GetSource</c>.
+            </param>
+            <param name="DataType">The data type of this column.</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.SqlServerSourceSystem.#ctor(System.String,System.String,System.String,System.String,System.Int32)">
-            <param name="name">Friendly name for display to users</param>
-            <param name="technicalName">Name for internal use by the OLAP engine</param>
-            <param name="description">Description of the source system</param>
-            <param name="server">Server DNS name or IP address</param>
-            <param name="port">Optional port number (default is 1433)</param>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceField.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.String,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.DataType)">
+            <summary>
+                A physical column on an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource" />. A leaf field — it
+                doesn't reference any other field. Table-side fields
+                (<see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />) map to a SourceField via
+                <c>SourceFieldId</c>.
+            </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="OwnerSourceId">
+                Reference to the owning source; resolve via <c>Root.GetSource</c>.
+            </param>
+            <param name="DataType">The data type of this column.</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.SqlServerSourceSystem.Server">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceField.Description">
             <summary>
-                Server DNS name or IP address
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.SqlServerSourceSystem.Port">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceField.OwnerSourceId">
             <summary>
-                Port number for SQL Server connection
+                Reference to the owning source; resolve via <c>Root.GetSource</c>.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceSystems.SqlServerSourceSystem.SystemIdentifier">
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceField.DataType">
+            <summary>The data type of this column.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceField.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceField.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.AbstractModel.SourceField.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.AbstractModel.SourceField.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
             <inheritdoc />
         </member>
         <member name="T:TabularEditor.SemanticBridge.Exceptions.UnsupportedMappingException">
@@ -1088,6 +1958,37 @@
                 Generic visitor interface for traversing object graphs.
             </summary>
         </member>
+        <member name="T:TabularEditor.SemanticBridge.Orchestration.TransformationResult`1">
+            <summary>
+            	Result type for any transformation step in the Semantic Bridge.
+            </summary>
+            <typeparam name="T"></typeparam>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Orchestration.TransformationResult`1.Diagnostics">
+            <summary>
+            	Diagnostic messages related to this result. Success cases may carry
+            	warning and other non-failure informational messages.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Orchestration.TransformationResult`1.AddDiagnostics(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})">
+            <summary>
+            	Add diagnostic messages to the result. This is useful for multi-phase
+            	validations or processing.
+            </summary>
+            <returns>The same result with additional diagnostics includes</returns>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Orchestration.TransformationResult`1.Success">
+            <summary>
+            	A successful transformation or validation. Any non-failure
+            	diagnostics are available in `Diagnostics` for review.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Orchestration.TransformationResult`1.Failure">
+            <summary>
+            	The transformation or validation failed. Messages explaining why
+            	are available in `Diagnostics` for review.
+            </summary>
+        </member>
         <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService">
             <summary>
                 Databricks MetricView operations and state management service.
@@ -1161,7 +2062,7 @@
                 The validation function receives both the object and the validation context.
             </summary>
             <typeparam name="T">
-                Type of MetricView object the rule applies to (View, Join, Dimension, or Measure)
+                Type of MetricView object the rule applies to (View, Join, Field, or Measure)
             </typeparam>
             <param name="name">Unique name for the validation rule</param>
             <param name="category">Category for organizational purposes (e.g., "Naming", "Structure")</param>
@@ -1172,12 +2073,17 @@
                 A validation rule that can be used with <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Validate(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})" />
             </returns>
         </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule``1(System.String,System.String,System.Func{``0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}},System.String)">
+            <inheritdoc
+                cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule``1(System.String,System.String,System.Func{``0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
         <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean})">
             <summary>
                 Creates a validation rule for a specific type of MetricView object with simple predicate validation.
             </summary>
             <typeparam name="T">
-                Type of MetricView object the rule applies to (View, Join, Dimension, or Measure)
+                Type of MetricView object the rule applies to (View, Join, Field, or Measure)
             </typeparam>
             <param name="name">Unique name for the validation rule</param>
             <param name="category">Category for organizational purposes (e.g., "Naming", "Structure")</param>
@@ -1187,6 +2093,10 @@
                 A validation rule that can be used with <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Validate(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})" />
             </returns>
         </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
         <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean})">
             <summary>
                 Creates a validation rule for the root View object.
@@ -1197,6 +2107,10 @@
             <param name="isInvalid">Predicate function to determine if the view is invalid.</param>
             <returns>A validation rule for use in validation.</returns>
         </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
         <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean})">
             <summary>
                 Creates a validation rule specifically for Join objects.
@@ -1207,15 +2121,23 @@
             <param name="isInvalid">Predicate function that returns true when the join is invalid</param>
             <returns>A validation rule for Join objects</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForDimension(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension,System.Boolean})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForField(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field,System.Boolean})">
             <summary>
-                Creates a validation rule specifically for Dimension objects.
+                Creates a validation rule specifically for Field objects.
             </summary>
             <param name="name">Unique name for the validation rule</param>
             <param name="category">Category for organizational purposes</param>
-            <param name="message">Error message returned when the dimension is invalid</param>
-            <param name="isInvalid">Predicate function that returns true when the dimension is invalid</param>
-            <returns>A validation rule for Dimension objects</returns>
+            <param name="message">Error message returned when the field is invalid</param>
+            <param name="isInvalid">Predicate function that returns true when the field is invalid</param>
+            <returns>A validation rule for Field objects</returns>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForField(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForField(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
         </member>
         <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean})">
             <summary>
@@ -1227,7 +2149,11 @@
             <param name="isInvalid">Predicate function that returns true when the measure is invalid</param>
             <returns>A validation rule for Measure objects</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.ImportToTabular(TabularEditor.TOMWrapper.Model,System.String,System.String,System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}@,System.Boolean)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.ImportToTabular(TabularEditor.TOMWrapper.Model,System.String,System.String,System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}@,System.Boolean,System.String)">
             <summary>
                 Converts the currently loaded Databricks MetricView to a Tabular Model.
             </summary>
@@ -1236,6 +2162,7 @@
             <param name="databricksHttpPath">Databricks HTTP path for connection.</param>
             <param name="diagnostics">Diagnostic messages from validation and conversion.</param>
             <param name="failOnValidationErrors">If true, abort on validation errors before creating TOM objects.</param>
+            <param name="databaseName">The name of the database to be used for any native SQL queries</param>
             <returns>True if conversion succeeded, false if critical errors occurred.</returns>
             <exception cref="T:System.InvalidOperationException">Thrown when no MetricView is currently loaded.</exception>
         </member>
@@ -1257,67 +2184,353 @@
             </summary>
             <exception cref="T:System.InvalidOperationException">Thrown when no MetricView is currently loaded.</exception>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForDimension(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension,System.Boolean})">
             <summary>
-                Marker interface for all MetricView domain objects.
-                Used for type safety and identification in public API
+                Legacy name for "MakeValidationRuleForField". Produces
+                a <c>ValidationRule&lt;Dimension&gt;</c> via the generic
+                <c>MakeValidationRule&lt;T&gt;</c> factory with <c>T</c> inferred
+                as <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" />. The validation visitor picks up
+                <c>ValidationRule&lt;Dimension&gt;</c> rules alongside
+                <c>ValidationRule&lt;Field&gt;</c> rules and applies both against
+                each field in <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields" />.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForDimension(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForDimension(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1").</param>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem">
             <summary>
-                Interface for validation rules that can be applied to metric view objects.
-                ValidMetricViewRules encapsulate a specific validation check that produces
-                diagnostic messages when validation fails.
+                Databricks source system definition. Carries connection details
+                (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Host" />, <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.HttpPath" />) and optional
+                default-context fields (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Database" />, <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Schema" />,
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Port" />).
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="Host">Databricks host name or address.</param>
+            <param name="HttpPath">HTTP path for the Databricks workspace.</param>
+            <param name="Database">Optional default catalog/database.</param>
+            <param name="Schema">Optional default schema.</param>
+            <param name="Port">Port number (default 443).</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.Name">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.#ctor(TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceSystemId,System.String,System.String,System.String,System.String,System.String,System.String,System.String,System.Int32)">
             <summary>
-                Gets the unique name of the validation rule.
-                Names should be descriptive and indicate what the rule validates.
+                Databricks source system definition. Carries connection details
+                (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Host" />, <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.HttpPath" />) and optional
+                default-context fields (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Database" />, <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Schema" />,
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Port" />).
             </summary>
+            <param name="Id">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+            </param>
+            <param name="Name">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+            </param>
+            <param name="TechnicalName">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+            </param>
+            <param name="Description">
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
+            </param>
+            <param name="Host">Databricks host name or address.</param>
+            <param name="HttpPath">HTTP path for the Databricks workspace.</param>
+            <param name="Database">Optional default catalog/database.</param>
+            <param name="Schema">Optional default schema.</param>
+            <param name="Port">Port number (default 443).</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.Category">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Description">
             <summary>
-                Gets the category of the validation rule for organizational purposes.
-                Categories help group related rules (e.g., "Names", "Structure", "Expressions").
+                <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Description" path="/summary/node()" />
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.TargetType">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Host">
+            <summary>Databricks host name or address.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.HttpPath">
+            <summary>HTTP path for the Databricks workspace.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Database">
+            <summary>Optional default catalog/database.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Schema">
+            <summary>Optional default schema.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Port">
+            <summary>Port number (default 443).</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Id">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Id" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.TechnicalName">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.TechnicalName" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Name">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.AbstractModel.Interfaces.IModelObject.Name" path="/summary/node()" />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.SystemIdentifier">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem.Accept``1(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.RootDatabricksExtensions">
             <summary>
-                Gets the type of object this rule is designed to validate.
-                This allows for efficient filtering and application of rules.
+                Convenience extension for adding a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem" />
+                to a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" />. Wraps <c>Root.AddSourceSystem</c> with the
+                Databricks-specific construction.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Exceptions.MetricViewVersionException">
             <summary>
-                Validates the target object using the provided read-only context.
-                ValidMetricViewRules receive a read-only view to prevent accidental
-                mutation of validation state.
+                Thrown when a version-gated property is set on a MetricView object
+                whose version does not support it.
             </summary>
-            <param name="target">The object to validate</param>
-            <param name="context">
-                Read-only validation context with state information including path tracking
-                and uniqueness collections
-            </param>
-            <returns>
-                Collection of diagnostic messages for any validation failures, or an empty
-                collection if validation passes
-            </returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitable">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast">
             <summary>
-                This is a platform-specific interface that enables the visitor pattern
-                for traversing the MetricView object graph.
+                Builds an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression" /> AAST from a parsed
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression" />. Structural shapes the visitor recognizes
+                (currently only <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef" />) produce
+                matching AAST nodes; anything else falls through the base class's
+                abort path to <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Fallback" />, which collapses the body to
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> carrying the original
+                verbatim source for downstream platform-keyed emission.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitable.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor{``0})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Translate(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,System.String,System.Func{System.String,System.Nullable{TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId}},TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef,System.Nullable{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId}},System.String,System.String)">
             <summary>
-                Accepts a visitor that produces a result of type TResult.
-                The concrete type dispatches to the appropriate Visit overload on
-                the visitor based on its runtime type (View, Join, Dimension, or
-                Measure).
+                Translate <paramref name="sqlRoot" /> to an AAST in the context of
+                a measure named <paramref name="subjectName" /> at
+                <paramref name="subjectPath" />. <paramref name="verbatim" /> is
+                the original source text (used as the
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> payload when the
+                translation can't structurally model the shape).
+                <paramref name="resolveMeasureByName" /> looks up a declared
+                measure by name (case-insensitive in production); returns null for
+                unknown names.
+                <paramref name="ownerFactId" /> is the fact this measure belongs
+                to — used when a node's structural translation references the
+                owning table (e.g.,
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount" /> for <c>COUNT(*)</c>).
+                A metric view's measure body always reduces over the fact (dims
+                are left-outer-joined), so the owner is constrained to
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId" />; the AAST node's
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount.Target" /> stays
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" /> for emit-side flexibility.
             </summary>
-            <typeparam name="TResult">The type of value produced by the visitor</typeparam>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Fallback">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Numeric)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Boolean)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Null)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.BinaryOp)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Paren)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.IsRowCountShape(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall)">
+            <summary>
+                <c>COUNT(*)</c> or <c>COUNT(&lt;non-null literal&gt;)</c>, no
+                <c>DISTINCT</c>. <c>COUNT(NULL)</c> is excluded — it returns 0 in
+                SQL regardless of row count, so it's semantically not a row-count.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.IsColumnAggregationShape(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall,TabularEditor.SemanticBridge.AbstractModel.AggregationType@,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef@)">
+            <summary>
+                One of <c>SUM</c>/<c>AVG</c>/<c>AVERAGE</c>/<c>MIN</c>/<c>MAX</c>/
+                <c>COUNT</c> over a single column reference. <c>DISTINCT</c> is
+                only accepted in combination with <c>COUNT</c> (becomes
+                <see cref="F:TabularEditor.SemanticBridge.AbstractModel.AggregationType.DistinctCount" />); on any other
+                aggregation it's rejected.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.PeekTopLevelAggregationKind(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression)">
+            <summary>
+                Surface-only peek at the top-level structural aggregation kind of
+                <paramref name="root" />: returns the same answer
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall)" /> would build the
+                AAST node from — without resolving the column ref, so callers can
+                read intent even when the ref is unresolved and the AAST falls
+                back to <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" />. Used by
+                the visitor to preserve aggregation-driven measure-type inference
+                in the dim-unresolved recovery case.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewCollection`1">
+            <summary>
+                Read surface of a name-indexed collection of metric view child
+                objects. Name lookups are case-insensitive, matching the Databricks
+                SQL default (<c>spark.sql.caseSensitive=false</c>).
+            </summary>
+            <typeparam name="T">The type of metric view object in the collection</typeparam>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewCollection`1.Item(System.String)">
+            <summary>
+                Gets the item with the specified name.
+            </summary>
+            <exception cref="T:System.Collections.Generic.KeyNotFoundException">
+                If no item with the specified name exists
+            </exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewCollection`1.Find(System.String)">
+            <summary>
+                Finds an item by name, returning null if not found.
+            </summary>
+            <param name="name">The name to search for</param>
+            <returns>The item with the specified name, or null if not found</returns>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewCollection`1.Contains(System.String)">
+            <summary>
+                Determines whether an item with the specified name exists in the collection.
+            </summary>
+            <param name="name">The name to search for</param>
+            <returns>True if an item with the specified name exists</returns>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewItemOwner">
+            <summary>
+                The owning collection's contract toward its items: lets a child object
+                coordinate lifecycle operations with whichever collection holds it,
+                without knowing which collection that is (View.Joins, View.Fields,
+                View.Measures, or a nested Join.Joins).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewItemOwner.Remove(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase)">
+            <summary>
+                Removes the item from this owner. Reference-based; returns false if
+                the item is not (or no longer) owned by this collection.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewItemOwner.Rename(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase,System.String,System.String)">
+            <summary>
+                Validates and re-keys the name index for a pending rename. Throws
+                ArgumentException when newName already belongs to a different item
+                (case-insensitive) -- and does so BEFORE the item's Name mutates,
+                so a rejected rename leaves both the object and the index
+                untouched.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewNamedObject">
+            <summary>
+                Contract for the named child objects of a View (joins, fields,
+                measures). Renaming through <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewNamedObject.Name" /> keeps the owning
+                collection's name index consistent.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewNamedObject.IsDeleted">
+            <summary>
+                True once this object has been deleted from its parent collection.
+                Deleted objects are zombies: their properties remain readable, but
+                they are detached from the model and no longer serialize.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewNamedObject.Delete">
+            <summary>
+                Deletes this object from its parent collection. Idempotent.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject">
+            <summary>
+                Universal contract for all MetricView domain objects, root and
+                children alike. Used for type safety and identification in public API.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject.View">
+            <summary>
+                The root <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View" /> of the object graph this
+                object belongs to. The View itself returns the same instance, so
+                any object can be walked up to the root without pattern matching.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule">
+            <summary>
+                Interface for validation rules that can be applied to metric view objects.
+                ValidMetricViewRules encapsulate a specific validation check that produces
+                diagnostic messages when validation fails.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.Name">
+            <summary>
+                Gets the unique name of the validation rule.
+                Names should be descriptive and indicate what the rule validates.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.Category">
+            <summary>
+                Gets the category of the validation rule for organizational purposes.
+                Categories help group related rules (e.g., "Names", "Structure", "Expressions").
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.TargetType">
+            <summary>
+                Gets the type of object this rule is designed to validate.
+                This allows for efficient filtering and application of rules.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.VersionConstraint">
+            <summary>
+                Gets the version constraint for this rule, declaring which metric view
+                spec versions the rule applies to. Defaults to <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.All" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext)">
+            <summary>
+                Validates the target object using the provided read-only context.
+                ValidMetricViewRules receive a read-only view to prevent accidental
+                mutation of validation state.
+            </summary>
+            <param name="target">The object to validate</param>
+            <param name="context">
+                Read-only validation context with state information including path tracking
+                and uniqueness collections
+            </param>
+            <returns>
+                Collection of diagnostic messages for any validation failures, or an empty
+                collection if validation passes
+            </returns>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitable">
+            <summary>
+                This is a platform-specific interface that enables the visitor pattern
+                for traversing the MetricView object graph.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitable.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor{``0})">
+            <summary>
+                Accepts a visitor that produces a result of type TResult.
+                The concrete type dispatches to the appropriate Visit overload on
+                the visitor based on its runtime type (View, Join, Field, or
+                Measure).
+            </summary>
+            <typeparam name="TResult">The type of value produced by the visitor</typeparam>
             <param name="visitor">The visitor to accept</param>
             <returns>The result produced by the visitor</returns>
         </member>
@@ -1328,2702 +2541,4507 @@
                 This interface enables type-safe transformation of MetricView objects while
                 supporting generic orchestration through the base IVisitor interface.
             </summary>
-            <typeparam name="TResult">The type of value produced by visiting MetricView objects</typeparam>
+            <typeparam name="TResult">The type of value produced by visiting MetricView objects</typeparam>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+            <summary>
+                Visits a MetricView root object.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)">
+            <summary>
+                Visits a Join (dimension relationship) in the MetricView.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field)">
+            <summary>
+                Visits a Field (attribute) in the MetricView.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+            <summary>
+                Visits a Measure (metric) in the MetricView.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis">
+            <summary>
+                Shared SQL-expression analysis primitive consumed by
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis" />, <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis" />, and
+                Join.On analysis. Captures the parsed expression tree, the resolved
+                column references (deduped + canonicalized against the context's
+                implicit table), and parser/translator diagnostics.
+            </summary>
+            <remarks>
+                Each <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn" /> carries the table the column
+                effectively belongs to. Bare column references and references whose
+                qualifier matches the implicit table (case-insensitively) are reported
+                with the implicit-table literal as <c>Table</c>; explicit qualifiers
+                that do not match are preserved as written. Dedup is by record
+                equality on <c>(Table, ColumnName)</c>.
+            </remarks>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseResult,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn},System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})">
+            <summary>
+                Shared SQL-expression analysis primitive consumed by
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis" />, <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis" />, and
+                Join.On analysis. Captures the parsed expression tree, the resolved
+                column references (deduped + canonicalized against the context's
+                implicit table), and parser/translator diagnostics.
+            </summary>
+            <remarks>
+                Each <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn" /> carries the table the column
+                effectively belongs to. Bare column references and references whose
+                qualifier matches the implicit table (case-insensitively) are reported
+                with the implicit-table literal as <c>Table</c>; explicit qualifiers
+                that do not match are preserved as written. Dedup is by record
+                equality on <c>(Table, ColumnName)</c>.
+            </remarks>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn">
+            <summary>
+                A column reference from the analyzed expression, resolved against
+                the context's implicit table. <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn.Table" /> is the canonical
+                table this column effectively belongs to; <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn.ColumnName" />
+                is the column name as written in the SQL.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn.#ctor(System.String,System.String)">
+            <summary>
+                A column reference from the analyzed expression, resolved against
+                the context's implicit table. <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn.Table" /> is the canonical
+                table this column effectively belongs to; <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn.ColumnName" />
+                is the column name as written in the SQL.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn.CaseInsensitiveComparer">
+            <summary>
+                Equality on <c>(Table, ColumnName)</c> using
+                <see cref="F:System.StringComparison.OrdinalIgnoreCase" />. Databricks
+                SQL identifiers are case-insensitive, so refs differing only in
+                casing represent the same column.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.Of(System.String,System.Type,System.String,System.String,System.String)">
+            <summary>
+                Parse <paramref name="expression" />, extract resolved column
+                references against <paramref name="defaultTable" /> (deduped by
+                <c>(Table, ColumnName)</c>), and build diagnostics from the parse
+                result. <paramref name="subjectType" /> identifies what is being
+                analyzed for kind-aware diagnostic factory selection.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.BuildMeasureRefOutOfContextDiagnostics(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseResult,System.Type,System.String,System.String)">
+            <summary>
+                MEASURE references are only legal in measure bodies. In any other
+                context (field expression, join ON clause) every occurrence becomes a
+                pre-flight diagnostic. One per call site — per-occurrence visibility
+                lets the user fix each one in isolation.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldTarget">
+            <summary>
+                Routing decision for a field's resulting field: the fact table, or
+                a specific dimension table identified by name. <c>FieldTarget.Fact</c>
+                is the default when the analyzer cannot conclusively resolve refs to a
+                single non-source dim table (errors, source refs, multi-dim refs, zero
+                refs, parse errors, defense-in-depth fallback all route to Fact).
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject">
+            <summary>
+                The field being visited and the abstract-model field kind it
+                becomes. 
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.#ctor(System.String)">
+            <summary>
+                The field being visited and the abstract-model field kind it
+                becomes. 
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Simple">
+            <summary>
+                The field expression resolves to a single column reference: the
+                resulting abstract is a ReferenceField pointing at a SourceField
+                named <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Simple.SourceFieldName" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Simple.#ctor(System.String,System.String)">
+            <summary>
+                The field expression resolves to a single column reference: the
+                resulting abstract is a ReferenceField pointing at a SourceField
+                named <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Simple.SourceFieldName" />.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Derived">
+            <summary>
+                The field expression is complex: the resulting abstract is a
+                DerivedField carrying the verbatim <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Derived.Expression" />.
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Derived.UpstreamReferences" /> lists the columns the
+                expression depends on; the visitor ensures each one as a
+                ReferenceField + SourceField pair before creating the DerivedField.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Derived.#ctor(System.String,System.String,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn})">
+            <summary>
+                The field expression is complex: the resulting abstract is a
+                DerivedField carrying the verbatim <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Derived.Expression" />.
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Derived.UpstreamReferences" /> lists the columns the
+                expression depends on; the visitor ensures each one as a
+                ReferenceField + SourceField pair before creating the DerivedField.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Placeholder">
+            <summary>
+                The field expression is empty or whitespace-only: the resulting
+                abstract is a DerivedField with empty Expressions. Downstream
+                Abstract→TOM emits <c>DERIVED_FIELD_NO_EXPRESSION</c> and a
+                placeholder column body.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject.Placeholder.#ctor(System.String)">
+            <summary>
+                The field expression is empty or whitespace-only: the resulting
+                abstract is a DerivedField with empty Expressions. Downstream
+                Abstract→TOM emits <c>DERIVED_FIELD_NO_EXPRESSION</c> and a
+                placeholder column body.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis">
+            <summary>
+                Result of analyzing a Metric View <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" /> for
+                translation into the abstract model. Composed atop a shared
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis" /> (parsing, ref extraction, parse-level
+                diagnostics). Adds the field-specific kind decision
+                (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.VisitedField" />) and routing decision
+                (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.Target" />).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis,TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldTarget,TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.Subject)">
+            <summary>
+                Result of analyzing a Metric View <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" /> for
+                translation into the abstract model. Composed atop a shared
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis" /> (parsing, ref extraction, parse-level
+                diagnostics). Adds the field-specific kind decision
+                (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.VisitedField" />) and routing decision
+                (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.Target" />).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.Analyze(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field)">
+            <summary>
+                Analyze a Metric View field to determine the abstract-model
+                field shape it should produce.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldAnalysis.TargetForSingleRef(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef)">
+            <summary>
+                Routes a Simple subject's target based on the single column ref's
+                qualifier. Unqualified or matching the implicit table -> Fact. Any
+                other qualifier -> Dimension named after that qualifier (case
+                preserved from the SQL).
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper">
+            <summary>
+                Field-Root operations used by the MV→Abstract visitor: pair-creation
+                primitives (<see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureDeclared(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})" /> for user-declared subjects,
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureUpstream(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId})" /> for Expr-derived refs), the
+                placement-resolver wrapper (<see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.ResolveUpstreamRef(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})" />), and
+                post-hoc type opinion (<see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.SetFieldType(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.DataType)" />).
+            </summary>
+            <remarks>
+                The shared core <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsurePair(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.String,System.String)" /> is <c>private</c> — only the
+                two named frontends call it. This enforces at the type level that
+                callers commit to declaration vs. upstream intent rather than reaching
+                past the abstraction.
+            </remarks>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsurePair(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.String,System.String)">
+            <summary>
+                Materialize or reuse a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> +
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> pair. Idempotent by
+                <paramref name="refTechnicalName" /> on <paramref name="tableId" />
+                (case-insensitive). Bails (returns the existing id unchanged) when
+                any field already sits at that TechnicalName, including a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> (bail rule for the derived-aggregation
+                case). Newly-created fields use <see cref="F:TabularEditor.SemanticBridge.AbstractModel.DataType.String" />;
+                callers apply type opinions separately via
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.SetFieldType(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.DataType)" />. <paramref name="refDisplayName" /> and
+                <paramref name="description" /> are applied to a newly-created
+                ReferenceField only; existing fields are returned unchanged. When
+                <paramref name="refDisplayName" /> is empty, the field's Name falls
+                back to TechnicalName via Names.Or. SourceField description stays
+                empty (internal, never user-visible).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureDeclared(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})">
+            <summary>
+                Materialize or refine a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> +
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> pair for a user-declared MV subject
+                (Subject.Simple from an MV field). Caller supplies the full
+                metadata bundle, the resolved placement, the visitor's set of
+                already-declared field ids (consulted to distinguish placeholders
+                from declarations), and the diagnostics list (for collision
+                reporting).
+                <para>
+                    When an existing field at <paramref name="refTechnicalName" />
+                    is a placeholder (not in <paramref name="declaredFieldIds" />)
+                    with the same source binding, the declaration's metadata is
+                    applied to it — empty slots filled in, existing non-empty
+                    metadata preserved. The FieldId is unchanged; relationships
+                    and other references survive.
+                </para>
+                <para>
+                    The returned FieldId is added to
+                    <paramref name="declaredFieldIds" /> when the result is a
+                    ReferenceField, so later calls can distinguish this declared
+                    field from placeholders.
+                </para>
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.ComputeDedupSuffixName(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String)">
+            <summary>
+                Compute a dedup-suffix name by repeating
+                <paramref name="originalName" /> separated by underscores until the
+                result is unique among fields on <paramref name="tableId" />
+                (case-insensitive). Pathological collisions yield ugly names like
+                <c>pk_pk_pk</c>; that's accepted in exchange for trivial dedup
+                logic.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureUpstream(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId})">
+            <summary>
+                Materialize or reuse a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> +
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> pair for an implicitly-discovered
+                reference (a column extracted from an Expr or ON clause). Has no
+                metadata to apply — the caller is an upstream-ref site, not a
+                user-declared subject. Resulting field's display name falls back to
+                TechnicalName via Names.Or.
+                <para>
+                    Lookup is by TechnicalName first. When the name-match is a
+                    declaration whose source binding differs from
+                    <paramref name="sourceFieldName" /> (the result of an
+                    <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureDeclared(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})" /> rename collision), the upstream
+                    ref isn't asking for that declaration — it's asking for the
+                    field backed by the requested SQL column. Falls back to
+                    finding any non-declared ReferenceField backed by that
+                    SourceField.
+                </para>
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.ResolveUpstreamRef(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})">
+            <summary>
+                Placement resolver for <paramref name="resolvedRef" />: resolves
+                against <c>Root.Dimensions</c>, delegates to
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureUpstream(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId})" /> on the resolved branch (source-side
+                -> Fact, dim-side -> matching dim), and falls back to a Fact-side
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> placeholder named <c>"table.column"</c>
+                plus an <c>UNRESOLVED_DIMENSION_REFERENCE</c> warning on the
+                unresolved branch. Newly-created fields are always
+                <see cref="F:TabularEditor.SemanticBridge.AbstractModel.DataType.String" />; type opinions flow through
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.SetFieldType(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.DataType)" /> separately.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.SetFieldType(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.DataType)">
+            <summary>
+                Sets a field's <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DataType" />. Updates a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" /> AND its linked <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" />
+                in lockstep, OR a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> on its own (no
+                SourceField behind it). Direct hits on a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" />
+                id are a no-op — SourceField data types flow through the
+                ReferenceField lockstep, not direct mutation. The caller decides
+                whether to call; there's no "no opinion" sentinel inside the
+                function. Silently swallows a stale or unknown
+                <paramref name="fieldId" /> rather than throw — id-integrity bugs
+                are caught upstream by the <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureDeclared(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})" /> /
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.EnsureUpstream(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,System.String,System.String,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId})" /> returns the visitor threads through.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.SetFormat(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.String)">
+            <summary>
+                Sets a field's <c>Format</c>. Applies to <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />
+                and <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> alike; <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> has
+                no Format (it's internal, never user-visible). Silently swallows a
+                stale or unknown <paramref name="fieldId" />, matching the
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.SetFieldType(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.DataType)" /> robustness pattern.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis">
+            <summary>
+                Result of analyzing a Metric View <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure" /> for
+                translation into the abstract model. Composed atop a shared
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis" /> (parsing, ref extraction, parse-level
+                diagnostics). The record itself is the kind discriminator: a measure
+                analyzed expression resolves to <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated" />,
+            	or <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Placeholder" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis,System.String)">
+            <summary>
+                Result of analyzing a Metric View <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure" /> for
+                translation into the abstract model. Composed atop a shared
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis" /> (parsing, ref extraction, parse-level
+                diagnostics). The record itself is the kind discriminator: a measure
+                analyzed expression resolves to <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated" />,
+            	or <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Placeholder" />.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated">
+            <summary>
+                The measure expression is complex: multi-arg aggregation, nested
+                function, arithmetic, CASE, an unknown function, or anything else
+                that doesn't fit the Simple pattern. The resulting abstract is a
+                calculated measure carrying the verbatim <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated.Expression" />.
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated.UpstreamReferences" /> lists the columns the expression
+                depends on so the visitor can ensure them before creating the
+                calculated measure.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis,System.String,System.String,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn})">
+            <summary>
+                The measure expression is complex: multi-arg aggregation, nested
+                function, arithmetic, CASE, an unknown function, or anything else
+                that doesn't fit the Simple pattern. The resulting abstract is a
+                calculated measure carrying the verbatim <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated.Expression" />.
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated.UpstreamReferences" /> lists the columns the expression
+                depends on so the visitor can ensure them before creating the
+                calculated measure.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Placeholder">
+            <summary>
+                The measure expression is empty or whitespace-only: the resulting
+                abstract is a placeholder calculated measure with no expression.
+                Downstream Abstract→TOM emits the placeholder body and a warning.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Placeholder.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis,System.String)">
+            <summary>
+                The measure expression is empty or whitespace-only: the resulting
+                abstract is a placeholder calculated measure with no expression.
+                Downstream Abstract→TOM emits the placeholder body and a warning.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Analyze(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+            <summary>
+                Analyze a Metric View measure to determine the abstract-model
+                measure shape it should produce. After the
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression" /> AAST landed, classification
+                collapsed to <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Placeholder" /> (empty body) and
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MeasureAnalysis.Calculated" /> (everything else): structural recognition
+                happens at AAST-build time in <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast" />, not here.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.FormatTranslationLossy(System.String)">
+            <summary>
+                Emitted when an MV format spec cannot be translated to TOM
+                FormatString without information loss. Covers two flavors:
+                (a) lossy translation — a best-effort FormatString is emitted but
+                some user intent is dropped (e.g., locale_short_month maps to
+                Long Date, losing the "short" specificity); (b) untranslatable
+                drop with ISO fallback — no FormatString equivalent exists, and
+                the translator falls back to an ISO date/time form so the user
+                gets an unambiguous rendering rather than nothing. Warning
+                severity in both cases — the user's explicit format intent is
+                not fully honored.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.FieldCollisionRename(System.String,System.String)">
+            <summary>
+                Emitted when a user-declared field collides with an existing
+                implementation-detail placeholder field at the same
+                <paramref name="originalName" /> on the target table, with a
+                different SQL source binding. The placeholder is renamed to
+                <paramref name="renamedName" /> (preserving the relationship
+                wiring that referenced it); the declaration takes the original
+                name with its declared source. Information severity: this rename
+                is deterministic accommodation of the user's explicit
+                declaration, not a problem to fix.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.UnresolvedDimensionReference(System.String,System.String)">
+            <summary>
+                Emitted by <c>EnsureField</c> when a column reference's table
+                qualifier does not resolve to a known dimension (and is not
+                <c>"source"</c>). The visitor recovers by placing a placeholder
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" />
+                on the Fact preserving the original ref text; this diagnostic
+                surfaces that the dim wiring is missing so the user can either
+                declare the join or fix the typo.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.JoinOnEmpty(System.String,System.String)">
+            <summary>
+                Emitted when a join's <c>On</c> clause is empty or whitespace.
+                The dim and its source are created, but no FK/PK pair is wired —
+                downstream model is structurally incomplete on the join side.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.JoinOnUnrecognized(System.String,System.String,System.String)">
+            <summary>
+                Emitted when a join's <c>On</c> clause can't be parsed or doesn't
+                take the expected shape of a single equality (e.g., a different
+                comparison operator, unparseable SQL). The dim and its source
+                are created, but no FK/PK pair is wired.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.JoinOnNoSourceSide(System.String,System.String,System.String)">
+            <summary>
+                Emitted when a join's <c>On</c> clause is a binary equality but
+                the two refs don't pair a source-qualified column with a
+                dim-qualified column. Either both refs land on the same side, or
+                one of them carries an unrelated qualifier. The dim and its
+                source are created, but no FK/PK pair is wired.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.OneToManyJoinUntranslated(System.String,System.String)">
+            <summary>
+                Emitted when a join declares <c>cardinality: one_to_many</c>. The
+                v1.1 spec treats the joined table as an independent fact source
+                aggregated separately at the source grain; the translator does
+                not currently model that shape. The joined table is still mapped
+                so it stays visible in the resulting model, but the FK/PK
+                relationship to the source is skipped. Measures that reference
+                columns from this table must be reviewed and evaluated by hand
+                — without the relationship the generated DAX cannot bring those
+                columns into context and will produce wrong or empty results at
+                refresh.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.DuplicateJoinDimension(System.String,System.String)">
+            <summary>
+                Emitted when a join would create a dimension whose name collides
+                with an existing dimension — e.g. the same join name nested under
+                two different parents. Join names are unique across a metric view
+                (enforced by the UniqueJoinName validation rule), so this only fires
+                when validation was bypassed; the duplicate dimension is skipped (the
+                existing one stands) and translation continues. Warning severity —
+                the model is incomplete for the skipped branch.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.StructReferenceUnsupported(System.String,System.String,System.String)">
+            <summary>
+                Emitted when a dimension expression references a joined table as a
+                whole-row or nested struct value (e.g. <c>customer</c> or
+                <c>customer.nation</c>, where the referenced name is itself a join)
+                rather than a scalar column. Tabular has no column equivalent for a
+                struct/row value: the column is still emitted so the model stays
+                buildable, but it binds to a non-existent source column and will not
+                resolve at refresh. Warning severity — the reference is valid in the
+                metric view but untranslatable here.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.ExpressionUntranslated(System.Type,System.String,System.String,System.String)">
+            <summary>
+                Used for surviving Unknown nodes — constructs that parsed cleanly
+                into the AST but for which we have no translation path. Code and
+                message are kind-specific: field and measure bodies fall back to a
+                comment-block wrap of the original expression downstream, while an
+                untranslatable join ON clause yields the joined tables without a
+                relationship.
+            </summary>
+            <param name="subjectType">
+                what is being analyzed: <c>typeof(Field)</c>,
+                <c>typeof(Measure)</c>, or <c>typeof(Join)</c>
+            </param>
+            <param name="objectName">
+                the object's declared name (formatted into the message)
+            </param>
+            <param name="path">canonical object path (anchor for navigation)</param>
+            <param name="context">
+                diagnostic context: the unhandled construct or semantic error
+                rendered with its source text
+            </param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.ExpressionParseError(System.Type,System.String,System.String,System.String,System.String)">
+            <summary>
+                Used when ANTLR's lexer or parser reports an error against the
+                subject's expression, i.e., the source SQL itself didn't parse.
+                Distinct from <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.ExpressionUntranslated(System.Type,System.String,System.String,System.String)" />, which signals
+                a parsed-but-unhandled construct. As the parser grows in coverage
+                this code becomes a clear "the user's SQL is the problem" signal
+                rather than "we don't translate this yet." The code is
+                kind-specific; the message carries the kind word.
+            </summary>
+            <param name="subjectType">
+                what is being analyzed: <c>typeof(Field)</c>,
+                <c>typeof(Measure)</c>, or <c>typeof(Join)</c>
+            </param>
+            <param name="path">canonical object path (anchor for navigation)</param>
+            <param name="offendingText">
+                the offending source slice — preferably the tight span of the
+                surviving Unknown that overlapped this error; falls back to the
+                parser's own context text otherwise
+            </param>
+            <param name="errorContext">parser/lexer error context (typically short)</param>
+            <param name="errorMessage">parser/lexer error message (typically longer)</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.FieldConfigurationUnexpected(System.String,System.String,System.String)">
+            <summary>
+                Defense-in-depth diagnostic for the case-analysis fallback in
+                <c>FieldAnalysis.Analyze</c>. The case analysis is exhaustive
+                today, so this should never fire; if it does, future grammar or
+                visitor changes have broken our routing invariants. We surface a
+                distinct code so the failure is identifiable in support requests,
+                and we route the dimension to a Fact field as the safe default
+                rather than throw.
+            </summary>
+            <param name="fieldName">dimension name (for the user-facing message)</param>
+            <param name="path">canonical dimension path (anchor for navigation)</param>
+            <param name="context">
+                diagnostic context — typically the dimension expression and a brief
+                description of which routing branches were considered
+            </param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MeasureRefOutOfContext(System.Type,System.String,System.String,System.String)">
+            <summary>
+                Emitted when a <c>MEASURE(name)</c> reference appears in an
+                expression context that does not permit it (dimension expressions
+                and join ON clauses). The expression continues to flow through the
+                existing best-effort emission path; this diagnostic surfaces the
+                structural violation pre-flight so the user can correct the MV.
+                One diagnostic is emitted per occurrence — per-call-site visibility
+                is preferred over a single summary so each site can be fixed in
+                isolation.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.UnresolvedMeasureReference(System.String,System.String,System.String)">
+            <summary>
+                Emitted when a <c>MEASURE(name)</c> reference cannot be resolved to
+                a measure declared in the Root under construction. The MV spec
+                forbids forward references, so this typically indicates a typo or
+                a missing measure declaration. The AAST collapses to
+                <c>Unstructured(verbatim)</c>; downstream emission falls back to
+                the platform-keyed source text with the usual untranslated warning.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.DeserializationWarn(System.String,System.String,System.String,System.String)">
+            <summary>
+                Create a warning diagnostic with a templatized message indicating
+                that the warning originated during deserialization.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingFormatType(System.String)">
+            <summary>
+                Used when the format specification is missing the required `type`
+                property in YAML.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingVersion(System.String)">
+            <summary>
+                Use when the metric view is missing required `version` property in
+                YAML.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownFormatType(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.FormatDto,System.String)">
+            <summary>
+                The format type provided (YAML `type` property) is not known.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownAbbreviation(System.String,System.String)">
+            <summary>
+                Format abbreviation value didn't match any known abbreviation.
+                The format keeps no abbreviation (null).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingDateFormat(System.String)">
+            <summary>
+                <c>date_format</c> was omitted on a Date/DateTime format.
+                Defaults to <c>year_month_day</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownDateFormat(System.String,System.String)">
+            <summary>
+                <c>date_format</c> value didn't match any known DateFormatSpec.
+                Defaults to <c>year_month_day</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingTimeFormat(System.String)">
+            <summary>
+                <c>time_format</c> was omitted on a DateTime format.
+                Defaults to <c>locale_hour_minute_second</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownTimeFormat(System.String,System.String)">
+            <summary>
+                <c>time_format</c> value didn't match any known TimeFormatSpec.
+                Defaults to <c>locale_hour_minute_second</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingDecimalType(System.String)">
+            <summary>
+                <c>decimal_places.type</c> was omitted. Defaults to <c>all</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownDecimalType(System.String,System.String)">
+            <summary>
+                <c>decimal_places.type</c> value didn't match any known
+                DecimalType. Defaults to <c>all</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingSemiadditive(System.String)">
+            <summary>
+                <c>semiadditive</c> was omitted on a window spec.
+                Defaults to <c>Last</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownSemiadditive(System.String,System.String)">
+            <summary>
+                <c>semiadditive</c> value didn't match any known
+                SemiadditiveType. Defaults to <c>Last</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingMaterializationMode">
+            <summary>
+                <c>materialization.mode</c> was omitted. Defaults to <c>relaxed</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownMaterializationMode(System.String)">
+            <summary>
+                <c>materialization.mode</c> value didn't match any known
+                MaterializationMode. Defaults to <c>relaxed</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewMissingMaterializedViewType(System.String)">
+            <summary>
+                <c>type</c> was omitted on a materialized view spec.
+                Defaults to <c>unaggregated</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownMaterializedViewType(System.String,System.String)">
+            <summary>
+                <c>type</c> value on a materialized view spec didn't match
+                any known MaterializedViewType. Defaults to <c>unaggregated</c>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewVersionMismatch(System.String,System.String)">
+            <summary>
+                Setting a versioned property raised a
+                <c>MetricViewVersionException</c> through reflection — the
+                property exists but isn't valid for the view's declared version.
+                The message text comes from the underlying exception.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewDeprecatedDimensionsKeyword">
+            <summary>
+                Emitted when a metric view's YAML uses the legacy
+                <c>dimensions:</c> keyword at the top level on a v1.1-or-later
+                view. The canonical form starting in v1.1 is <c>fields:</c>; both
+                keywords continue to work, so this is informational. Fires at most
+                once per file. Scope is the top-level keyword only — the
+                materialization block's <c>dimensions:</c> field-name list is
+                canonical at all versions and does not trigger this diagnostic.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewFieldsKeywordPreV11(System.String)">
+            <summary>
+                Emitted when a metric view's YAML uses the <c>fields:</c> keyword
+                at the top level on a pre-v1.1 view. The <c>fields:</c> alias
+                became canonical in v1.1; on earlier versions <c>dimensions:</c>
+                is canonical. We don't refuse the read — Databricks doesn't
+                document <c>fields:</c> as illegal in older versions — but
+                surface the mismatch as a soft warning. Fires at most once per
+                file.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewUnknownJoinCardinality(System.String,System.String)">
+            <summary>
+                The value of a join's <c>cardinality:</c> field was not a known
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality" /> value. The join's cardinality
+                defaults to <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.ManyToOne" /> on this
+                path.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewFieldsAndDimensionsBothPresent">
+            <summary>
+                A metric view's YAML declared both top-level <c>fields:</c> and
+                <c>dimensions:</c>. The two keywords are aliases for the same
+                collection; declaring both is ambiguous, so deserialization
+                fails. The fields/dimensions block is skipped on this path
+                (the resulting view has no fields) and the diagnostic is
+                surfaced as a <see cref="T:TabularEditor.SemanticBridge.Orchestration.TransformationResult`1.Failure" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.MetricViewDuplicateName(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase,System.String)">
+            <summary>
+                A second object in the YAML claimed a name already used in the same
+                collection (case-insensitive, matching the Databricks SQL default).
+                Deserialization fails: the object model cannot hold duplicate names,
+                and every metric view name is a SQL alias, so duplicates fail at
+                declare or query time on the platform regardless. Kind and path
+                derive from the first claimant, so they cannot disagree with each
+                other or the collection.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor">
+            <summary>
+                Visitor that maps a MetricView (<see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View" />) to an
+                abstract-model <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" />. Constructs the Root directly via
+                <c>Root.AddX</c> pure-functional operations — no builder or fragment
+                intermediate layer. Accumulates the in-progress Root across Visit calls
+                via <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor._root" />; each Visit returns the (updated) Root.
+                Diagnostics encountered during traversal are exposed via
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.Diagnostics" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.#ctor(System.String,System.String,System.String)">
+            <summary>
+                Visitor that maps a MetricView (<see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View" />) to an
+                abstract-model <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" />. Constructs the Root directly via
+                <c>Root.AddX</c> pure-functional operations — no builder or fragment
+                intermediate layer. Accumulates the in-progress Root across Visit calls
+                via <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor._root" />; each Visit returns the (updated) Root.
+                Diagnostics encountered during traversal are exposed via
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.Diagnostics" />.
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.EmptyMetricViewRoot">
+            <summary>
+                An empty <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" /> tagged for MetricView translation.
+                Shared between the visitor's internal seed state and test setup
+                helpers so <c>expected</c>/<c>actual</c> roots agree on Name and
+                TechnicalName trivially.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.WireJoinKeys(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)">
+            <summary>
+                Wires this join's foreign-key/primary-key <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />
+                pair and the resulting <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" />. The upstream side
+                of the ON clause is the parent join's table: the metric-view source
+                (<c>"source"</c>) for a top-level join, or the parent dimension for a
+                nested (snowflake) join. Best-effort — a malformed ON clause emits a
+                classified <c>JOIN_ON_*</c> diagnostic and returns without wiring; the
+                dimension table created by the caller stands.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.ApplyFieldFormatAndType(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format)">
+            <summary>
+                Translates a user-declared MV format and applies it (plus the
+                resulting inferred DataType) to the abstract field at
+                <paramref name="fieldId" />. No-op when <paramref name="mvFormat" />
+                is null. Used by every dim-side branch (Subject.Simple normal,
+                Subject.Simple recovery, Subject.Derived, Subject.Placeholder)
+                after the field has been created or refined.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.TranslateMeasureFormat(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format)">
+            <summary>
+                Translates a user-declared MV measure format to a TOM FormatString
+                and appends any lossy-translation diagnostics. Returns empty when
+                no format is declared. Caller is responsible for using the result
+                as the measure's Format value.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.TranslateMeasureBody(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+            <summary>
+                Builds an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression" /> body for a measure
+                about to be added as <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" />. Routes
+                through <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Expression.MvSqlToAast" />, which resolves MEASURE
+                references against the in-progress Root (case-insensitive
+                name match) and falls back to
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> for shapes it
+                doesn't yet model structurally. Diagnostics from the translation
+                are appended to <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor._diagnostics" />.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.ResolveFieldIdForColumnRef(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef)">
+            <summary>
+                Resolves a SQL <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef" /> to its
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId" /> in the in-progress Root. The caller is
+                expected to have already ensured the field (via
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldHelper.ResolveUpstreamRef(TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId,TabularEditor.SemanticBridge.AbstractModel.Interfaces.SourceId,TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis.ResolvedColumn,System.Collections.Generic.HashSet{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId},System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})" />); this lookup is
+                read-only and returns null when the ref doesn't resolve, which
+                causes the AAST builder to abort and fall back.
+                <para>
+                    Table resolution mirrors
+                    <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.ExpressionAnalysis" />'s rule: bare or
+                    <c>source</c>-qualified refs land on the owning Fact;
+                    dim-qualified refs target the named dim. Field resolution
+                    within the table follows source binding first (so a renamed
+                    placeholder whose <c>TechnicalName</c> no longer matches the
+                    SQL column still resolves correctly), preferring the field
+                    whose own <c>TechnicalName</c> also matches the SQL column
+                    (the canonical placeholder over a same-source user
+                    declaration). Falls back to a name match for
+                    <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> targets, which have no source
+                    binding.
+                </para>
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.CollectColumnAggregations(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)">
+            <summary>
+                Walks the AAST yielding every <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation" />
+                reachable from <paramref name="body" />. Used by the measure
+                visitor to apply per-field type opinions after the body has been
+                translated.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.ApplyFieldTypeOpinion(TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.SemanticBridge.AbstractModel.AggregationType)">
+            <summary>
+                Apply the aggregation's field-type opinion to the field at
+                <paramref name="fieldId" /> via
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatInference.InferFieldType(TabularEditor.SemanticBridge.AbstractModel.DataType,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format,System.Boolean,System.Nullable{TabularEditor.SemanticBridge.AbstractModel.AggregationType})" />: String → Decimal
+                under SUM/AVG/MIN/MAX, no opinion under counts, key Integer
+                preserved against non-date opinions.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.InferAggregationFromBody(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression)">
+            <summary>
+                Picks the <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AggregationType" /> opinion the body
+                contributes to the measure's DataType inference: a top-level
+                column aggregation contributes its kind; a top-level row count
+                contributes <see cref="F:TabularEditor.SemanticBridge.AbstractModel.AggregationType.Count" />; anything else
+                contributes nothing (caller falls back to format-driven type or
+                the Decimal default).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.ResolveMeasureByName(System.String)">
+            <summary>
+                Case-insensitive name lookup against the in-progress
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor._measuresByName" /> cache. Forward references are
+                forbidden by the MV spec, so the cache is authoritative at the
+                moment of translation — every previously-emitted measure has been
+                indexed.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.SerializeWindowSpec(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+            <summary>
+                Re-serializes a measure's window specification(s) to a source-shaped
+                YAML fragment, or returns <c>null</c> when the measure declares none.
+                Carried on the abstract measure as
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.UnsupportedWindowSpec" />.
+                TODO (#6347): drop once windowed measures are translated natively.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewToAbstractVisitor.AddSource(TabularEditor.SemanticBridge.AbstractModel.Root,System.String,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem)">
+            <summary>
+                Appends an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource" /> derived from
+                <paramref name="source" /> to <paramref name="root" />, linked to
+                <paramref name="sourceSystem" /> and labeled with
+                <paramref name="name" />. <paramref name="source" /> parsed as a
+                3-part identifier produces a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource" />; anything
+                else produces a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QuerySource" /> carrying the string
+                verbatim.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewTraverser">
+            <summary>
+                Traverses a MetricView object graph and returns all nodes using the visitor pattern.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewTraverser.Traverse(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+            <summary>
+                Returns all objects in the MetricView graph.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.SourceHelper.ParseSqlObject(System.String)">
+            <summary>
+                Parses a 3-part SQL table name into its constituent parts.
+            </summary>
+            <param name="source">The source string to parse</param>
+            <returns>Database, schema, and table names if parsing succeeds; null otherwise</returns>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.ViewDto">
+            <summary>
+                DTO for Databricks Metric View YAML serialization.
+                Uses snake_case naming convention via YamlDotNet configuration.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.FieldDto">
+            <summary>
+                DTO for field definitions in YAML
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.MeasureDto">
+            <summary>
+                DTO for measure definitions in YAML
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.JoinDto">
+            <summary>
+                DTO for join definitions in YAML
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.RelyDto">
+            <summary>
+                DTO for the v1.1 <c>rely:</c> map on joins.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.FormatDto">
+            <summary>
+                DTO for format specification in YAML
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.DecimalPlacesDto">
+            <summary>
+                DTO for decimal places specification
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.WindowSpecDto">
+            <summary>
+                DTO for window specification
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.MaterializationDto">
+            <summary>
+                DTO for materialization configuration
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.MaterializedViewSpecDto">
+            <summary>
+                DTO for materialized view specification
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field">
+            <summary>
+                Represents a field definition in a Databricks Metric View
+            </summary>
+            <remarks>
+                A field in a Metric View is a single field. There is no namespacing
+                or delineation of separate named collections of fields.
+            </remarks>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.ToString">
+            <summary>
+                Masks the runtime <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> type name introduced by
+                the legacy shim so logs, debugger tooltips, and default
+                <c>ToString()</c> consumers always see the canonical "Field" label
+                regardless of which subtype currently backs the instance.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.Name">
+            <summary>
+                The YAML name for the field
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.Expr">
+            <summary>
+                The YAML string representing the expression for this field,
+                either a field reference or scalar SQL expression.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.Comment">
+            <summary>
+                Description of the field. Requires version 1.1+.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.DisplayName">
+            <summary>
+                Human-readable display name. Requires version 1.1+.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.Synonyms">
+            <summary>
+                Alternative names for AI/search. Requires version 1.1+.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.Format">
+            <summary>
+                Display format specification. Requires version 1.1+.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension">
+            <summary>
+                Legacy name for <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" />. Retained as an obsolete subclass
+                so external code still compiles during the deprecation window. Every
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" /> instance constructed via <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField(System.String,System.String)" />
+                or <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddDimension(System.String,System.String)" /> is actually a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" />
+                at runtime, so a cast (<c>(Dimension)field</c>) succeeds and returns the
+                same reference.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format">
+            <summary>
+                Databricks Metric View format specifications
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Type">
+            <summary>
+                The type of format (i.e., "number", "currency", "percentage",
+                "byte", "date", "datetime")
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Date">
+            <summary>
+                Date: Use date format for date values with various display options.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Date.Type">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Date.DateFormat">
+            <summary>
+                Controls the way the date is displayed
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Date.LeadingZeros">
+            <summary>
+                Controls whether single digit numbers are preceded by a zero
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateTime">
+            <summary>
+                DateTime format specification
+            </summary>
+            <remarks>
+                When working with a `DateTime` type, at least one of `DateFormat`
+                or `TimeFormat` must specify a value other than `NoDate` or
+                `NoTime`.
+            </remarks>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateTime.Type">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateTime.TimeFormat">
+            <summary>
+                Time format specification
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec">
+            <summary>
+                Controls the way the date is displayed
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec.NoDate">
+            <summary>
+                >
+                Date is hidden (only valid for DateTime, not for Date)
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec.LocaleShortMonth">
+            <summary>
+                Displays the date with an abbreviated month
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec.LocaleLongMonth">
+            <summary>
+                Displays the date with the full name of the month
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec.YearMonthDay">
+            <summary>
+                Formats the date as YYYY-MM-DD
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec.LocaleNumberMonth">
+            <summary>
+                Displays the date with a month as a number
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DateFormatSpec.YearWeek">
+            <summary>
+                Formats the date as a year and a week number. For example, `2025-W1`
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.TimeFormatSpec">
+            <summary>
+                Controls the way the time is displayed
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.TimeFormatSpec.NoTime">
+            <summary>
+                Time is hidden
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.TimeFormatSpec.LocaleHourMinute">
+            <summary>
+                Displays the hour and minute
+            </summary>
+        </member>
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.TimeFormatSpec.LocaleHourMinuteSecond">
+            <summary>
+                Displays the hour, minute, and second
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.BaseNumber.Type">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.BaseNumber.DecimalPlaces">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.BaseNumber.HideGroupSeparator">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Number">
+            <summary>
+                Number: Use plain number format for general numeric values with optional
+                decimal place control and abbreviation options.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Number.Type">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Number.Abbreviation">
+            <summary>
+                Abbreviation style: none, compact, or scientific
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Currency">
+            <summary>
+                Currency: Use currency format for monetary values with ISO-4217 currency codes.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Currency.Type">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Currency.CurrencyCode">
+            <summary>
+                ISO 4217 currency code (e.g., "USD", "EUR", "JPY")
+            </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Percentage">
             <summary>
-                Visits a MetricView root object.
+                Percentage: Use percentage format for ratio values expressed as percentages.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Percentage.Type">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Byte">
             <summary>
-                Visits a Join (dimension relationship) in the MetricView.
+                Byte: Use byte format for data size values displayed with appropriate
+                byte units (KB, MB, GB, etc.).
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.Byte.Type">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DecimalPlaceSpec">
             <summary>
-                Visits a Dimension (attribute) in the MetricView.
+                Specifies decimal place formatting.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DecimalPlaceSpec.Type">
             <summary>
-                Visits a Measure (metric) in the MetricView.
+                Type of decimal formatting: "max", "exact", or "all"
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.AbstractModelBuilderVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitable)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.DecimalPlaceSpec.Places">
             <summary>
-                Entry point for generic visitor pattern orchestration.
-                Delegates to the visitable object's Accept method for double dispatch,
-                which calls back to the appropriate type-specific Visit method (View, Join, Dimension, or Measure).
-                This method enables generic orchestration code to work with MetricView objects
-                through the IVisitor interface while maintaining complete type safety.
-                The compiler enforces that only IMetricViewVisitable objects can be passed to this method.
+                Number of decimal places (0-10). Null if not specified.
             </summary>
-            <param name="visitable">The MetricView object to visit (View, Join, Dimension, or Measure)</param>
-            <returns>The builder with fragments added based on the visited object</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.AbstractModelBuilderVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.IMetricViewNumericFormat.DecimalPlaces">
             <summary>
-                Create relationship and dimension reference fragments from the join.
-                Ensure that the fields referenced are in the fact and dimension.
-                Ensure the dimension exists.
+                Decimal places configuration
             </summary>
-            <param name="join"></param>
-            <returns></returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldFragmentHelper">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.IMetricViewNumericFormat.HideGroupSeparator">
             <summary>
-                Helper for managing field fragments during Metric View to Abstract Model mapping.
-                Handles field lookup, creation, and type updates for fields referenced by measures.
+                Whether to hide the group separator (e.g., commas in 1,000)
             </summary>
-            <remarks>
-                This helper encapsulates the logic for ensuring fields exist in both the fact table
-                and its source, managing data type updates when measures require Decimal types,
-                and searching for existing fields by name or technical name.
-            </remarks>
-            <remarks>
-                Creates a new FieldFragmentHelper for managing field fragments.
-            </remarks>
-            <param name="builder">The model builder containing all fragments</param>
-            <param name="fact">The fact fragment to manage fields for</param>
-            <param name="factSource">The source fragment for the fact</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldFragmentHelper.#ctor(TabularEditor.SemanticBridge.AbstractModel.Builder.IAbstractModelBuilder,TabularEditor.SemanticBridge.AbstractModel.Builder.FactFragment,TabularEditor.SemanticBridge.AbstractModel.Builder.SourceFragment)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format.FormatType">
             <summary>
-                Helper for managing field fragments during Metric View to Abstract Model mapping.
-                Handles field lookup, creation, and type updates for fields referenced by measures.
+                The type of format (i.e., "number", "currency", "percentage",
+                "byte", "date", "datetime")
             </summary>
-            <remarks>
-                This helper encapsulates the logic for ensuring fields exist in both the fact table
-                and its source, managing data type updates when measures require Decimal types,
-                and searching for existing fields by name or technical name.
-            </remarks>
-            <remarks>
-                Creates a new FieldFragmentHelper for managing field fragments.
-            </remarks>
-            <param name="builder">The model builder containing all fragments</param>
-            <param name="fact">The fact fragment to manage fields for</param>
-            <param name="factSource">The source fragment for the fact</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldFragmentHelper.FindFieldFragmentKey(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join">
             <summary>
-                Finds the field fragment key for a given column reference.
-                Searches fact fields first, then dimension fields.
-                Matches by technical name or name.
+                Represents a join definition in a Databricks Metric View
             </summary>
-            <param name="fieldRef">The column reference to find</param>
-            <returns>The field fragment key if found, otherwise null</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldFragmentHelper.EnsureFieldForMeasure(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference,TabularEditor.SemanticBridge.AbstractModel.AggregationType)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.ParentJoin">
             <summary>
-                Ensures a field exists for a measure, creating one if needed.
-                For aggregations that imply numeric values (SUM, AVG, MIN, MAX), updates
-                existing String fields to Decimal. COUNT aggregations don't imply a
-                particular field type, so the field's DataType is preserved.
+                Parent join if this is a nested join, null if this is a top-level join.
             </summary>
-            <param name="fieldRef">Column reference from the measure expression</param>
-            <param name="aggregationType">The aggregation type of the measure</param>
-            <returns>Field fragment key for the field</returns>
-            <remarks>
-                This method handles two scenarios:
-                <list type="number">
-                    <item>Field exists (e.g., created by a dimension): Updates DataType to Decimal</item>
-                    <item>Field doesn't exist: Creates new field with Decimal type</item>
-                </list>
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldFragmentHelper.UpdateFieldDataType(System.String,TabularEditor.SemanticBridge.AbstractModel.DataType)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Source">
             <summary>
-                Updates an existing field fragment and its corresponding source field
-                to the specified DataType, but only if the current type is String.
-                Non-String types (e.g., Integer keys) are preserved.
+                Source table or query for the join
             </summary>
-            <param name="fieldKey">Key of the field fragment to update</param>
-            <param name="dataType">New data type for the field</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.FieldFragmentHelper.CreateFieldForMeasure(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.On">
             <summary>
-                Creates new field fragments (fact and source) for a measure that
-                references a non-existent field.
-                Both Name and TechnicalName are set to the column name.
+                Optional SQL boolean expression for the join condition
             </summary>
-            <param name="fieldRef">Column reference from the measure expression</param>
-            <returns>Key of the created fact field fragment</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewTraverser">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Using">
             <summary>
-                Traverses a MetricView object graph and returns all nodes using the visitor pattern.
+                Optional list of column names to use for join
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewTraverser.Traverse(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Joins">
             <summary>
-                Returns all objects in the MetricView graph.
+                Child joins that are part of this join definition
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Cardinality">
             <summary>
-                Static wrapper/convenience class for use in C# scripts
+                Controls the relationship between the source and the joined table.
+                Per spec, <c>cardinality:</c> defaults to <c>many_to_one</c>: the
+                joined table acts as a dimension lookup. Set
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.OneToMany" /> to aggregate the joined
+                table as a separate fact source. Three states round-trip faithfully:
+                <c>null</c> (YAML omitted; spec-equivalent to <c>many_to_one</c>),
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.ManyToOne" /> (explicit), and
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.OneToMany" />. Requires YAML spec 1.1+.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Load(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Rely">
             <summary>
-                Loads a MetricView from a YAML file
+                Optimizer hints about the join's relationship to its source.
+                Currently the map only carries <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Rely.AtMostOneMatch" />;
+                the spec is shaped as an extensible map for future keys.
+                Conservatively gated to YAML spec 1.1+: <c>rely:</c> was not
+                part of the v0.1 spec, so emitting it on a v0.1 view would
+                produce YAML that pre-v1.1 tooling can't read. The current
+                spec's feature-availability table ties <c>rely.at_most_one_match</c>
+                to DBR 18.1 without restating a YAML version requirement; we
+                keep the YAML gate as a compatibility restriction.
             </summary>
-            <param name="path">full path to the yaml file on disk</param>
-            <returns>an unvalidated MetricView</returns>
-            <exception cref="T:System.IO.InvalidDataException">
-                thrown when the YAML is invalid, but doesn't check for internal
-                consistency of the model
-            </exception>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Deserialize(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Name">
             <summary>
-                Deserialize a MetricView from a YAML string
+                Name of the joined table
             </summary>
-            <param name="yaml">the YAML string to deserialize</param>
-            <returns>an unvalidated MetricView</returns>
-            <exception cref="T:System.IO.InvalidDataException">
-                thrown when the YAML is invalid, but doesn't check for internal
-                consistency of the model
-            </exception>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Save(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.AddJoin(System.String,System.String)">
             <summary>
-                Serialize the MetricView to YAML and save to disk
+                Adds a child join to this join definition
             </summary>
-            <param name="view">the MetricView to serialize</param>
-            <param name="path">the path to save the YAML file</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Serialize(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Rely">
             <summary>
-                Serialize a MetricView to a YAML string
+                Optimizer hints about a join's relationship to its source. Today this
+                carries only <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Rely.AtMostOneMatch" />; the Databricks spec models
+                <c>rely:</c> as an extensible map so additional keys may appear in
+                future spec revisions.
+                An explicitly-empty <c>rely: {}</c> in YAML deserializes to a non-null
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Rely" /> with all-null fields, distinct from an omitted
+                <c>rely:</c> (which leaves <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Rely" /> null). Both states
+                round-trip faithfully. Faithful round-trips are a goal of our Metric
+                View serialization and deserialization.
             </summary>
-            <param name="view">the MetricView to serialize</param>
-            <returns>the serialized YAML string</returns>
         </member>
-        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.DefaultValidationRules">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Rely.AtMostOneMatch">
             <summary>
-                The default validation rules to use when validating MetricViews.
-                Automatically used when calling `Validate(MetricView)` overload
+                When <c>true</c>, declares that the join has no fan-out on the
+                "one" side: on a many-to-one join, each source row matches at most
+                one row in the joined table; on a one-to-many join, each joined
+                row matches at most one source row. Databricks recommends setting
+                <c>rely</c> on both cardinalities when the constraint holds: it
+                lets the engine skip unnecessary joins and reduce data scanned,
+                especially for queries that filter on fields from the joined
+                table. Not validated at runtime; if the asserted side actually
+                fans out, measures return incorrect results.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality">
             <summary>
-                Validate a MetricView using the provided validator
+                The cardinality of a join's relationship between source and joined
+                table. Drives whether the joined table is treated as a dimension
+                lookup (<see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.ManyToOne" />) or as an independent fact source
+                that the engine aggregates separately (<see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.OneToMany" />).
+                Per the Databricks v1.1 spec, omitting the field defaults to
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.ManyToOne" />; <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.OneToMany" /> additionally
+                requires Databricks Runtime 18.1+.
             </summary>
-            <param name="view">the MetricView to validate</param>
-            <param name="validator">the validator to use</param>
-            <returns>enumerable of diagnostic messages resulting from the validation rules</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.ManyToOne">
             <summary>
-                Validate a MetricView using the default set of validation rules
+                Each source row matches at most one row in the joined table —
+                the joined table acts as a dimension lookup. Default per spec
+                when <c>cardinality:</c> is omitted.
             </summary>
-            <param name="view">MetricView to validate</param>
-            <returns>enumerable of diagnostic messages resulting from the validation rules</returns>
-            <remarks>The set of rules is available as `MetricViews.DefaultValidationRules`</remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality.OneToMany">
             <summary>
-                Validate a MetricView using the provided set of rules
+                The joined table can have multiple matching rows per source
+                row; the engine aggregates it independently at the source grain
+                as a separate fact source.
             </summary>
-            <param name="view">the MetricView to validate</param>
-            <param name="rules">the set of validation rules to apply</param>
-            <returns>enumerable of diagnostic messages resulting from the validation rules</returns>
-            <remarks>does not use any of the default rules unless you explicitly include these</remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidator">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Materialization">
             <summary>
-                Make a new MetricViewValidationVisitor with the default set of rules
+                Specifies materialization configuration for accelerating metric view queries.
+                This is an experimental feature.
             </summary>
-            <returns>a reusable MetricViewValidationVisitor to use as a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidator(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule},System.Boolean)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Materialization.Schedule">
             <summary>
-                Make a new MetricViewValidationVisitor with the provided set of
-                rules, optionally including the default rules
+                Refresh schedule (e.g., "every 6 hours")
             </summary>
-            <param name="rules">the set of validation rules to use in the validator</param>
-            <param name="includeDefaultRules">
-                whether to include the default rules (default: `true`)
-            </param>
-            <returns>a reusable MetricViewValidationVisitor to use as a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.Func{``0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}})">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Materialization.Mode">
             <summary>
-                Creates a validation rule for a specific type of MetricView object.
+                Materialization mode. Currently only "relaxed" is supported.
             </summary>
-            <typeparam name="T">
-                type of MetricView object the rule applies to. One of `MetricView`,
-                `MetricViewDimension`, `MetricViewJoin`, `MetricViewMeasure`
-            </typeparam>
-            <param name="name">name of the rule</param>
-            <param name="category">category for the rule (you can use any text)</param>
-            <param name="validate">validation function</param>
-            <returns>a validation rule for use in a validator</returns>
-            <remarks>
-                the validation function `validate` is a function of two arguments:
-                1. the metric view object to which the rule is applied
-                2. the validation context
-                validation context is a `IReadOnlyValidationContext` object which
-                provides:
-                - `PathStack`: identifies the exact object currently being
-                examined, with all of its parents (in reverse order from this
-                object to the root). In general you probably don't need to do
-                much with this.
-                - `JoinNames`: set of strings of all join names already seen
-                during validation
-                - `DimensionNames`: set of strings of all dimension names already
-                seen
-                - `MeasureNames`: set of strings of all measure names already seen
-                - `MakeError(message, property)`: function to create a diagnostic
-                error. **You should use this to create the errors you return**.
-                The first arg is a string describing the error. The second arg
-                is an optional property name (e.g. "Name") to append to the path.
-                **Only use the name of a MetricView object property**, not any
-                arbitrary string.
-                Your function must return an enumerable of DiagnosticMessage objects.
-                If there are no problems, return an empty enumerable (e.g. `[]`).
-                If the object is invalid according to the rule (your conditional
-                checks), then return an enumerable with one or more errors created
-                with the context's `MakeError` method. You can inspect any properties
-                of the object (the first arg to your function) or anything in the
-                context object.
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean})">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Materialization.MaterializedViews">
             <summary>
-                Create a validation rule for a specific MetricView object type
+                List of materialized view specifications
             </summary>
-            <typeparam name="T">
-                type of MetricView object the rule applies to. One of `MetricView`,
-                `MetricViewDimension`, `MetricViewJoin`, `MetricViewMeasure`
-            </typeparam>
-            <param name="name">name of the rule</param>
-            <param name="category">category for the rule (you can use any text)</param>
-            <param name="message">the message returned in the error if the object is invalid</param>
-            <param name="isInvalid">a predicate function to determine if the object is invalid</param>
-            <returns>a validation rule for use in a validator</returns>
-            <remarks>
-                the function `isInvalid` is a simple predicate function that can
-                only inspect the properties of the current MetricView object. If you
-                need to inspect other context, you should use the other overload of
-                `MakeValidationRule`
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean})">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializedViewSpec">
             <summary>
-                Create a validation rule for the root MetricView object
+                Specifies a single materialized view within the materialization configuration.
             </summary>
-            <param name="name">name of the rule</param>
-            <param name="category">category for the rule (you can use any text)</param>
-            <param name="message">the message returned in the error if the object is invalid</param>
-            <param name="isInvalid">a predicate function to determine if the object is invalid</param>
-            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean})">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializedViewSpec.Name">
             <summary>
-                Create a validation rule for MetricViewJoin objects
+                Name of the materialization
             </summary>
-            <param name="name">name of the rule</param>
-            <param name="category">category for the rule (you can use any text)</param>
-            <param name="message">
-                the message returned in the error if the MetricViewJoin is invalid
-            </param>
-            <param name="isInvalid">
-                a predicate function to determine if the MetricViewJoin is invalid
-            </param>
-            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForDimension(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension,System.Boolean})">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializedViewSpec.Type">
             <summary>
-                Create a validation rule for MetricViewDimension objects
+                Type of materialization: aggregated or unaggregated
             </summary>
-            <param name="name">name of the rule</param>
-            <param name="category">category for the rule (you can use any text)</param>
-            <param name="message">
-                the message returned in the error if the MetricViewDimension is invalid
-            </param>
-            <param name="isInvalid">
-                a predicate function to determine if the MetricViewDimension is invalid
-            </param>
-            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean})">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializedViewSpec.Dimensions">
             <summary>
-                Create a validation rule for MetricViewMeasure objects
+                List of dimension names to materialize (for aggregated type)
             </summary>
-            <param name="name">name of the rule</param>
-            <param name="category">category for the rule (you can use any text)</param>
-            <param name="message">
-                the message returned in the error if the MetricViewMeasure is invalid
-            </param>
-            <param name="isInvalid">
-                a predicate function to determine if the MetricViewMeasure is invalid
-            </param>
-            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.ToTabularModel(TabularEditor.TOMWrapper.Model,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.String,System.String,System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}@,System.Boolean)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializedViewSpec.Measures">
             <summary>
-                Converts a Databricks MetricView to a Tabular Model.
+                List of measure names to materialize (for aggregated type)
             </summary>
-            <param name="model">
-                The target TOM model to populate with tables, columns, measures,
-                and relationships
-            </param>
-            <param name="view">The source MetricView to convert</param>
-            <param name="databricksHostName">Databricks host name for connection</param>
-            <param name="databricksHttpPath">Databricks HTTP path for connection</param>
-            <param name="diagnostics">
-                A list of diagnostic messages indicating details of partial or full
-                failues. May be populated even when the method returns true and
-                does create a TOM model.
-            </param>
-            <param name="failOnValidationErrors">
-                if true, abort on validation errors before creating any TOM objects
-            </param>
-            <remarks>
-            </remarks>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializationMode">
             <summary>
-                Represents a dimension definition in a Databricks Metric View
+                Materialization mode. Currently only "relaxed" is supported by Databricks.
             </summary>
-            <remarks>
-                A dimension in a Metric View is a single field. There is no namespacing
-                or delineation of separate named collections of fields.
-            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension.Name">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MaterializedViewType">
             <summary>
-                The YAML name for the dimension field
+                Type of materialized view specification.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension.Expr">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure">
             <summary>
-                The YAML string representing the expression for this dimension,
-                either a field reference or scalar SQL expression.
+                Represents a measure definition in a Databricks Metric View
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Name">
             <summary>
-                Lightweight value representation of a single column reference within a
-                Metric View expression.  The parser populates <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.Table" /> only
-                when a single (non‑backticked) dot qualification is present (or when a
-                backticked token acts as table side). For undotted identifiers (or
-                identifiers whose dot is inside backticks) <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.Table" /> is the
-                empty string. Formatting policy is intentionally minimal: only quote
-                when required.
+                The name of the measure, referenced in Metric View expressions as
+                MEASURE(name)
             </summary>
-            <param name="Table">
-                Optional table/alias portion (empty string if not present or not applicable).
-            </param>
-            <param name="Column">
-                The logical column identifier (never null; empty only for a
-                default-initialized value).
-            </param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.#ctor(System.String,System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Expr">
             <summary>
-                Lightweight value representation of a single column reference within a
-                Metric View expression.  The parser populates <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.Table" /> only
-                when a single (non‑backticked) dot qualification is present (or when a
-                backticked token acts as table side). For undotted identifiers (or
-                identifiers whose dot is inside backticks) <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.Table" /> is the
-                empty string. Formatting policy is intentionally minimal: only quote
-                when required.
+                Aggregate SQL expression that defines the measure
             </summary>
-            <param name="Table">
-                Optional table/alias portion (empty string if not present or not applicable).
-            </param>
-            <param name="Column">
-                The logical column identifier (never null; empty only for a
-                default-initialized value).
-            </param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.Table">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Comment">
             <summary>
-                Optional table/alias portion (empty string if not present or not applicable).
+                Description of the measure. Requires version 1.1+.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.Column">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.DisplayName">
             <summary>
-                The logical column identifier (never null; empty only for a
-                default-initialized value).
+                Human-readable display name. Requires version 1.1+.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference.ToSql">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Synonyms">
             <summary>
-                Render the reference using minimal quoting rules consistent with
-                the parser. Rules per side (table / column):
-                - If empty -> omitted (for table) or empty string for column.
-                - Any token containing a dot is always backticked (avoids
-                ambiguity and preserves original backticked literals like
-                `orders.amount`).
-                - Bare identifier pattern [A-Za-z_][A-Za-z0-9_]* AND not a
-                reserved word -> emitted bare.
-                - Otherwise wrapped in backticks (parser strips existing backticks
-                so internal backticks not expected).
+                Alternative names for AI/search. Requires version 1.1+.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Format">
             <summary>
-                Lightweight, heuristic parser for extracting column identifiers from
-                Databricks Metric View expressions. Focused only on documented patterns
-                (bare identifiers and backtick-delimited identifiers) and deliberately
-                avoids full SQL parsing. Silent on malformed input, returning what can
-                be confidently identified.
+                Display format specification. Requires version 1.1+.
             </summary>
         </member>
-        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.ReservedWords">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Window">
             <summary>
-                Databricks reserved keywords that must be backtick-quoted to be
-                part of an identifier.
+                Window specifications for windowed, cumulative, or semiadditive aggregations.
+                Requires version 1.1+. This is an experimental feature.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.TryGetSingleColumn(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference@)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1">
             <summary>
-                Attempt to determine if an expression is exactly a single column
-                reference.  Returns a structured <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference" />
-                (table + column). Supports:
-                * Bare identifier (non-reserved)
-                * Backticked identifier (any content except stray backticks)
-                * Single dotted qualification outside backticks (table.column)
-                with rules:
-                - At most one dot outside backticks (multi-dot => throw
-                <see cref="T:System.ArgumentException" />)
-                - No whitespace adjacent to the dot (spaced forms return false)
-                - BOTH sides must be bare (non-reserved) or individually
-                backticked. A bare reserved keyword is rejected on EITHER side;
-                backticks required to treat it literally.
-                * Entire expression backticked is treated as undotted column even
-                if inner text contains dots
-                All other forms return false (silent failure posture) except
-                multi-dot which throws.
+                A collection of MetricView objects with name-based indexing.
+                Implements IReadOnlyList for compatibility while providing O(1) name lookups.
             </summary>
+            <typeparam name="T">The type of MetricView object in the collection</typeparam>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.IsSingleColumnReference(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.#ctor">
             <summary>
-                Convenience wrapper over <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.TryGetSingleColumn(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference@)" />.
+                Creates a new collection for a named object type
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.ExtractColumnReferences(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Item(System.Int32)">
             <summary>
-                Extract distinct structured column references (first-seen order,
-                case-insensitive distinctness via linear scan). Dotted
-                (table.column) pairs are produced only when syntactically valid with
-                a single dot outside backticks and no whitespace adjacency.
-                Multi-dot contiguous sequences (a.b.c or variants mixing
-                backticked segments) throw <see cref="T:System.ArgumentException" />.
-                Spaced-dot patterns yield separate undotted identifiers. Backticked
-                whole tokens with internal dots may still act as table side when
-                followed immediately by ".identifier" (e.g.
-                `orders.amount`.field -> table:"orders.amount", column:"field"). If
-                a backticked left side is followed by a bare reserved right side
-                (e.g. `orders`.CASE) both sides are skipped (zero references) to
-                avoid surfacing an unusable partial reference. Bare left reserved
-                (CASE.amount) is ignored and the right side is surfaced undotted.
-                Bare reserved right (orders.CASE) causes only the left side to be
-                surfaced undotted. Backticked right sides always pass regardless of
-                reserved status.  Function heads (identifier immediately followed
-                by '(') are excluded.
+                Gets the item at the specified index.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.ExtractColumnReferencesWithSpans(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Item(System.String)">
             <summary>
-                Extract distinct structured column references with their source positions
-                (first-seen order, case-insensitive distinctness via linear scan).
-                Returns position information for each reference, enabling delimiter-aware parsing.
+                Gets the item with the specified name.
             </summary>
-            <remarks>
-                Position spans include the entire reference from start to end, including:
-                - Backticks (if present)
-                - Table qualification and dot (if present)
-                - Column name
-                Follows the same parsing rules as <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.ExtractColumnReferences(System.String)" />.
-            </remarks>
+            <exception cref="T:System.Collections.Generic.KeyNotFoundException">If no item with the specified name exists</exception>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.TryParseIdentifierSide(System.ReadOnlySpan{System.Char},System.String@)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Count">
             <summary>
-                Parse one side of a potential dotted identifier (used only by
-                single-column detection).  Bare reserved words are rejected on
-                BOTH sides; backticks required to treat them literally.
+                Gets the number of items in the collection.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceParser.RemoveComments(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.GetEnumerator">
             <summary>
-                Remove all block (`/* ... */`) and line (`-- ...\n`) comments from
-                expr. Handles nested comments and normalizes line endings to `\n`.
+                Returns an enumerator that iterates through the collection.
             </summary>
-            <param name="expr">Databricks SQL expression</param>
-            <returns>
-                A string with all comments removed, with '\n' line endings, and all
-                leading and trailing whitespace removed (this leading and trailing
-                space is trimmed after comment removal). Leading whitespace on an
-                individual line is not removed.
-            </returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.System#Collections#IEnumerable#GetEnumerator">
             <summary>
-                Represents the position and length of a column reference in source text.
-                Used for delimiter-aware parsing and error reporting.
+                Returns an enumerator that iterates through the collection.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan.Start">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Find(System.String)">
             <summary>
-                Zero-based index where the column reference starts in the source string.
+                Finds an item by name, returning null if not found.
             </summary>
+            <param name="name">The name to search for</param>
+            <returns>The item with the specified name, or null if not found</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan.Length">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Contains(System.String)">
             <summary>
-                Length of the column reference in characters, including any backticks or qualifiers.
+                Determines whether an item with the specified name exists in the collection.
             </summary>
+            <param name="name">The name to search for</param>
+            <returns>True if an item with the specified name exists</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan.End">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.ThrowIfNameTaken(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase)">
             <summary>
-                Zero-based index of the character after the last character of the reference.
+            	A name is admitted when it is free or already the claimant's own (case-only rename).
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan.Contains(System.Int32)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Add(`0)">
+            <summary> Adds an item to the collection and takes ownership of it. </summary>
+            <param name="item">The item to add</param>
+            <exception cref="T:System.ArgumentException">If an item with the same name already exists</exception>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Remove(`0)">
             <summary>
-                Checks if a given position falls within this span.
+                Removes an item from the collection and relinquishes ownership.
+                Reference-based: the item is removed only when the name index maps
+                its current Name to this exact instance, so a stale index entry can
+                never silently remove the wrong item -- or nothing -- on behalf of a
+                renamed one.
             </summary>
-            <param name="position">Zero-based character position to check</param>
-            <returns>True if position is within [Start, End), false otherwise</returns>
+            <param name="item">The item to remove</param>
+            <returns>True if the item was removed, false if not found</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan.#ctor(System.Int32,System.Int32)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase">
             <summary>
-                Creates a new span with the given start position and length.
+                Abstract base class for the named child objects of a View (joins,
+                fields, measures). The root <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.View" /> is not a child and
+                stands outside this hierarchy; the surface shared with it is
+                expressed through <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject" />.
             </summary>
-            <param name="start">Zero-based start position</param>
-            <param name="length">Length in characters</param>
-            <exception cref="T:System.ArgumentOutOfRangeException">
-                Thrown when start or length is negative
-            </exception>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.View">
             <summary>
-                A column reference with associated source position information.
-                Used when you need both the parsed reference and its location in source text.
+                Reference to the root View object this child belongs to.
+                Constructor-established: never null, immutable for the object's
+                lifetime. Deleted objects keep it, so Path and property reads stay
+                valid on zombies.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.Reference">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
             <summary>
-                The parsed column reference (table name and column name).
+                Child objects are created with their owning View. private protected
+                with no parameterless overload also removes the possibility of a
+                compiler-synthesized public constructor on a subclass: an author
+                adding a new child type must write an explicit constructor that
+                passes the View, instead of silently shipping a public default one.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.Span">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.Name">
             <summary>
-                The position and length of this reference in the source text.
+                The name of this object, used for name-based indexing in the owning
+                collection. Declared abstract so each concrete class carries its own
+                type-specific documentation on the override.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.TableName">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.EscapeName(System.String)">
             <summary>
-                The table name (may be empty for unqualified references).
+                Escape backslashes and quotes for building paths that are valid C#.
             </summary>
+            <param name="name">name of some metric view object</param>
+            <returns>
+                A string that will be valid in a lookup in a C# snippet such as:
+                `Model.Fields["a \"dangerous\" name"]`
+            </returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.ColumnName">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.IsDeleted">
             <summary>
-                The column name.
+                Indicates whether this object has been deleted from its parent collection.
+                Deleted objects become "zombies" - they retain their data but are detached from the model.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.IsQualified">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.Owner">
             <summary>
-                Whether this is a qualified reference (table.column).
+                The collection that currently owns this object. Wired by
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1.Add(`0)" /> and cleared on removal;
+                null while the object is unattached or deleted, in which case there
+                is no collection to coordinate lifecycle operations with.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.Start">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.RenameGuard(System.String,System.String)">
             <summary>
-                Zero-based start position in source text.
+                Rename coordination for Name setters
+                (<c>set => field = RenameGuard(field, value);</c>): no-op when the
+                name is unchanged or the object has never been named; otherwise the
+                owning collection validates and re-keys BEFORE the backing field
+                mutates, so a rejected rename (duplicate name) leaves the object
+                and the index untouched. Unowned objects -- never attached, or
+                deleted -- just take the new name. A null oldName is the first
+                assignment, which happens during every object initialization:
+                required members assign after the constructor completes and before
+                Add attaches an owner, so there is never anything indexed to
+                re-key. Uniqueness is the only content rule, exactly what Add
+                enforces; blank names are permitted here as they are there.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.Length">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.Delete">
             <summary>
-                Length in characters.
+                Deletes this object from its owning collection. Idempotent: calls
+                after the first are no-ops. The deleted object becomes a zombie --
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.IsDeleted" /> is true, it no longer serializes, and its
+                properties (including <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.View" /> and <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.Path" />)
+                remain readable.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.End">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.AcceptInternal``1(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor{``0})">
             <summary>
-                Zero-based end position (exclusive).
+                Visitor dispatch bridge. Each concrete subclass overrides this with
+                <c>visitor.Visit(this)</c>: overload resolution against the concrete
+                static type of <c>this</c> is what selects the correct typed Visit
+                overload.
             </summary>
+            <remarks>
+                This member exists because the usual double-dispatch spelling is not
+                available here: the model classes are public while the visitor
+                interfaces are internal, so a public abstract Accept cannot compile
+                (inconsistent accessibility), and explicit interface implementations
+                cannot be abstract. Do not "simplify" this into a concrete
+                implementation on this base class: there, <c>this</c> is statically
+                typed as the base, overload resolution can only select
+                Visit(IMetricViewVisitable), and that overload's implementation calls
+                Accept again -- infinite mutual recursion.
+            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.ValidateVersion``1(``0,System.String)">
             <summary>
-                Creates a new reference with position information.
+                Version gate for v1.1+ property setters
+                (<c>set => field = ValidateVersion(value);</c>): validates against
+                the owning View's version only when a non-null value is being set,
+                then returns the value unchanged.
             </summary>
-            <param name="reference">The parsed column reference</param>
-            <param name="span">The position span in source text</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference,System.Int32,System.Int32)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion">
             <summary>
-                Creates a new reference with position information.
+                Provides version comparison utilities for Databricks Metric View specifications.
+                Unknown versions are treated as greater than all known versions (forward compatible).
             </summary>
-            <param name="reference">The parsed column reference</param>
-            <param name="start">Zero-based start position</param>
-            <param name="length">Length in characters</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.Contains(System.Int32)">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.KnownVersions">
             <summary>
-                Checks if a given position falls within this reference's span.
+                Known metric view specification versions in order
             </summary>
-            <param name="position">Zero-based character position</param>
-            <returns>True if position is within this span, false otherwise</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceWithSpan.ToSql">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.V01">
             <summary>
-                Converts to SQL syntax (ignores position information).
+                Version 0.1 - Initial release (Databricks Runtime 16.4 through 17.1)
             </summary>
-            <returns>SQL representation of the column reference</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.V11">
             <summary>
-                Represents the semantic analysis of a Databricks Metric View dimension.
-                Contains information about whether the dimension is a simple field reference
-                or a derived expression, along with field references and target table determination.
+                Version 1.1 - Adds semantic metadata, comments (Databricks Runtime 17.2+)
             </summary>
-            <remarks>
-                <para>
-                    This is a discriminated union represented through inheritance.
-                    Use pattern matching to determine whether the dimension is simple or derived,
-                    then access the appropriate properties.
-                </para>
-                <para>
-                    A simple dimension is one that directly references a single column from
-                    the source or a joined table. A derived dimension contains a complex
-                    expression that must be represented as a calculated column in the target.
-                </para>
-            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Name">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.Default">
             <summary>
-                The name of the dimension as it appears in the Metric View.
+                Default version when not specified in YAML (Databricks defaults to 1.1)
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Expression">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.Compare(System.String,System.String)">
             <summary>
-                The complete expression string from the dimension.
+                Compares two version strings.
+                Unknown versions sort greater than all known versions.
             </summary>
+            <returns>
+                Negative if left &lt; right, zero if equal, positive if left &gt; right
+            </returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Simple">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.IsAtLeast(System.String,System.String)">
             <summary>
-                Analysis result for a simple dimension that directly references a column.
+                Returns true if the version is at least the specified minimum version.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Simple.Field">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.IsGreaterThan(System.String,System.String)">
             <summary>
-                The single field reference that this dimension maps to.
+                Returns true if <paramref name="version" /> is strictly greater than
+                <paramref name="other" />, using full version-number comparison.
+                Patch-level strings (<c>"1.1.1"</c>) ARE greater than their parent
+                minor version (<c>"1.1"</c>) — any version bump from Databricks
+                means a spec change we should respect. Unparseable strings on
+                either side fall back to the array-index ordering used by
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.IsAtLeast(System.String,System.String)" />.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Derived">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.IsKnown(System.String)">
             <summary>
-                Analysis result for a derived dimension with a complex expression
-                that must be represented as a calculated column.
+                Returns true if the version string is a known version.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Derived.ReferencedFields">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewVersion.GetVersionIndex(System.String)">
             <summary>
-                All column references found in the dimension expression.
+                Gets the index of a version in the known versions array.
+                Unknown versions return int.MaxValue (sort after all known).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionAnalysis.Derived.Target">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionAttribute">
             <summary>
-                The target table for the derived field.
-                This is determined by the source of the referenced fields:
-                - If all fields are from a single dimension, the derived field goes on that dimension
-                - If fields are from multiple tables or the source, the derived field goes on the fact
+                Specifies the minimum metric view version required for a property.
+                Used for setter validation when setting v1.1+ properties on older versions.
             </summary>
+            <remarks>
+                Creates a new MinVersion attribute with the specified minimum version.
+            </remarks>
+            <param name="version">The minimum version required (e.g., "1.1")</param>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DerivedFieldTarget">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionAttribute.#ctor(System.String)">
             <summary>
-                Represents the target table for a derived field.
+                Specifies the minimum metric view version required for a property.
+                Used for setter validation when setting v1.1+ properties on older versions.
             </summary>
+            <remarks>
+                Creates a new MinVersion attribute with the specified minimum version.
+            </remarks>
+            <param name="version">The minimum version required (e.g., "1.1")</param>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DerivedFieldTarget.Fact">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionAttribute.Version">
             <summary>
-                The derived field should be placed on the fact table.
+                The minimum version required for this property.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DerivedFieldTarget.Dimension">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionCache">
             <summary>
-                The derived field should be placed on a specific dimension table.
+                Provides cached lookups for MinVersion attributes on properties.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DerivedFieldTarget.Dimension.DimensionName">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionCache.GetMinVersion(System.Type,System.String)">
             <summary>
-                The name of the dimension (join alias) where the derived field belongs.
+                Gets the minimum version required for a property, or null if no minimum.
             </summary>
+            <param name="type">The type containing the property</param>
+            <param name="propertyName">The name of the property</param>
+            <returns>The minimum version string, or null if no MinVersion attribute</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionExtensions">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionCache.ValidateVersion``1(System.Type,System.String,``0,System.String)">
             <summary>
-                Extension methods for analyzing and converting Databricks Metric View dimensions.
+                Guard-returning version gate for property setters
+                (<c>set => field = ValidateVersion(value);</c>): when a non-null
+                value is being set on a [MinVersion]-gated property, throws unless
+                the model version meets the property's minimum; otherwise hands the
+                value back unchanged.
             </summary>
+            <exception cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Exceptions.MetricViewVersionException">
+                Thrown if the property requires a higher version than current
+            </exception>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionExtensions.Analyze(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlDeserializer">
             <summary>
-                Analyzes a dimension expression to determine if it's a simple field reference
-                or a complex derived expression, and identifies the target table.
+                Handles deserialization of Databricks Metric Views from YAML
             </summary>
-            <param name="dimension">The Metric View dimension to analyze</param>
-            <returns>
-                A DimensionAnalysis indicating whether the dimension is simple or derived,
-                with appropriate field references and target table information.
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.DimensionExtensions.DetermineTarget(System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReference})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlDeserializer.Deserialize(System.String)">
             <summary>
-                Determines the target table for a derived field based on the tables
-                referenced by its constituent fields.
+                Deserializes a YAML string into a MetricView object
             </summary>
-            <param name="fields">The column references from the expression</param>
+            <param name="yaml">The YAML string to deserialize</param>
+            <returns>A MetricView object</returns>
+            <exception cref="T:YamlDotNet.Core.YamlException">If YAML is invalid or cannot be deserialized</exception>
             <returns>
-                A DerivedFieldTarget indicating whether the field should go on the fact
-                or a specific dimension table.
+                A TransformationResult, either:
+                - success containing the view and any non-failure-inducing
+                diagnostic messages
+                - failure containing a list of errors that caused deserialization
+                or validation to fail. There is no view available in this case.
             </returns>
-            <remarks>
-                Target determination rules:
-                <list type="bullet">
-                    <item>All fields from source/empty table -> Fact</item>
-                    <item>All fields from a single dimension -> that Dimension</item>
-                    <item>Fields from multiple dimensions -> Fact</item>
-                    <item>Mix of source and dimension fields -> Fact</item>
-                </list>
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.JoinExtensions.ParseFields(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlDeserializer.MapToDomain(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.DTO.ViewDto)">
             <summary>
-                Parses join fields from MetricViewJoin. Handles 'Using' and 'On'.
-                Returns (factFieldKey, dimensionFieldKey) tuple or null if parsing fails.
+                Maps a DTO to the domain model, wiring up parent pointers
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.JoinExtensions.ExtractJoinOn(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlDeserializer.ReportIfDuplicate``1(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection{``0},System.String,System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})">
             <summary>
-                Extracts LHS and RHS from an equality join expression
+                Reports a duplicate-name diagnostic when the collection already
+                holds an item under the name. Returns true when it does, in which
+                case the caller must skip the duplicate entry.
             </summary>
-            <param name="joinExpr"></param>
-            <returns></returns>
-            <remarks>
-                We do not handle inequality joins or fields with spaces in their names.
-                We expect fully qualified names on both sides.
-                See: https://docs.databricks.com/aws/en/metric-views/yaml-ref#joins
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.JoinExtensions.GetSourceFragment(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,TabularEditor.SemanticBridge.AbstractModel.Builder.SourceSystemFragment)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlSerializer">
             <summary>
-                Creates a SourceFragment for a join's dimension source
+                Handles serialization of Databricks Metric Views to YAML
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.JoinExtensions.Regexes.JoinOnRegex">
-            <remarks>
-            Pattern:<br/>
-            <code>^\\s*(?&lt;table1&gt;\\w+)\\.(?&lt;field1&gt;\\w+)\\s*=\\s*(?&lt;table2&gt;\\w+)\\.(?&lt;field2&gt;\\w+)\\s*$</code><br/>
-            Explanation:<br/>
-            <code>
-            ○ Match if at the beginning of the string.<br/>
-            ○ Match a whitespace character atomically any number of times.<br/>
-            ○ "table1" capture group.<br/>
-                ○ Match a word character atomically at least once.<br/>
-            ○ Match '.'.<br/>
-            ○ "field1" capture group.<br/>
-                ○ Match a word character atomically at least once.<br/>
-            ○ Match a whitespace character atomically any number of times.<br/>
-            ○ Match '='.<br/>
-            ○ Match a whitespace character atomically any number of times.<br/>
-            ○ "table2" capture group.<br/>
-                ○ Match a word character atomically at least once.<br/>
-            ○ Match '.'.<br/>
-            ○ "field2" capture group.<br/>
-                ○ Match a word character atomically at least once.<br/>
-            ○ Match a whitespace character greedily any number of times.<br/>
-            ○ Match if at the end of the string or if before an ending newline.<br/>
-            </code>
-            </remarks>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlSerializer.Serialize(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+            <summary>
+                Serializes a MetricView object to a YAML string
+            </summary>
+            <param name="metricView">The MetricView object to serialize</param>
+            <returns>A YAML string representation</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlSerializer.SerializeWindow(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window})">
             <summary>
-                Represents the semantic analysis of a Databricks Metric View measure.
-                Contains information about the measure's type, aggregation function,
-                and field references extracted from the expression.
+                Serializes a measure's window specification(s) to a YAML fragment
+                using the same naming convention and DTO mapping as a full view, so
+                the output matches the <c>window:</c> block as authored in the
+                source metric view. Used to embed the spec verbatim in a fallback
+                comment when window measures are encountered (see #6347).
             </summary>
-            <remarks>
-                <para>
-                    This is a discriminated union represented through inheritance.
-                    Use pattern matching or type checks to determine whether the measure
-                    is simple or calculated, then access the appropriate properties.
-                </para>
-                <para>
-                    A simple measure is one that can be translated to a basic aggregation in the
-                    target platform. It must:
-                </para>
-                <list type="bullet">
-                    <item>Use a supported aggregation function (SUM, COUNT, MIN, MAX, AVG, COUNT DISTINCT)</item>
-                    <item>Reference exactly one field</item>
-                    <item>Have no complex expressions (arithmetic, nested functions, etc.)</item>
-                </list>
-                <para>
-                    Calculated measures contain more complex expressions that cannot be automatically
-                    translated and must be handled platform-specifically.
-                </para>
-            </remarks>
+            <param name="windows">The window specifications to serialize.</param>
+            <returns>A YAML string representation of the window list.</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Name">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlSerializer.MapToDto(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.SerializationOptions)">
             <summary>
-                The name of the measure as it appears in the Metric View.
+                Maps the domain model to a DTO for serialization
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Expression">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.SerializationOptions.DefaultFor(System.String)">
             <summary>
-                The complete expression string from the measure.
+                Version-aware default keyword choice for a view with no explicit
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.SerializationOptions" />. Conservative: v1.1 and earlier
+                emit <c>dimensions:</c>; anything strictly greater than v1.1 emits
+                <c>fields:</c>. The <c>fields:</c> alias was introduced after the
+                v1.1 spec was published, so defaulting v1.1 to <c>dimensions:</c>
+                stays compatible with tooling that targets the original v1.1
+                spec.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Simple">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View">
             <summary>
-                Analysis result for a simple measure that can be directly translated
-                to a platform-specific aggregation.
+                Represents a Databricks Metric View definition. The root of the
+                metric view object graph: unlike the child objects (joins, fields,
+                measures) it does not derive from <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase" />
+                -- it has no name in the Metric View spec (the view's name lives in
+                Unity Catalog, outside the YAML) and cannot be deleted from anything.
+                The surface shared with child objects is expressed through
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Simple.AggregationType">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.TabularEditor#SemanticBridge#Platforms#Databricks#Interfaces#IMetricViewObject#View">
             <summary>
-                The aggregation type (SUM, COUNT, MIN, MAX, AVG, DISTINCT COUNT).
+                The root of the graph is itself: the fixed point of
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject.View" />. Implemented explicitly
+                because C# forbids a declared member named like its enclosing type
+                (CS0542); root self-reference is only meaningful through
+                interface-typed references anyway.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Simple.Field">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.ValidateVersion``1(``0,System.String)">
             <summary>
-                The single field reference that this measure aggregates.
+                Version gate for this View's own v1.1+ property setters. The
+                child-object equivalent lives on <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase" />
+                and reads <c>View.Version</c>; both are thin shims over
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MinVersionCache" />.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Calculated">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Version">
             <summary>
-                Analysis result for a calculated measure with a complex expression
-                that cannot be automatically translated.
+                Version of the metric view specification
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Calculated.ReferencedFields">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Source">
             <summary>
-                All column references found in the measure expression.
-                May contain zero or more references depending on the expression.
+                The source data for the metric view, playing the role of a single fact
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.Analyze(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Filter">
             <summary>
-                Analyzes a Databricks Metric View measure to determine its semantic properties.
+                Optional SQL boolean expression that applies to all queries; a WHERE
             </summary>
-            <param name="measure">The measure to analyze</param>
-            <returns>
-                A <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis" /> - either <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Simple" />
-                or <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureAnalysis.Calculated" />. Use pattern matching or type checks
-                to determine which and access the appropriate properties.
-            </returns>
-            <remarks>
-                <para>
-                    A simple measure is one that can be translated to a basic aggregation in the
-                    target platform. It must:
-                </para>
-                <list type="bullet">
-                    <item>Use a supported aggregation function (SUM, COUNT, MIN, MAX, AVG, COUNT DISTINCT)</item>
-                    <item>Reference exactly one field</item>
-                    <item>Have no complex expressions (arithmetic, nested functions, etc.)</item>
-                </list>
-                <para>
-                    Calculated measures contain more complex expressions that cannot be automatically
-                    translated and must be handled platform-specifically.
-                </para>
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.ParseAggregationType(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Comment">
             <summary>
-                Parses an aggregation function name from a measure expression and
-                maps it to AggregationType.
-                Supports: SUM, COUNT, MIN, MAX, AVG/AVERAGE, COUNT(DISTINCT ...)
+                Description of the metric view. Requires version 1.1+.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.IsSimpleAggregation(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Materialization">
             <summary>
-                Determines if a measure expression is a simple aggregation over a
-                single field. A simple aggregation has the pattern:
-                AGG_FUNCTION(field_reference) or COUNT(DISTINCT field_reference)
+                Materialization configuration for query acceleration. Requires version 1.1+.
+                This is an experimental feature.
             </summary>
-            <remarks>
-                <para>
-                    Uses a two-step validation approach:
-                    1. Extract all column references from the expression using robust ColumnReferenceParser
-                    2. Validate that expression structure is exactly FUNCTION(column) with no extra content
-                </para>
-                <para>
-                    This approach handles all edge cases while preserving original quoting/formatting:
-                </para>
-                <list type="bullet">
-                    <item>Backticked identifiers with any content (including parentheses)</item>
-                    <item>Reserved word validation</item>
-                    <item>Qualified references (table.column)</item>
-                    <item>Superfluous quoting (validates structure, not exact string match)</item>
-                    <item>DISTINCT COUNT patterns</item>
-                </list>
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.SqlAggRegex">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Joins">
+            <summary>
+                Optional join definitions for the metric view
+            </summary>
             <remarks>
-            Pattern:<br/>
-            <code>^(SUM|COUNT|MIN|MAX|AVG|AVERAGE)\\s*\\(</code><br/>
-            Options:<br/>
-            <code>RegexOptions.IgnoreCase</code><br/>
-            Explanation:<br/>
-            <code>
-            ○ Match if at the beginning of the string.<br/>
-            ○ 1st capture group.<br/>
-                ○ Match with 4 alternative expressions.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [Ss].<br/>
-                        ○ Match a character in the set [Uu].<br/>
-                        ○ Match a character in the set [Mm].<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [Cc].<br/>
-                        ○ Match a character in the set [Oo].<br/>
-                        ○ Match a character in the set [Uu].<br/>
-                        ○ Match a character in the set [Nn].<br/>
-                        ○ Match a character in the set [Tt].<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [Mm].<br/>
-                        ○ Match with 2 alternative expressions.<br/>
-                            ○ Match a sequence of expressions.<br/>
-                                ○ Match a character in the set [Ii\u0130].<br/>
-                                ○ Match a character in the set [Nn].<br/>
-                            ○ Match a sequence of expressions.<br/>
-                                ○ Match a character in the set [Aa].<br/>
-                                ○ Match a character in the set [Xx].<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [Aa].<br/>
-                        ○ Match a character in the set [Vv].<br/>
-                        ○ Match with 2 alternative expressions.<br/>
-                            ○ Match a character in the set [Gg].<br/>
-                            ○ Match a sequence of expressions.<br/>
-                                ○ Match a character in the set [Ee].<br/>
-                                ○ Match a character in the set [Rr].<br/>
-                                ○ Match a character in the set [Aa].<br/>
-                                ○ Match a character in the set [Gg].<br/>
-                                ○ Match a character in the set [Ee].<br/>
-            ○ Match a whitespace character atomically any number of times.<br/>
-            ○ Match '('.<br/>
-            </code>
+                A join is also the place where dimension sources are defined; this
+                information exists nowhere else.
             </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.DistinctCountRegex">
-            <remarks>
-            Pattern:<br/>
-            <code>^COUNT\\s*\\(\\s*DISTINCT\\s+</code><br/>
-            Options:<br/>
-            <code>RegexOptions.IgnoreCase</code><br/>
-            Explanation:<br/>
-            <code>
-            ○ Match if at the beginning of the string.<br/>
-            ○ Match a character in the set [Cc].<br/>
-            ○ Match a character in the set [Oo].<br/>
-            ○ Match a character in the set [Uu].<br/>
-            ○ Match a character in the set [Nn].<br/>
-            ○ Match a character in the set [Tt].<br/>
-            ○ Match a whitespace character atomically any number of times.<br/>
-            ○ Match '('.<br/>
-            ○ Match a whitespace character atomically any number of times.<br/>
-            ○ Match a character in the set [Dd].<br/>
-            ○ Match a character in the set [Ii\u0130].<br/>
-            ○ Match a character in the set [Ss].<br/>
-            ○ Match a character in the set [Tt].<br/>
-            ○ Match a character in the set [Ii\u0130].<br/>
-            ○ Match a character in the set [Nn].<br/>
-            ○ Match a character in the set [Cc].<br/>
-            ○ Match a character in the set [Tt].<br/>
-            ○ Match a whitespace character atomically at least once.<br/>
-            </code>
-            </remarks>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields">
+            <summary>
+                Array of field definitions
+            </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.GetContentStartPosition(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Measures">
             <summary>
-                Identifies the aggregation pattern and returns where content starts.
+                Array of measure definitions
             </summary>
-            <param name="expression">The expression to analyze</param>
-            <returns>The position where content starts after the aggregation pattern, or null if no pattern found</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.IsValidClosingPosition(System.String,System.Int32)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField(System.String,System.String)">
             <summary>
-                Validates that the closing paren is at the end of the expression.
-                Only whitespace is allowed after the closing paren.
+                Adds a new field to the metric view
             </summary>
-            <param name="expression">The expression to validate</param>
-            <param name="closeParenIndex">The index of the closing parenthesis</param>
-            <returns>True if closing paren is properly positioned, false otherwise</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.ExtractContent(System.String,System.Int32,System.Int32)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddMeasure(System.String,System.String)">
             <summary>
-                Extracts and trims content between two positions.
+                Adds a new measure to the metric view
             </summary>
-            <param name="expression">The expression containing the content</param>
-            <param name="start">Start position (inclusive)</param>
-            <param name="end">End position (exclusive)</param>
-            <returns>The extracted and trimmed content, or null if invalid range or empty</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.FindMatchingCloseParen(System.String,System.Int32,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddJoin(System.String,System.String)">
             <summary>
-                Finds the matching closing paren for an opening paren at given index.
-                Handles nested parentheses correctly and skips parentheses inside
-                excluded spans (e.g., backticked identifiers).
+                Adds a new join to the metric view
             </summary>
-            <param name="str">The string to search within</param>
-            <param name="openIndex">The index of the opening parenthesis</param>
-            <param name="excludeSpans">
-                Spans to exclude from paren matching (e.g., backticked identifiers).
-                Any parentheses within these spans are ignored.
-            </param>
-            <returns>The index of the matching closing parenthesis, or -1 if not found</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.IsInExcludedSpan(System.Int32,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.ColumnReferenceSpan})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddJoin(System.String,System.String,System.String)">
             <summary>
-                Checks if a position falls within any excluded span.
+                Adds a new join to the metric view with parentName as the parent join
             </summary>
-            <param name="position">The position to check</param>
-            <param name="spans">The list of excluded spans</param>
-            <returns>True if position is within any span, false otherwise</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.ExtractAggregationContent(System.String)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Dimensions">
             <summary>
-                Extracts the content inside aggregation function parentheses.
-                For DISTINCT COUNT, treats DISTINCT as part of the aggregation spec.
-                AGG_FUNCTION(content) -> returns "content"
-                COUNT(DISTINCT content) -> returns "content" (DISTINCT is part of
-                aggregation).
-                Returns null if pattern doesn't match or has invalid structure.
+                Legacy name for <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields" />. A live, read-only view over
+                the same underlying collection: no items are copied, no separate
+                collection is maintained, and every read defers to
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields" /> and casts. The cast to <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" />
+                is safe because <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.NewField(System.String,System.String)" /> constructs every field as a
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> at runtime. Item references are the same
+                instances stored in <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields" />, so mutations through
+                either surface are visible through the other, and later additions or
+                removals are reflected immediately.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.DimensionCollectionView">
+            <summary>
+                The deferring view behind <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Dimensions" />.
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1" /> is invariant, so the same
+                instance cannot satisfy both <c>&lt;Field&gt;</c> and
+                <c>&lt;Dimension&gt;</c>; this view bridges the element type for the
+                deprecation window by casting per access.
             </summary>
-            <remarks>
-                Uses position-aware column reference parsing to correctly handle
-                parentheses inside backticked identifiers (e.g., `Field) Name`).
-            </remarks>
-            <param name="expression">The aggregation expression to parse</param>
-            <returns>The content between parentheses, or null if extraction fails</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.ValidateSimpleAggregationStructure(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.DimensionCollectionView.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field})">
             <summary>
-                Validates that expression has the structure of a simple aggregation.
-                Extracts content between parens and validates it's a single column reference.
-                Since ExtractAggregationContent now treats DISTINCT as part of the aggregation,
-                no special handling is needed for DISTINCT COUNT.
+                The deferring view behind <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Dimensions" />.
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewCollection`1" /> is invariant, so the same
+                instance cannot satisfy both <c>&lt;Field&gt;</c> and
+                <c>&lt;Dimension&gt;</c>; this view bridges the element type for the
+                deprecation window by casting per access.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.ToMeasureFragment(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,TabularEditor.SemanticBridge.AbstractModel.Builder.FactFragment,TabularEditor.SemanticBridge.AbstractModel.Builder.IAbstractModelBuilder)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.NewField(System.String,System.String)">
             <summary>
-                Converts a Databricks Metric View Measure to a MeasureFragment,
-                handling field lookup/creation and determining measure type.
+                Internal factory used by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField(System.String,System.String)" /> (and indirectly
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddDimension(System.String,System.String)" />) to construct every <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" />
+                instance as a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> at runtime.
             </summary>
-            <param name="measure">The Metric View measure to convert</param>
-            <param name="view">The Metric View containing the measure</param>
-            <param name="fact">The fact fragment to associate the measure with</param>
-            <param name="builder">The model builder for fragment management</param>
-            <returns>A configured MeasureFragment ready to be added to the model</returns>
             <remarks>
                 <para>
-                    This method bridges the gap between measure analysis and fragment creation:
+                    The load-bearing piece of the legacy shim. Because the
+                    <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Dimensions" /> getter casts items to
+                    <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> and <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddDimension(System.String,System.String)" /> returns
+                    one, every instance backing a <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields" /> entry
+                    must actually be a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> subclass at runtime.
+                    The compile-time return type stays <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" /> so
+                    canonical callers see the canonical type; only the runtime
+                    instance type differs.
+                </para>
+                <para>
+                    Implications while the shim lives:
+                    <list type="bullet">
+                        <item>
+                            <c>field.GetType()</c> returns <c>typeof(Dimension)</c>,
+                            not <c>typeof(Field)</c>, for any field constructed via
+                            <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField(System.String,System.String)" /> or <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddDimension(System.String,System.String)" />.
+                        </item>
+                        <item>
+                            Default <c>object.ToString()</c> would surface the
+                            runtime <c>Dimension</c> type name;
+                            <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field.ToString" /> is overridden to mask this
+                            in logs and debugger tooltips.
+                        </item>
+                        <item>
+                            Reflection-based code that inspects the runtime type
+                            name (custom serializers, reflection-based assertions,
+                            some debugger views) will observe <c>Dimension</c>.
+                            The legacy <c>(Dimension)field</c> cast succeeds
+                            without copying state — this is why we construct
+                            eagerly rather than wrapping per-access.
+                        </item>
+                    </list>
                 </para>
-                <list type="number">
-                    <item>Analyzes the measure using <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.Analyze(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)" /></item>
-                    <item>For simple measures: ensures field exists and creates aggregation fragment</item>
-                    <item>For calculated measures: creates expression-based fragment</item>
-                </list>
                 <para>
-                    Simple measures get a FieldKey and AggregationType.
-                    Calculated measures get an Expression and no AggregationType.
+                    When <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> is eventually removed, this
+                    factory and its callers revert to constructing
+                    <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" /> directly. The runtime type flips back —
+                    any external code that hardcoded the runtime type name to
+                    <c>"Dimension"</c> will then need to update.
                 </para>
             </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.MeasureExtensions.DataTypeForAggregation(TabularEditor.SemanticBridge.AbstractModel.AggregationType)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddDimension(System.String,System.String)">
             <summary>
-                Determines the appropriate DataType for a simple measure based on its aggregation type.
-                Count and DistinctCount produce integer results; other aggregations produce Decimal.
+                Legacy name for <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField(System.String,System.String)" />. The returned reference is
+                typed as <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> so call sites that assign to a
+                <c>Dimension</c>-typed local continue to compile; the underlying
+                instance is the same one stored in <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Fields" />.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.PathExtensions">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window">
             <summary>
-                Extension methods for traversing a MetricView object graph by canonical
-                path string.
+                Specifies window measure behavior for windowed, cumulative, or
+                semiadditive aggregations.
             </summary>
+            <remarks>
+                This is an experimental feature in Databricks.
+                The Semantic Bridge performs minimal validation or enforcement of the
+                window specification.
+            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.SourceHelper.ParseSqlObject(System.String)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.SemiadditiveType">
             <summary>
-                Parses a 3-part SQL table name into its constituent parts.
+                Aggregation strategy for semiadditive measures.
             </summary>
-            <param name="source">The source string to parse</param>
-            <returns>Database, schema, and table names if parsing succeeds; null otherwise</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.SourceHelper.GetSourceFragment(System.String,System.String,System.String,System.String)">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.SemiadditiveType.First">
             <summary>
-                Creates a SourceFragment with queryable properties if the source is
-                a 3-part table name, otherwise creates one with a query property.
+                Makes sure that the first cumulative value is used when
+                aggregating over fields
             </summary>
-            <param name="source">The source string to create a fragment for</param>
-            <param name="key">The fragment key</param>
-            <param name="name">The fragment name</param>
-            <param name="sourceSystemKey">The source system key reference</param>
-            <returns>A configured SourceFragment</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.SourceHelper.CleanIdentifier(System.String)">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.SemiadditiveType.Last">
             <summary>
-                Removes backticks from identifier if present.
+                Makes sure that the last cumulative value is used when
+                aggregating over fields
             </summary>
-            <param name="identifier">The identifier to clean</param>
-            <returns>The cleaned identifier without surrounding backticks</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Extensions.SourceHelper.SqlObjectPattern">
-            <remarks>
-            Pattern:<br/>
-            <code>^(?&lt;database&gt;[a-zA-Z_][a-zA-Z0-9_]*|`[^`]+`)\\.(?&lt;schema&gt;[a-zA-Z_][a-zA-Z0-9_]*|`[^`]+`)\\.(?&lt;table&gt;[a-zA-Z_][a-zA-Z0-9_]*|`[^`]+`)$</code><br/>
-            Options:<br/>
-            <code>RegexOptions.Compiled</code><br/>
-            Explanation:<br/>
-            <code>
-            ○ Match if at the beginning of the string.<br/>
-            ○ "database" capture group.<br/>
-                ○ Match with 2 alternative expressions.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [A-Z_a-z].<br/>
-                        ○ Match a character in the set [0-9A-Z_a-z] atomically any number of times.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match '`'.<br/>
-                        ○ Match a character other than '`' atomically at least once.<br/>
-                        ○ Match '`'.<br/>
-            ○ Match '.'.<br/>
-            ○ "schema" capture group.<br/>
-                ○ Match with 2 alternative expressions.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [A-Z_a-z].<br/>
-                        ○ Match a character in the set [0-9A-Z_a-z] atomically any number of times.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match '`'.<br/>
-                        ○ Match a character other than '`' atomically at least once.<br/>
-                        ○ Match '`'.<br/>
-            ○ Match '.'.<br/>
-            ○ "table" capture group.<br/>
-                ○ Match with 2 alternative expressions.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match a character in the set [A-Z_a-z].<br/>
-                        ○ Match a character in the set [0-9A-Z_a-z] atomically any number of times.<br/>
-                    ○ Match a sequence of expressions.<br/>
-                        ○ Match '`'.<br/>
-                        ○ Match a character other than '`' atomically at least once.<br/>
-                        ○ Match '`'.<br/>
-            ○ Match if at the end of the string or if before an ending newline.<br/>
-            </code>
-            </remarks>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Order">
+            <summary>
+                The field name that determines the ordering of the window.
+            </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Range">
             <summary>
-                Represents a join definition in a Databricks Metric View
+                Defines the extent of the window.
+                Values: "current", "cumulative", "trailing N unit", "leading N unit", "all"
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Name">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Semiadditive">
             <summary>
-                Name of the joined table
+                Specifies how to summarize the measure when the order field is not
+                included in the query's `GROUP BY`.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Source">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Offset">
             <summary>
-                Source table or query for the join
+                Optional offset that shifts the window frame backward or forward
+                along the <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Order" /> field by a fixed interval. Treated
+                as an opaque string: we round-trip the source form verbatim and
+                do not validate.
+                Per the v1.1 spec the form is <c>&lt;n&gt; &lt;period&gt;</c>
+                where <c>n</c> is a signed integer (negative looks backward,
+                positive looks forward) and <c>period</c> is one of <c>day</c>,
+                <c>days</c>, <c>month</c>, <c>months</c>, <c>year</c>, or
+                <c>years</c>. Examples: <c>-12 month</c>, <c>1 year</c>,
+                <c>-3 days</c>, <c>7 day</c>.
+                Spec constraints we do not enforce: <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Order" /> must be
+                a date or timestamp column; <c>offset</c> has no effect when
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window.Range" /> is <c>all</c>; a shifted frame outside the
+                available data evaluates to NULL at query time.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.On">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews">
             <summary>
-                Optional SQL boolean expression for the join condition
+                Static wrapper/convenience class for use in C# scripts
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Using">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Load(System.String)">
             <summary>
-                Optional list of column names to use for join
+                Loads a MetricView from a YAML file
             </summary>
+            <param name="path">full path to the yaml file on disk</param>
+            <returns>an unvalidated MetricView</returns>
+            <exception cref="T:System.IO.InvalidDataException">
+                Thrown in exceptional failures of deserialization; we should always see a result
+            </exception>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join.Joins">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Deserialize(System.String)">
             <summary>
-                Child joins that are part of this join definition
+                Deserialize a MetricView from a YAML string
             </summary>
+            <param name="yaml">the YAML string to deserialize</param>
+            <returns>an unvalidated MetricView</returns>
+            <exception cref="T:System.IO.InvalidDataException">
+                thrown in exceptional failures of deserialization; we should always see a result
+            </exception>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Save(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.String)">
             <summary>
-                Represents a measure definition in a Databricks Metric View
+                Serialize the MetricView to YAML and save to disk
             </summary>
+            <param name="view">the MetricView to serialize</param>
+            <param name="path">the path to save the YAML file</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure.Expr">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Serialize(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
             <summary>
-                Aggregate SQL expression that defines the measure
+                Serialize a MetricView to a YAML string
             </summary>
+            <param name="view">the MetricView to serialize</param>
+            <returns>the serialized YAML string</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.DefaultValidationRules">
             <summary>
-                Internal abstract base class for all MetricView domain objects.
-                Implements both the public marker interface and the internal visitable interface.
+                The default validation rules to use when validating MetricViews.
+                Automatically used when calling `Validate(MetricView)` overload
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase.TabularEditor#SemanticBridge#Platforms#Databricks#Interfaces#IMetricViewVisitable#Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewVisitor{``0})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor)">
             <summary>
-                Accepts a visitor that produces a result of type TResult.
-                Must be implemented by derived domain objects.
+                Validate a MetricView using the provided validator
             </summary>
+            <param name="view">the MetricView to validate</param>
+            <param name="validator">the validator to use</param>
+            <returns>enumerable of diagnostic messages resulting from the validation rules</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.DeserializationValidator">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
             <summary>
-                Validator for MetricView objects after YAML deserialization. Collects
-                all validation errors. Intentionally a very limited set of rules. We
-                don't own the metric view spec, so this should be somewhat permissive
-                and only return an error for very obvious issues that should be
-                impossible.
+                Validate a MetricView using the default set of validation rules
             </summary>
+            <param name="view">MetricView to validate</param>
+            <returns>enumerable of diagnostic messages resulting from the validation rules</returns>
+            <remarks>The set of rules is available as `MetricViews.DefaultValidationRules`</remarks>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlDeserializer">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
             <summary>
-                Handles deserialization of Databricks Metric Views from YAML
+                Validate a MetricView using the provided set of rules
             </summary>
+            <param name="view">the MetricView to validate</param>
+            <param name="rules">the set of validation rules to apply</param>
+            <returns>enumerable of diagnostic messages resulting from the validation rules</returns>
+            <remarks>does not use any of the default rules unless you explicitly include these</remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlDeserializer.Deserialize(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidator">
             <summary>
-                Deserializes a YAML string into a MetricView object
+                Make a new MetricViewValidationVisitor with the default set of rules
             </summary>
-            <param name="yaml">The YAML string to deserialize</param>
-            <returns>A MetricView object</returns>
-            <exception cref="T:System.ArgumentException">If YAML is invalid or cannot be deserialized</exception>
-            <exception cref="T:System.AggregateException">
-                If semantic validation fails, contains one or more
-                <see cref="T:System.IO.InvalidDataException" /> for each validation error.
-            </exception>
+            <returns>a reusable MetricViewValidationVisitor to use as a validator</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlSerializer">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidator(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule},System.Boolean)">
             <summary>
-                Handles serialization of Databricks Metric Views to YAML
+                Make a new MetricViewValidationVisitor with the provided set of
+                rules, optionally including the default rules
             </summary>
+            <param name="rules">the set of validation rules to use in the validator</param>
+            <param name="includeDefaultRules">
+                whether to include the default rules (default: `true`)
+            </param>
+            <returns>a reusable MetricViewValidationVisitor to use as a validator</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Serialization.MetricViewYamlSerializer.Serialize(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.Func{``0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}})">
             <summary>
-                Serializes a MetricView object to a YAML string
+                Creates a validation rule for a specific type of MetricView object.
             </summary>
-            <param name="metricView">The MetricView object to serialize</param>
-            <returns>A YAML string representation</returns>
+            <typeparam name="T">
+                type of MetricView object the rule applies to. One of `MetricView`,
+                `MetricViewField`, `MetricViewJoin`, `MetricViewMeasure`
+            </typeparam>
+            <param name="name">name of the rule</param>
+            <param name="category">category for the rule (you can use any text)</param>
+            <param name="validate">validation function</param>
+            <returns>a validation rule for use in a validator</returns>
+            <remarks>
+                the validation function `validate` is a function of two arguments:
+                1. the metric view object to which the rule is applied
+                2. the validation context
+                validation context is a `IReadOnlyValidationContext` object which
+                provides:
+                - `PathStack`: identifies the exact object currently being
+                examined, with all of its parents (in reverse order from this
+                object to the root). In general you probably don't need to do
+                much with this.
+                - `JoinNames`: set of strings of all join names already seen
+                during validation
+                - `FieldNames`: set of strings of all field names already
+                seen
+                - `MeasureNames`: set of strings of all measure names already seen
+                - `MakeError(message, property)`: function to create a diagnostic
+                error. **You should use this to create the errors you return**.
+                The first arg is a string describing the error. The second arg
+                is an optional property name (e.g. "Name") to append to the path.
+                **Only use the name of a MetricView object property**, not any
+                arbitrary string.
+                Your function must return an enumerable of DiagnosticMessage objects.
+                If there are no problems, return an empty enumerable (e.g. `[]`).
+                If the object is invalid according to the rule (your conditional
+                checks), then return an enumerable with one or more errors created
+                with the context's `MakeError` method. You can inspect any properties
+                of the object (the first arg to your function) or anything in the
+                context object.
+            </remarks>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.Func{``0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}},System.String)">
+            <inheritdoc
+                cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.Func{``0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean})">
+            <summary>
+                Create a validation rule for a specific MetricView object type
+            </summary>
+            <typeparam name="T">
+                type of MetricView object the rule applies to. One of `MetricView`,
+                `MetricViewField`, `MetricViewJoin`, `MetricViewMeasure`
+            </typeparam>
+            <param name="name">name of the rule</param>
+            <param name="category">category for the rule (you can use any text)</param>
+            <param name="message">the message returned in the error if the object is invalid</param>
+            <param name="isInvalid">a predicate function to determine if the object is invalid</param>
+            <returns>a validation rule for use in a validator</returns>
+            <remarks>
+                the function `isInvalid` is a simple predicate function that can
+                only inspect the properties of the current MetricView object. If you
+                need to inspect other context, you should use the other overload of
+                `MakeValidationRule`
+            </remarks>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRule``1(System.String,System.String,System.String,System.Func{``0,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean})">
             <summary>
-                Represents a Databricks Metric View definition
+                Create a validation rule for the root MetricView object
             </summary>
+            <param name="name">name of the rule</param>
+            <param name="category">category for the rule (you can use any text)</param>
+            <param name="message">the message returned in the error if the object is invalid</param>
+            <param name="isInvalid">a predicate function to determine if the object is invalid</param>
+            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Version">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForView(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean})">
             <summary>
-                Version of the metric view specification
+                Create a validation rule for MetricViewJoin objects
             </summary>
+            <param name="name">name of the rule</param>
+            <param name="category">category for the rule (you can use any text)</param>
+            <param name="message">
+                the message returned in the error if the MetricViewJoin is invalid
+            </param>
+            <param name="isInvalid">
+                a predicate function to determine if the MetricViewJoin is invalid
+            </param>
+            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Source">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForJoin(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForField(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field,System.Boolean})">
             <summary>
-                The source data for the metric view, playing the role of a single fact
+                Create a validation rule for MetricViewField objects
             </summary>
+            <param name="name">name of the rule</param>
+            <param name="category">category for the rule (you can use any text)</param>
+            <param name="message">
+                the message returned in the error if the MetricViewField is invalid
+            </param>
+            <param name="isInvalid">
+                a predicate function to determine if the MetricViewField is invalid
+            </param>
+            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Filter">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForField(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForField(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean})">
             <summary>
-                Optional SQL boolean expression that applies to all queries; a WHERE
+                Create a validation rule for MetricViewMeasure objects
             </summary>
+            <param name="name">name of the rule</param>
+            <param name="category">category for the rule (you can use any text)</param>
+            <param name="message">
+                the message returned in the error if the MetricViewMeasure is invalid
+            </param>
+            <param name="isInvalid">
+                a predicate function to determine if the MetricViewMeasure is invalid
+            </param>
+            <returns>a validation rule for use in a validator</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Joins">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean},System.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.MakeValidationRuleForMeasure(System.String,System.String,System.String,System.Func{TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure,System.Boolean})" />
+            <param name="minVersion">Minimum spec version this rule applies to (e.g. "1.1")</param>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.ToTabularModel(TabularEditor.TOMWrapper.Model,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.String,System.String,System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}@,System.Boolean,System.String)">
             <summary>
-                Optional join definitions for the metric view
+                Companion to <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.MetricViews.ToTabularModel(TabularEditor.TOMWrapper.Model,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View,System.String,System.String,System.Collections.Generic.List{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}@,System.Boolean,System.String)" /> that routes through the
+                <c>AbstractModel.Next</c> visitor pipeline. Same return contract and
+                diagnostic semantics; the two coexist while the new pipeline is
+                completed.
             </summary>
-            <remarks>
-                A join is also the place where dimension sources are defined; this
-                information exists nowhere else.
-            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Dimensions">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast">
             <summary>
-                Array of dimension definitions
+                Parses Databricks SQL expressions into an <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression" />
+                AST using <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser" /> and an ANTLR visitor.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.Measures">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.Tokenize(System.String)">
+            <summary>Tokenize the SQL expression in `input`</summary>
+            <returns>Token stream omitting whitespace and comments</returns>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.Parse(System.String)">
             <summary>
-                Array of measure definitions
+                Parse the input expression and return the AST root with any errors.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast._lastGood">
             <summary>
-                Provides the default set of validation rules that match the current
-                implementation of MetricViewValidationVisitor.
+                Cache for parse results; most recently visited non-Unknown. Acts
+                as an anchor for error-recovery spans.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.ForType``1">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.Visit(Antlr4.Runtime.Tree.IParseTree)">
             <summary>
-                Returns validation rules for the specified type.
+                Ensure we wrap all concrete visit methods and catch those antlr
+                trees which have not been handled.
             </summary>
-            <typeparam name="T">The type of object to get rules for.</typeparam>
-            <returns>ValidMetricViewRules that apply to the specified type.</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.InCategory(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)">
             <summary>
-                Returns validation rules in the specified category.
+                Route child visits through Visit instead of Accept so our error
+                handling and caching in Visit applies at every depth. ANTLR's
+                default VisitChildren uses Accept which bypasses Visit.
             </summary>
-            <param name="category">The category of rules to get.</param>
-            <returns>ValidMetricViewRules that belong to the specified category.</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.GetByName(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.AggregateResult(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression)">
             <summary>
-                Returns validation rules with the specified name.
+                Aggressive aggregation: a non-null aggregate means we are inside
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)" /> of a rule without an explicit visitor
+                override. Wrap the running aggregate plus the next child into an
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown" /> that preserves structurally-
+                recognized subtrees as <c>Inner</c> children.  Existing Unknown
+                wrappers are flattened so we never produce
+                <c>Unknown(Unknown(...))</c>. Effect: any unhandled grammar rule
+                surfaces as Unknown spanning its full source extent, with all
+                recognized inner expressions reachable via the standard
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Children" /> walk.
             </summary>
-            <param name="name">The name of the rule to find.</param>
-            <returns>The rule with the specified name, or null if not found.</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.UnknownSpanAfterLastGood">
             <summary>
-                Visitor that validates a MetricView object graph using configurable rules.
+                Find the first default-channel token at or after the last
+                successfully visited node. Falls back to last good end, then to
+                start of input.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.#ctor(System.Collections.Generic.List{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.SpanForTree(Antlr4.Runtime.Tree.IParseTree)">
             <summary>
-                Visitor that validates a MetricView object graph using configurable rules.
+                Create a non-overlapping, contiguous span for the tree node.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Rules">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.SpanFrom(Antlr4.Runtime.ParserRuleContext)">
             <summary>
-                The validation rules which will be applied during traversal.
+                Create a TextSpan for the whole range of the parser rule context.
+                Intended for use in known valid parser visit methods only.
             </summary>
+            <exception cref="T:System.InvalidOperationException">
+                Thrown when the context includes a null Stop token, which means
+                we're trying to make a span for a context where we can't. Should
+                never throw in normal operation; this is just extra defensiveness.
+            </exception>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.#ctor(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.VisitLiteralExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.LiteralExprContext)">
             <summary>
-                Creates a new validation visitor with only the specified rules.
+                Dispatch on the matched terminal token to produce the corresponding
+                typed <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal" /> subtype with the parsed
+                payload. Numeric and string parsing happens once here so downstream
+                consumers (AAST builders, validators) don't need to re-derive value
+                from the raw span text.
             </summary>
-            <param name="rules">The validation rules to apply</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.#ctor">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.UnquoteSqlString(System.String)">
             <summary>
-                Creates a new validation visitor with the default rules.
+                Strip the outer single quotes from a SQL string literal and
+                unescape embedded <c>''</c> to a single quote.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.WithDefaultRules(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.ParseDecimal(System.String)">
             <summary>
-                Creates a new validation visitor with the default rules and optional extra rules.
+                Parse a numeric token (DECIMAL / FLOAT / REAL) into a
+                <see cref="T:System.Decimal" />. Uses <see cref="F:System.Globalization.NumberStyles.Float" /> so
+                exponential notation (<c>1.5e2</c>) is accepted alongside the
+                simpler integer/fractional forms.
             </summary>
-            <param name="extraRules">Extra rules to be used in traversal of the metric view</param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.BinOp(Antlr4.Runtime.ParserRuleContext)">
             <summary>
-                Validates a MetricView object by applying all applicable rules and
-                traversing its structure.
+                Create AST node for any binary expression. All have the same 3 parts.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.ParserErrorContext(Antlr4.Runtime.RecognitionException,System.Int32)">
             <summary>
-                Validates a MetricViewJoin object by applying all applicable rules and
-                traversing any child joins.
+                Best available context span for a parser error: the enclosing rule
+                if available, otherwise the whole line.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.Ast.LineSpan(System.Int32)">
             <summary>
-                Validates a MetricViewDimension object by applying all applicable rules.
+                Extract a TextSpan covering the entire line (1-based) from _input.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor`1">
             <summary>
-                Validates a MetricViewMeasure object by applying all applicable rules.
+                Double-dispatch visitor over <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression" /> nodes. One
+                <c>Visit</c> overload per concrete leaf type — adding a new leaf to
+                the SQL AST forces every visitor to consider it (either override or
+                inherit the default abort from <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1" />).
+                <para>
+                    Recursive code in concrete overloads should call
+                    <c>Visit(child)</c>, not <c>child.Accept(this)</c> — the
+                    <c>Visit(SqlExpression)</c> dispatcher routes through Accept,
+                    keeping the dispatch detail in one place. An
+                    <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" /> raised from any nested
+                    <c>Visit</c> propagates freely; only the outermost emit (via
+                    <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.EmitWithFallback(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression)" />)
+                    catches it and invokes <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor`1.Fallback" />.
+                </para>
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.ApplyRules``1(System.Collections.Generic.List{TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule{``0}},``0)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor`1.Fallback">
             <summary>
-                Applies all applicable validation rules to the target object.
-                A rule receives a read-only view of the validation context to prevent
-                accidental mutation.
+                Visitor-specific placeholder produced when emission aborts. For an
+                SQL-to-AAST builder this is typically
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Unstructured" /> wrapping
+                the verbatim source; for other consumers (validators, dumpers) it
+                can be whatever default the visitor's result type calls for.
+                Implementors MUST override; the abstract base class declares this
+                <c>abstract</c> so the omission fails at compile time.
             </summary>
-            <typeparam name="T">The type of object being validated</typeparam>
-            <param name="rules">type-appropriate rules to be applied to `target`</param>
-            <param name="target">The object to validate</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Reset">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError">
             <summary>
-                Reset all state in the validation context to ensure idempotent operation.
+                A parse error reported by the ANTLR parser during expression parsing.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.Message">
             <summary>
-                Read-only view of validation context state for consumption by validation rules
+                ANTLR's formatted error description.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.PathStack">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.Context">
             <summary>
-                Read-only view of the stack tracking the current path in the object graph.
+                Surrounding context of source text where the failure occurred.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.JoinNames">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.LexerError">
             <summary>
-                Read-only view of join names seen during traversal for uniqueness validation
+                An error that comes from ANTLR's lexer pass
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.DimensionNames">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.LexerError.#ctor(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan,System.Int32)">
             <summary>
-                Read-only view of dimension names seen during traversal for
-                uniqueness validation
+                An error that comes from ANTLR's lexer pass
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.MeasureNames">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.LexerError.Message">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.LexerError.Context">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.LexerError.Position">
             <summary>
-                Read-only view of measure names seen during traversal for
-                uniqueness validation
+                The position of the character in the line that caused the lexer
+                failure.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.MakeError(System.String,System.String)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.ParserError">
             <summary>
-                Creates a diagnostic error message with the current path context
+                An error that comes from ANTLR's parse of the grammar
             </summary>
-            <param name="message">The error message</param>
-            <param name="property">The property that has the error</param>
-            <returns>A DiagnosticMessage with Error severity</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.ParserError.#ctor(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan,Antlr4.Runtime.IToken)">
             <summary>
-                Mutable validation context for internal validation orchestration.
-                Extends the read-only interface with mutation capabilities.
-                This interface is internal to restrict mutation operations to the
-                validation framework.
+                An error that comes from ANTLR's parse of the grammar
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.PathStack">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.ParserError.Message">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.ParserError.Context">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.ParserError.OffendingSymbol">
             <summary>
-                Mutable stack tracking the current path in the object graph
+                The token that caused the parse failure.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.JoinNames">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.SemanticError">
             <summary>
-                Mutable set of join names seen during traversal for uniqueness validation
+                A semantic error from our visit and interpretation of metric view
+                logic
             </summary>
+            <param name="Message"></param>
+            <param name="Context"></param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.DimensionNames">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.SemanticError.#ctor(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Mutable set of dimension names seen during traversal for
-                uniqueness validation
+                A semantic error from our visit and interpretation of metric view
+                logic
             </summary>
+            <param name="Message"></param>
+            <param name="Context"></param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.MeasureNames">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.SemanticError.Message">
+            <inheritdoc />
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError.SemanticError.Context">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseResult">
             <summary>
-                Mutable set of measure names seen during traversal for uniqueness validation
+                Result of parsing an expression string into an AST.
+                Always contains an expression (ANTLR recovers on errors).
+                Errors, if any, indicate where recovery occurred.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.Reset">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseResult.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ParseError},System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown})">
             <summary>
-                Resets the context state for a new validation run, ensuring idempotent operation
+                Result of parsing an expression string into an AST.
+                Always contains an expression (ANTLR recovers on errors).
+                Errors, if any, indicate where recovery occurred.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression">
             <summary>
-                Context object that maintains state during validation traversal of a
-                MetricView object graph.
-                External consumers can instantiate this but can only access mutation
-                capabilities within the same assembly.
+                AST node for a Databricks SQL expression. All variants carry a
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan" /> covering their extent in the original source.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext.MakeError(System.String,System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Creates a diagnostic error message with the current path context
+                AST node for a Databricks SQL expression. All variants carry a
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan" /> covering their extent in the original source.
             </summary>
-            <param name="message">The error message</param>
-            <param name="property">The property that has the error</param>
-            <returns>A DiagnosticMessage with Error severity</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext.TabularEditor#SemanticBridge#Platforms#Databricks#Validation#IMutableValidationContext#Reset">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Children">
             <summary>
-                Resets the context state for a new validation run, ensuring idempotency
-                internal only. Public consumers only see the readonly interface.
+                All direct children of the SqlExpression node.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext.PathCombine(System.String)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
             <summary>
-                Combines the path stack elements into a dot-notation path string
+                Double-dispatch hook. Each concrete subtype calls
+                <c>visitor.Visit(this)</c>, routing to the visitor overload that
+                accepts that specific shape. Implementors should never call
+                <c>Accept</c> directly; use <c>Visit(node)</c> on the visitor
+                instead, which routes through the base
+                <c>Visit(SqlExpression)</c> dispatcher.
             </summary>
-            <param name="property">Optional property to append to the path</param>
-            <returns>The combined path as a string</returns>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.DescendantsAndSelf">
             <summary>
-                Generic implementation of a validation rule for a specific type of
-                MetricView object.
+                Collect this node and all descendants in left-to-right DFS order.
             </summary>
-            <typeparam name="T">The type of object this rule validates</typeparam>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.#ctor(System.String,System.String,System.Func{`0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}})">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Descendants">
             <summary>
-                Generic implementation of a validation rule for a specific type of
-                MetricView object.
+                All descendants (excluding self) in left-to-right DFS order.
             </summary>
-            <typeparam name="T">The type of object this rule validates</typeparam>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.TargetType">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef">
             <summary>
-                Gets the type of object this rule is designed to validate.
+                A column reference in a Databricks SQL expression — either a bare
+                column name or a table-qualified column name.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Validates the target object if it matches the expected type.
+                A column reference in a Databricks SQL expression — either a bare
+                column name or a table-qualified column name.
             </summary>
-            <param name="target">The object to validate</param>
-            <param name="context">The read-only validation context</param>
-            <returns>
-                Collection of diagnostic messages for validation failures, or an
-                empty collection if validation passes
-            </returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.DataTypeExtensions.GetTomType(TabularEditor.SemanticBridge.AbstractModel.DataType)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified">
             <summary>
-                Maps Abstract Model DataType to Tabular Object Model DataType.
+                A SQL column name, e.g. `field` in `SELECT field FROM aTable`.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleMeasureExtensions">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified">
             <summary>
-                Extension methods for mapping SimpleMeasure to Tabular Model DAX
+                A qualified SQL column name: one or more dotted qualifiers
+                preceding the column. A 2-part ref (<c>t.field</c>) carries a
+                single qualifier; a multi-part snowflake path (<c>a.b.field</c>)
+                carries the full chain. The leaf qualifier (<see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified.Table" />)
+                is the column's immediate parent.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleMeasureExtensions.TryGenerateDax(TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure,TabularEditor.TOMWrapper.Model,System.Collections.Generic.Dictionary{System.String,System.String},System.String@)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified.Qualifiers">
             <summary>
-                Generates a DAX expression for a SimpleMeasure.
-                Returns a diagnostic message on failure.
+                The dotted qualifiers preceding the column, in source order;
+                at least one. The last is the column's immediate parent.
             </summary>
-            <param name="measure">The SimpleMeasure to generate DAX for</param>
-            <param name="model">The TOM model context</param>
-            <param name="tableNameMap">
-                map of Abstract model names to names of created tables in TOM model
-            </param>
-            <param name="daxExpression">The generated DAX expression, or null on failure</param>
-            <returns>A diagnostic message if validation fails, otherwise null</returns>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleMeasureExtensions.MapToDaxFunction(TabularEditor.SemanticBridge.AbstractModel.AggregationType)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified.Table">
             <summary>
-                Maps an AggregationType to the corresponding DAX function name.
-                Returns null if the aggregation type is not supported.
+                The leaf qualifier — the column's immediate parent. For a
+                2-part ref it is the only qualifier; for a multi-part path it
+                is the deepest one.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleRelationshipExtensions">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier)">
+            <summary>Convenience constructor for the common 2-part ref.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.EquivalentTo(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef)">
             <summary>
-                Extension methods for mapping SimpleRelationship to Tabular Model relationships.
+                Case-insensitive equivalence check on the identifier values.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleRelationshipExtensions.TryCreateTomRelationship(TabularEditor.SemanticBridge.AbstractModel.SimpleRelationship,TabularEditor.TOMWrapper.Model,TabularEditor.TOMWrapper.Table,TabularEditor.TOMWrapper.Table,TabularEditor.TOMWrapper.SingleColumnRelationship@)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.TableOrDefault(System.String)">
             <summary>
-                Creates a TOM relationship from a SimpleRelationship.
-                Returns a diagnostic message on failure.
+                Returns the table name for qualified refs, or <paramref name="defaultTable" />
+                for unqualified refs. An unqualified column means different things depending
+                on where it appears in a metric view: in a field expression it refers to
+                the source table, while in a join ON clause it refers to the join table itself.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleRelationshipExtensions.DetermineRelationshipDirection(TabularEditor.SemanticBridge.AbstractModel.SimpleRelationship,TabularEditor.TOMWrapper.Table,TabularEditor.TOMWrapper.Table)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.ToSql">
             <summary>
-                Determines the direction of a relationship based on cardinality.
-                Returns the many-side field, one-side field, and their respective tables.
+                Render the reference using quoting rules as follows:
+                - If empty -> omitted (for table) or empty string for column.
+                - Any token containing a dot is always backticked (e.g. `a.b` is one part)
+                - Any token that is also a keyword is backticked, despite Databricks
+                allowing more permissive naming
+                - Bare identifier pattern [A-Za-z_][A-Za-z0-9_]* AND not a
+                reserved word -> emitted bare.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.SimpleRelationshipExtensions.MapToTomFilterBehavior(TabularEditor.SemanticBridge.AbstractModel.FilterDirection)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionArgs">
             <summary>
-                Maps Abstract Model FilterDirection to TOM CrossFilteringBehavior.
+                The argument content of a function call — either a list of
+                expressions or a wildcard (<c>*</c>).
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionArgs.ExpressionList">
+            <summary>Zero or more expression arguments.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionArgs.ExpressionList.#ctor(System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression})">
+            <summary>Zero or more expression arguments.</summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionArgs.Wildcard">
+            <summary>Wildcard argument: <c>*</c>.</summary>
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall">
             <summary>
-                Visitor that maps from an Abstract Model to a Tabular (TOM) Model.
-                Traverses the Abstract Model object graph and mutates the provided TOM Model.
+                A function call: <c>SUM(amount)</c>, <c>COUNT(*)</c>,
+                <c>COUNT(DISTINCT col1, col2)</c>, etc.
             </summary>
-            <remarks>
-                Creates a new visitor that will populate the specified Tabular model.
-            </remarks>
-            <param name="model">The TOMWrapper Model to populate with Abstract Model data</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.#ctor(TabularEditor.TOMWrapper.Model)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionArgs,System.Boolean,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visitor that maps from an Abstract Model to a Tabular (TOM) Model.
-                Traverses the Abstract Model object graph and mutates the provided TOM Model.
+                A function call: <c>SUM(amount)</c>, <c>COUNT(*)</c>,
+                <c>COUNT(DISTINCT col1, col2)</c>, etc.
             </summary>
-            <remarks>
-                Creates a new visitor that will populate the specified Tabular model.
-            </remarks>
-            <param name="model">The TOMWrapper Model to populate with Abstract Model data</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Interfaces.IAbstractModelVisitable)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef">
             <summary>
-                Entry point for generic visitor pattern orchestration.
-                Delegates to the visitable object's Accept method for double dispatch.
+                A MEASURE reference: <c>MEASURE(measure_name)</c>. References
+                another measure by name within a measure expression.
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef.MeasureName" /> is a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier" />
+                rather than a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression" /> so the inner name does
+                not surface as a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef" /> in descendant walks.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Root)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visits the Root of the Abstract Model.
-                Traverses Facts, Dimensions, Perspectives, and SecurityModel.
+                A MEASURE reference: <c>MEASURE(measure_name)</c>. References
+                another measure by name within a measure expression.
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef.MeasureName" /> is a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier" />
+                rather than a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression" /> so the inner name does
+                not surface as a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef" /> in descendant walks.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Fact)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.BinaryOp">
+            <summary>Binary operator: <c>a + b</c>, <c>x AND y</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.BinaryOp.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Binary operator: <c>a + b</c>, <c>x AND y</c>.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.BinaryOp.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.BinaryOp.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.UnaryOp">
+            <summary>Unary operator: <c>-a</c>, <c>NOT x</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.UnaryOp.#ctor(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Unary operator: <c>-a</c>, <c>NOT x</c>.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.UnaryOp.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.UnaryOp.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr">
             <summary>
-                Visits a Fact.
-                Creates a TOM Table and sets up context for child visitors.
-                Traverses Source, Fields, Measures, and DimensionReferences.
+                CASE expression. Two forms share <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Whens" /> and
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Else" /> on the base.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Dimension)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.#ctor(System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.WhenClause},TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visits a Dimension.
-                Creates a TOM Table and sets up context for child visitors.
-                Traverses Source , Attributes, and Hierarchies.
+                CASE expression. Two forms share <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Whens" /> and
+                <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Else" /> on the base.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.DimensionReference)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Searched">
+            <summary>Searched: <c>CASE WHEN cond THEN result ... END</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Searched.#ctor(System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.WhenClause},TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Searched: <c>CASE WHEN cond THEN result ... END</c>.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Searched.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Searched.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Simple">
+            <summary>Simple: <c>CASE expr WHEN value THEN result ... END</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Simple.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.WhenClause},TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Simple: <c>CASE expr WHEN value THEN result ... END</c>.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Simple.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Simple.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Paren">
+            <summary>Parenthesized expression: <c>(expr)</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Paren.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Parenthesized expression: <c>(expr)</c>.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Paren.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Paren.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal">
             <summary>
-                Visits a DimensionReference.
-                Sets context for relationship visitor and delegates relationship creation.
+                Literal value. Abstract intermediate; each concrete subtype carries
+                the typed payload extracted by the parser visitor — so consumers
+                don't have to re-parse the span text.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.SimpleMeasure)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visits a SimpleMeasure.
-                Generates a DAX expression based on aggregation type and creates a TOM measure.
+                Literal value. Abstract intermediate; each concrete subtype carries
+                the typed payload extracted by the parser visitor — so consumers
+                don't have to re-parse the span text.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.CalculatedMeasure)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Children">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.String">
+            <summary>String literal — payload with quote-escaping already resolved.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.String.#ctor(System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>String literal — payload with quote-escaping already resolved.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.String.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Numeric">
             <summary>
-                Visits a CalculatedMeasure.
+                Numeric literal. Covers DECIMAL, FLOAT, and REAL grammar
+                productions; the source-level kind difference doesn't survive
+                into the AST.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.SimpleRelationship)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Numeric.#ctor(System.Decimal,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visits a SimpleRelationship.
-                Creates a TOM relationship between the current table and the dimension table.
+                Numeric literal. Covers DECIMAL, FLOAT, and REAL grammar
+                productions; the source-level kind difference doesn't survive
+                into the AST.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.RolePlayingRelationship)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Numeric.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Boolean">
+            <summary>Boolean literal — <c>TRUE</c> or <c>FALSE</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Boolean.#ctor(System.Boolean,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Boolean literal — <c>TRUE</c> or <c>FALSE</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Boolean.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Null">
+            <summary>Null literal — <c>NULL</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Null.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Null literal — <c>NULL</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Null.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown">
             <summary>
-                Visits a RolePlayingRelationship.
-                Currently not implemented - role-playing dimensions require special handling.
+                Fallback for parse errors or unrecognized constructs. May wrap
+                structurally-recognized subtrees that were preserved while the
+                surrounding rule itself was not understood.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.DimensionAttribute)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression})">
             <summary>
-                Visits a DimensionAttribute.
-                Creates a data column using the attribute's name and referencing
-                the source field, or delegates to DerivedField visitor if underlying field is derived.
+                Fallback for parse errors or unrecognized constructs. May wrap
+                structurally-recognized subtrees that were preserved while the
+                surrounding rule itself was not understood.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Hierarchy)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
+            <summary>Terminal-Unknown convenience: no preserved subtrees.</summary>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown.Children">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Error">
             <summary>
-                Visits a Hierarchy.
-                Traverses Levels (which are DimensionAttributes).
+                Recognized-invalid construct with a specific diagnostic.
+                Unlike <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown" />, this means we matched a known-bad
+                pattern and can describe the problem precisely.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Field)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Error.#ctor(System.String,System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visits a Field.
-                Fields on sources are metadata and don't create columns.
-                Fields on facts create data columns.
+                Recognized-invalid construct with a specific diagnostic.
+                Unlike <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown" />, this means we matched a known-bad
+                pattern and can describe the problem precisely.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.DerivedField)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Error.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1">
             <summary>
-                Visits a DerivedField.
-                Creates a TOM CalculatedColumn with the original expression in a DAX comment.
+                Default base for <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor`1" />
+                implementations that want the standard abort-and-fallback semantics:
+                unimplemented <c>Visit</c> overloads throw
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" />, and the outermost emit catches
+                once at the root and invokes <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Fallback" />.
+                <para>
+                    New-visitor minimum viable shape: derive, override
+                    <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Fallback" />, ship. Override per-shape <c>Visit</c>
+                    overloads incrementally for the constructs the visitor knows how
+                    to translate; everything else falls through to the abort and
+                    then to <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Fallback" /> at the root.
+                </para>
+                <para>
+                    Recursive code in concrete overloads should call
+                    <c>Visit(child)</c>, not <c>child.Accept(this)</c> — the
+                    <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression)" /> override routes through
+                    Accept, keeping the dispatch detail in one place. An
+                    <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" /> raised from any nested
+                    call propagates freely; do not catch it inside a Visit overload.
+                </para>
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Fallback">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor`1.Fallback" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression)">
             <summary>
-                Visits a QueryableSource.
-                Creates a TOM M partition with generated expression from the source system.
-                Must be called within a table context (set by Visit(Fact) or Visit(Dimension)).
+                Polymorphic-dispatch entry. Routes through the node's
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Accept``1(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.ISqlExpressionVisitor{``0})" /> to the matching
+                concrete-typed Visit overload.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)">
             <summary>
-                Visits a QuerySource.
-                Creates a TOM M partition with generated expression from the source system.
-                Must be called within a table context (set by Visit(Fact) or Visit(Dimension)).
+                Default abort. Overridden by derived classes that can translate
+                this construct structurally; otherwise the emit is unwound to the
+                root and <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Fallback" /> takes over.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Perspective)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Qualified)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.FunctionCall)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.MeasureRef)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.BinaryOp)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.UnaryOp)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Searched)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.CaseExpr.Simple)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Paren)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.String)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Numeric)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Boolean)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Literal.Null)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Unknown)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.Error)">
+            <inheritdoc cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression.ColumnRef.Unqualified)" />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.EmitWithFallback(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression)">
             <summary>
-                Visits a Perspective.
-                Note: ModelObjects in perspectives are not visitable, so we don't traverse them.
+                Run the visitor over <paramref name="root" />, catching any
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.EmissionAbortException" /> raised at any depth and
+                returning <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpressionVisitor`1.Fallback" /> instead. The single place where
+                the abort signal is consumed — concrete Visit overloads should
+                propagate, not catch.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.SecurityModel)">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier">
             <summary>
-                Visits a SecurityModel.
-                Traverses Roles.
+                An identifier in Databricks SQL — bare or backtick-quoted.
+                Wraps a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan" /> and provides clean access to
+                the identifier value without quoting characters.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.Visit(TabularEditor.SemanticBridge.AbstractModel.Role)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Visits a Role.
+                An identifier in Databricks SQL — bare or backtick-quoted.
+                Wraps a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan" /> and provides clean access to
+                the identifier value without quoting characters.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.SemanticBridgeService">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier.Value">
             <summary>
-                Main entry point for cross-platform semantic model operations.
+                The identifier text with backtick quoting removed if present.
             </summary>
-            <remarks>
-                <para>
-                    <b>Access Pattern:</b> This service is accessed via <c>ScriptHost.SemanticBridge</c> in C# scripts.
-                    It is initialized once during application startup in the main routine
-                    and remains constant for the application lifetime.
-                </para>
-                <para>
-                    <b>Lifecycle:</b> Unlike <c>ScriptHost.Model</c> and <c>ScriptHost.Selected</c>, which are set per
-                    script execution, SemanticBridge is an application-level singleton service. This allows service state
-                    (such as the currently loaded MetricView) to persist across multiple script executions.
-                </para>
-                <para>
-                    <b>Feature Flag:</b> Requires the SemanticBridge feature flag to be enabled for the current license tier.
-                    Construction will fail with <see cref="T:System.InvalidOperationException" /> if the feature is not enabled.
-                </para>
-            </remarks>
-            <example>
-                Load and validate a MetricView in a C# script:
-                <code>
-            SemanticBridge.MetricView.Load(@"C:\path\to\metricview.yaml");
-            var diagnostics = SemanticBridge.MetricView.Validate();
-            foreach (var diag in diagnostics)
-            {
-                Output($"{diag.Severity}: {diag.Message}");
-            }
-            </code>
-                Import a MetricView into the current Tabular model:
-                <code>
-            SemanticBridge.MetricView.Load(@"C:\path\to\metricview.yaml");
-            var success = SemanticBridge.MetricView.ImportToTabular(
-                Model,
-                "databricks-host.cloud.databricks.com",
-                "/sql/1.0/warehouses/abc123",
-                out var diagnostics);
-            if (!success)
-            {
-                foreach (var error in diagnostics)
-                    Error($"Import failed: {error.Message}");
-            }
-            </code>
-            </example>
-            <seealso cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService" />
-            <seealso cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult" />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.SemanticBridgeService.MetricView">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlIdentifier.IsQuoted">
             <summary>
-                Gets the Databricks MetricView operations and state management service.
+                True if the identifier was backtick-quoted in the source.
             </summary>
-            <remarks>
-                This service manages a single MetricView instance at a time. Loading a new MetricView
-                replaces the current view. The view state persists across multiple script executions.
-            </remarks>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.SemanticBridgeService.#ctor">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan">
             <summary>
-                Create a new instance of the SemanticBridgeService.
-                Only intended to be called in the `TryCreate` method with feature
-                flag checks and wrapping in a `ServiceInitializationResult`.
+                A slice of original expression text. Start is inclusive, End is
+                exclusive. Carries a reference to the source so it is self-contained.
             </summary>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.SemanticBridgeService.TryCreate(TabularEditor.SemanticBridge.ISemanticBridgeFeatureCheck)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan.Text">
             <summary>
-                Attempts to create a SemanticBridgeService instance with structured error handling.
+                The raw text of this span in the original source.
             </summary>
-            <remarks>
-                <para>
-                    This factory method uses the Result pattern to provide explicit handling of different failure modes:
-                    - <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult.Success" />: Service initialized successfully
-                    - <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult.LicenseFailure" />: Feature not enabled for license
-                    - <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure" />: Unexpected initialization error
-                </para>
-                <para>
-                    The Result includes the service instance when successful, making it self-contained and easy to use.
-                </para>
-            </remarks>
-            <param name="featureCheck">Feature check implementation to determine if SemanticBridge is enabled</param>
-            <returns>
-                A <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult" /> containing either the initialized service instance
-                or detailed information about why initialization failed.
-            </returns>
-            <example>
-                Initialize service with explicit error handling:
-                <code>
-            var result = SemanticBridgeService.TryCreate(featureCheck);
-            
-            switch (result)
-            {
-                case ServiceInitializationResult.Success success:
-                    ScriptHost.SemanticBridge = success.Service;
-                    break;
-            
-                case ServiceInitializationResult.LicenseFailure license:
-                    // Expected failure - log if needed
-                    telemetry.TrackEvent("SemanticBridge.LicenseNotEnabled");
-                    break;
-            
-                case ServiceInitializationResult.InitializationFailure failure:
-                    // Unexpected failure - log with details
-                    telemetry.TrackException(failure.Exception, "SemanticBridge.InitializationFailure");
-                    break;
-            }
-            </code>
-            </example>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions">
             <summary>
-                Represents the result of attempting to initialize the SemanticBridge service.
-                This discriminated union provides structured error handling that distinguishes
-                between license restrictions, unexpected failures, and successful initialization.
+                Extension members for ANTLR tokens to support keyword-as-identifier handling.
             </summary>
             <remarks>
-                The Result pattern encapsulates both the success/failure state and the service instance,
-                allowing callers to handle different failure modes explicitly while maintaining access
-                to the initialized service when successful.
+                Databricks does not enforce reserved keywords by default, so keywords
+                like KEY, TABLE, SCHEMA can appear as identifiers in dotted-name contexts.
+                See: https://docs.databricks.com/aws/en/sql/language-manual/sql-ref-identifiers
             </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.Message">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.Keywords">
             <summary>
-            	Helpful information for the user about the success or failure of
-            	the service initialization, with instructions or details in the
-            	case of failure.
+                All keyword strings from the lexer grammar, case-insensitive.
+                Derived from the vocabulary at startup — no manual maintenance.
+                Used by formatting logic to decide whether a bare identifier
+                needs backtick quoting.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult.Success">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.get_IsIdentifierLike(Antlr4.Runtime.IToken)">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.&lt;G&gt;$D587DB271EE3F3900125BC918B0BB35F.IsIdentifierLike"/>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.get_CleanIdentifier(Antlr4.Runtime.IToken)">
+            <inheritdoc cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.&lt;G&gt;$D587DB271EE3F3900125BC918B0BB35F.CleanIdentifier"/>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.&lt;G&gt;$D587DB271EE3F3900125BC918B0BB35F.IsIdentifierLike">
             <summary>
-                Service was successfully initialized and is ready for use.
-                The service instance is available via pattern matching (see
-            	example)
+                True if the token is an identifier or a keyword that can serve
+                as an unquoted identifier in Databricks SQL.
             </summary>
-            <example>
-            var initResult = SemanticBridgeService.TryCreate(semanticBridgeFeatureCheck);
-            switch (initResult)
-            {
-            	case ServiceInitializationResult.Success success:
-            		var service = success.Service;
-            		// use `service` for work
-            		break;
-            	case ServiceInitializationResult.SomeOtherCase otherCase:
-            		//handle other case
-            		...
-            }
-            </example>
-            <param name="Service">The successfully initialized SemanticBridgeService instance</param>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.ServiceInitializationResult.Success.#ctor(TabularEditor.SemanticBridge.SemanticBridgeService)">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TokenExtensions.&lt;G&gt;$D587DB271EE3F3900125BC918B0BB35F.CleanIdentifier">
             <summary>
-                Service was successfully initialized and is ready for use.
-                The service instance is available via pattern matching (see
-            	example)
+                Returns the token's text with backtick quoting removed if present.
             </summary>
-            <example>
-            var initResult = SemanticBridgeService.TryCreate(semanticBridgeFeatureCheck);
-            switch (initResult)
-            {
-            	case ServiceInitializationResult.Success success:
-            		var service = success.Service;
-            		// use `service` for work
-            		break;
-            	case ServiceInitializationResult.SomeOtherCase otherCase:
-            		//handle other case
-            		...
-            }
-            </example>
-            <param name="Service">The successfully initialized SemanticBridgeService instance</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.Success.Service">
-            <summary>The successfully initialized SemanticBridgeService instance</summary>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.WhenClause">
+            <summary>
+                A condition/result pair inside a SQL CASE expression.
+            </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult.LicenseFailure">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.WhenClause.#ctor(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.SqlExpression,TabularEditor.SemanticBridge.Platforms.Databricks.Sql.TextSpan)">
             <summary>
-                Service initialization failed due to licensing restrictions.
-                The SemanticBridge feature is not enabled for the current license
-                tier and the user should reach out to support to acquire an
-                appropriate license.
+                A condition/result pair inside a SQL CASE expression.
             </summary>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1">
             <summary>
-                Service initialization failed due to an unexpected error beyond licensing.
-                This typically indicates a configuration or dependency resolution issue.
+            This class provides an empty implementation of <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1"/>,
+            which can be extended to create a visitor which only needs to handle a subset
+            of the available methods.
             </summary>
-            <param name="Message">Description of the initialization failure</param>
-            <param name="Exception">The underlying exception, if available</param>
+            <typeparam name="Result">The return type of the visit operation.</typeparam>
         </member>
-        <member name="M:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure.#ctor(System.String,System.Exception)">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitParse(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ParseContext)">
             <summary>
-                Service initialization failed due to an unexpected error beyond licensing.
-                This typically indicates a configuration or dependency resolution issue.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.parse"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
-            <param name="Message">Description of the initialization failure</param>
-            <param name="Exception">The underlying exception, if available</param>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure.Exception">
-            <summary>The underlying exception, if available</summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitOrExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.OrExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>orExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.IsSuccess">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitColumnRefExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ColumnRefExprContext)">
             <summary>
-                Indicates whether initialization was successful.
-                This convenience property allows simple boolean checks without pattern matching.
+            Visit a parse tree produced by the <c>columnRefExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitMeasureRefExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MeasureRefExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>measureRefExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitParenExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ParenExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>parenExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitSearchedCaseExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.SearchedCaseExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>searchedCaseExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitConcatExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ConcatExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>concatExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitSimpleCaseExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.SimpleCaseExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>simpleCaseExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
+            </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitNotExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.NotExprContext)">
+            <summary>
+            Visit a parse tree produced by the <c>notExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="T:TabularEditor.SemanticBridge.Strings">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitUnaryMinusExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.UnaryMinusExprContext)">
             <summary>
-              A strongly-typed resource class, for looking up localized strings, etc.
+            Visit a parse tree produced by the <c>unaryMinusExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.ResourceManager">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitAddExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.AddExprContext)">
             <summary>
-              Returns the cached ResourceManager instance used by this class.
+            Visit a parse tree produced by the <c>addExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Culture">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitLiteralExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.LiteralExprContext)">
             <summary>
-              Overrides the current thread's CurrentUICulture property for all
-              resource lookups using this strongly typed resource class.
+            Visit a parse tree produced by the <c>literalExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilder_AddFragment_Fragment_key_cannot_be_null_or_empty_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitCompExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.CompExprContext)">
             <summary>
-              Looks up a localized string similar to Fragment key cannot be null or empty..
+            Visit a parse tree produced by the <c>compExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilder_GetFragment_Fragment_with_key___0___is_not_of_type__1__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitFunctionCallExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.FunctionCallExprContext)">
             <summary>
-              Looks up a localized string similar to Fragment with key &apos;{0}&apos; is not of type {1}..
+            Visit a parse tree produced by the <c>functionCallExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilder_GetFragment_Fragment_with_key___0___not_found">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitMulExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MulExprContext)">
             <summary>
-              Looks up a localized string similar to Fragment with key &apos;{0}&apos; not found.
+            Visit a parse tree produced by the <c>mulExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilder_TryBuild_Model">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitUnaryPlusExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.UnaryPlusExprContext)">
             <summary>
-              Looks up a localized string similar to Model.
+            Visit a parse tree produced by the <c>unaryPlusExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilderVisitor_Visit_Could_not_parse_join_fields_for_join___0___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitAndExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.AndExprContext)">
             <summary>
-              Looks up a localized string similar to Could not parse join fields for join &apos;{0}&apos;..
+            Visit a parse tree produced by the <c>andExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilderVisitor_Visit_Join_expression_must_reference__source__table_for_fact_side__Got____0__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitWhenClause(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.WhenClauseContext)">
             <summary>
-              Looks up a localized string similar to Join expression must reference &apos;source&apos; table for fact side. Got: &apos;{0}&apos;.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.whenClause"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilderVisitor_Visit_Multiple_join_conditions_are_not_yet_supported__Join___0___has__1__conditions_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitFunctionCall(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.FunctionCallContext)">
             <summary>
-              Looks up a localized string similar to Multiple join conditions are not yet supported. Join &apos;{0}&apos; has {1} conditions..
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.functionCall"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelBuilderVisitor_Visit_We_do_not_currently_support_snowflake_joins__Join___0_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitMeasureRef(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MeasureRefContext)">
             <summary>
-              Looks up a localized string similar to We do not currently support snowflake joins. Join: {0}.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.measureRef"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelFragment_Build_Cannot_find_dimension_fragment_with_key___0___for_dimension_reference">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitArgList(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ArgListContext)">
             <summary>
-              Looks up a localized string similar to Cannot find dimension fragment with key &apos;{0}&apos; for dimension reference.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.argList"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelFragment_Build_Cannot_find_fact_fragment_with_key___0___for_dimension_reference">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitMultiDotColumn(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MultiDotColumnContext)">
             <summary>
-              Looks up a localized string similar to Cannot find fact fragment with key &apos;{0}&apos; for dimension reference.
+            Visit a parse tree produced by the <c>multiDotColumn</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.columnRef"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelFragment_Build_Cannot_find_left_field_fragment_with_key___0___for_dimension_reference">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitQualifiedColumn(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.QualifiedColumnContext)">
             <summary>
-              Looks up a localized string similar to Cannot find left field fragment with key &apos;{0}&apos; for dimension reference.
+            Visit a parse tree produced by the <c>qualifiedColumn</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.columnRef"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelFragment_Build_Cannot_find_relationship_fragment_for_dimension_reference">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitUnqualifiedColumn(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.UnqualifiedColumnContext)">
             <summary>
-              Looks up a localized string similar to Cannot find relationship fragment for dimension reference.
+            Visit a parse tree produced by the <c>unqualifiedColumn</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.columnRef"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelFragment_Build_Cannot_find_right_field_fragment_with_key___0___for_dimension_reference">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitIdentifier(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.IdentifierContext)">
             <summary>
-              Looks up a localized string similar to Cannot find right field fragment with key &apos;{0}&apos; for dimension reference.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.identifier"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelFragment_Build_Failed_to_add_dimension_reference___0_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitKeyword(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.KeywordContext)">
             <summary>
-              Looks up a localized string similar to Failed to add dimension reference: {0}.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.keyword"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <!-- Badly formed XML comment ignored for member "P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Untranslated_original_expression" -->
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_CalculatedMeasure_does_not_have_any_expressions_defined">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParserBaseVisitor`1.VisitLiteral(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.LiteralContext)">
             <summary>
-              Looks up a localized string similar to CalculatedMeasure &apos;{0}&apos; does not have any expressions defined..
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.literal"/>.
+            <para>
+            The default implementation returns the result of calling <see cref="M:Antlr4.Runtime.Tree.AbstractParseTreeVisitor`1.VisitChildren(Antlr4.Runtime.Tree.IRuleNode)"/>
+            on <paramref name="context"/>.
+            </para>
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_Cannot_visit_measure_without_a_current_table_context_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1">
             <summary>
-              Looks up a localized string similar to Cannot visit measure &apos;{0}&apos; without a current table context..
+            This interface defines a complete generic visitor for a parse tree produced
+            by <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser"/>.
             </summary>
+            <typeparam name="Result">The return type of the visit operation.</typeparam>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_DerivedField_could_not_be_translated">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitParse(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ParseContext)">
             <summary>
-              Looks up a localized string similar to DerivedField &apos;{0}&apos; contains a complex expression that could not be translated to DAX. The original expression has been preserved as a comment..
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.parse"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_DerivedField_no_expressions">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitOrExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.OrExprContext)">
             <summary>
-              Looks up a localized string similar to DerivedField &apos;{0}&apos; does not have any expressions defined..
+            Visit a parse tree produced by the <c>orExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_Dimension_table___0___does_not_exist_in_the_model_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitColumnRefExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ColumnRefExprContext)">
             <summary>
-              Looks up a localized string similar to Dimension table &apos;{0}&apos; does not exist in the model..
+            Visit a parse tree produced by the <c>columnRefExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_DimensionAttribute___0___references_source_field___1___which_does_not_exist_in_the_source_s_field_collection_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitMeasureRefExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MeasureRefExprContext)">
             <summary>
-              Looks up a localized string similar to DimensionAttribute &apos;{0}&apos; references source field &apos;{1}&apos; which does not exist in the source&apos;s field collection..
+            Visit a parse tree produced by the <c>measureRefExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_Mapping_CalculatedMeasure___0___to_Tabular_Model_is_not_yet_implemented_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitParenExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ParenExprContext)">
             <summary>
-              Looks up a localized string similar to Mapping CalculatedMeasure &apos;{0}&apos; to Tabular Model is not yet implemented..
+            Visit a parse tree produced by the <c>parenExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.AbstractModelToTabularVisitor_Visit_Measure_contains_untranslatable_expression_in_comment">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitSearchedCaseExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.SearchedCaseExprContext)">
             <summary>
-              Looks up a localized string similar to Measure &apos;{0}&apos; contains a complex expression that could not be translated to DAX. The original expression has been preserved as a comment..
+            Visit a parse tree produced by the <c>searchedCaseExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.ColumnReferenceParser_TryGetSingleColumn_Multiple_dots_in_column_reference_are_unsupported__multi_part_qualification__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitConcatExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ConcatExprContext)">
             <summary>
-              Looks up a localized string similar to Multiple dots in column reference are unsupported (multi-part qualification)..
+            Visit a parse tree produced by the <c>concatExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.ColumnReferenceSpan_ColumnReferenceSpan_Length_must_be_non_negative">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitSimpleCaseExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.SimpleCaseExprContext)">
             <summary>
-              Looks up a localized string similar to Length must be non-negative.
+            Visit a parse tree produced by the <c>simpleCaseExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.ColumnReferenceSpan_ColumnReferenceSpan_Start_position_must_be_non_negative">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitNotExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.NotExprContext)">
             <summary>
-              Looks up a localized string similar to Start position must be non-negative.
+            Visit a parse tree produced by the <c>notExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DatabricksMetricViewService_ThrowIfNoViewLoaded_No_MetricView_is_currently_loaded__Call_Load___or_Deserialize___first_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitUnaryMinusExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.UnaryMinusExprContext)">
             <summary>
-              Looks up a localized string similar to No MetricView is currently loaded. Call Load() or Deserialize() first..
+            Visit a parse tree produced by the <c>unaryMinusExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DataTypeExtensions_GetTomType_DataType___0___is_not_supported_for_mapping_to_Tabular_Model_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitAddExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.AddExprContext)">
             <summary>
-              Looks up a localized string similar to DataType &apos;{0}&apos; is not supported for mapping to Tabular Model..
+            Visit a parse tree produced by the <c>addExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_TranslatableMetricViewRules_Join___0___must_use_exactly_one_column_in_the__using__clause_for_the_MVP_implementation">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitLiteralExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.LiteralExprContext)">
             <summary>
-              Looks up a localized string similar to Join &apos;{0}&apos; must use exactly one column in the &apos;using&apos; clause for the MVP implementation.
+            Visit a parse tree produced by the <c>literalExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_TranslatableMetricViewRules_Measure___0___must_use_a_simple_aggregate_function__SUM__COUNT__MIN__MAX__AVG__for_the_MVP_implementation">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitCompExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.CompExprContext)">
             <summary>
-              Looks up a localized string similar to Measure &apos;{0}&apos; must use a simple aggregate function (SUM, COUNT, MIN, MAX, AVG) for the MVP implementation.
+            Visit a parse tree produced by the <c>compExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitFunctionCallExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.FunctionCallExprContext)">
             <summary>
-              Looks up a localized string similar to Join &apos;{0}&apos; must use a simple equality condition with table prefixes (e.g. &apos;source.column = dimension.column&apos;).
+            Visit a parse tree produced by the <c>functionCallExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Dimension___0___expr_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitMulExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MulExprContext)">
             <summary>
-              Looks up a localized string similar to Dimension &apos;{0}&apos; expr cannot be empty.
+            Visit a parse tree produced by the <c>mulExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Dimension_name_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitUnaryPlusExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.UnaryPlusExprContext)">
             <summary>
-              Looks up a localized string similar to Dimension name cannot be empty.
+            Visit a parse tree produced by the <c>unaryPlusExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Duplicate_dimension_name____0__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitAndExpr(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.AndExprContext)">
             <summary>
-              Looks up a localized string similar to Duplicate dimension name: &apos;{0}&apos;.
+            Visit a parse tree produced by the <c>andExpr</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.expr"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Duplicate_join_name____0__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitWhenClause(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.WhenClauseContext)">
             <summary>
-              Looks up a localized string similar to Duplicate join name: &apos;{0}&apos;.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.whenClause"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Duplicate_measure_name____0__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitFunctionCall(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.FunctionCallContext)">
             <summary>
-              Looks up a localized string similar to Duplicate measure name: &apos;{0}&apos;.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.functionCall"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Expressions">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitMeasureRef(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MeasureRefContext)">
             <summary>
-              Looks up a localized string similar to Expressions.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.measureRef"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Join___0___cannot_specify_both__on__and__using__clauses">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitArgList(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.ArgListContext)">
             <summary>
-              Looks up a localized string similar to Join &apos;{0}&apos; cannot specify both &apos;on&apos; and &apos;using&apos; clauses.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.argList"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Join___0___must_have_at_least_one_column_specified_in_the__using__clause">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitMultiDotColumn(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.MultiDotColumnContext)">
             <summary>
-              Looks up a localized string similar to Join &apos;{0}&apos; must have at least one column specified in the &apos;using&apos; clause.
+            Visit a parse tree produced by the <c>multiDotColumn</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.columnRef"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Join___0___must_specify_either__on__or__using__clause">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitQualifiedColumn(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.QualifiedColumnContext)">
             <summary>
-              Looks up a localized string similar to Join &apos;{0}&apos; must specify either &apos;on&apos; or &apos;using&apos; clause.
+            Visit a parse tree produced by the <c>qualifiedColumn</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.columnRef"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Join___0___source_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitUnqualifiedColumn(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.UnqualifiedColumnContext)">
             <summary>
-              Looks up a localized string similar to Join &apos;{0}&apos; source cannot be empty.
+            Visit a parse tree produced by the <c>unqualifiedColumn</c>
+            labeled alternative in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.columnRef"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Join_name_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitIdentifier(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.IdentifierContext)">
             <summary>
-              Looks up a localized string similar to Join name cannot be empty.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.identifier"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Measure___0___expr_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitKeyword(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.KeywordContext)">
             <summary>
-              Looks up a localized string similar to Measure &apos;{0}&apos; expr cannot be empty.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.keyword"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Measure_name_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.IDatabricksExprParserVisitor`1.VisitLiteral(TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.LiteralContext)">
             <summary>
-              Looks up a localized string similar to Measure name cannot be empty.
+            Visit a parse tree produced by <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Sql.DatabricksExprParser.literal"/>.
             </summary>
+            <param name="context">The parse tree.</param>
+            <return>The visitor result.</return>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Names">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.DatabricksTabularProvider">
             <summary>
-              Looks up a localized string similar to Names.
+                Renders <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem" /> sources to Power Query (M)
+                for inclusion in a Tabular partition. Mirrors the structure produced by
+                the Power BI Databricks connector:
+                <c>Databricks.Catalogs(host, path)</c> followed by
+                <c>Database / Schema / Object</c> navigation through the catalog tree.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DefaultValidationRules_ValidMetricViewRules_Structure">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.DatabricksTabularProvider.RenderM(TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem,TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.DatabricksTabularProvider.RenderM(TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksSourceSystem,TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatExtensions">
             <summary>
-              Looks up a localized string similar to Structure.
+                Translates an MV <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format" /> spec into a TOM
+                <c>FormatString</c> value. TOM FormatString uses VBA-style
+                FORMAT_STRING semantics (per the MDX FORMAT_STRING contents spec):
+                lowercase <c>mm</c> for month, lowercase <c>nn</c> for minute (to avoid
+                month/minute ambiguity), and VBA-style named formats
+                (<c>Long Date</c>, <c>Short Date</c>, <c>Long Time</c>,
+                <c>Short Time</c>) which render locale-aware at query time.
+                <para>
+                    The translator returns a tuple of the resulting format string and
+                    any diagnostics. Cleanly-translatable cases emit a precise string
+                    with no diagnostics. Imperfect cases emit a best-effort string and
+                    a <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.Mapping.MetricViewDiagnostics.FormatTranslationLossy(System.String)" />
+                    diagnostic. Cases without any sensible equivalent fall back to ISO
+                    date/time or empty string, with a diagnostic.
+                </para>
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_dimension_expr_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatExtensions.CurrencyPrefix(System.String)">
             <summary>
-              Looks up a localized string similar to dimension expr cannot be empty.
+                Maps an ISO 4217 currency code to a FormatString prefix. Single 
+                character symbols (e.g., <c>$</c>, <c>€</c>) embed directly;
+                multi-character symbols (e.g., <c>kr</c>, <c>R$</c>) and unknown
+                codes wrap in quotes with a trailing space to separate the label
+                from the digits.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_dimension_name_cannot_be_empty">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatExtensions.CurrencySymbolByIso">
             <summary>
-              Looks up a localized string similar to dimension name cannot be empty.
+                ISO 4217 code → currency symbol. Curated and static so the emitted
+                FormatString is identical on every OS. Deliberately NOT derived from
+                <see cref="T:System.Globalization.RegionInfo" /> / <see cref="T:System.Globalization.CultureInfo" />: that data is
+                ICU-backed on macOS/Linux but NLS-backed on Windows, and the two
+                disagree on the symbol and on culture-enumeration order (e.g. JPY
+                yields "￥" on Windows but "JP¥" on macOS). Codes not listed here
+                fall back to an ISO-code prefix in <see cref="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatExtensions.CurrencyPrefix(System.String)" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_join_name_cannot_be_empty">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatInference">
             <summary>
-              Looks up a localized string similar to join name cannot be empty.
+                Decides a field's or measure's <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DataType" /> from an MV
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format" /> spec, the field's existing DataType, key status,
+                and aggregation context. The two entry points encode the asymmetry
+                between field inference (which preserves an existing non-String type
+                and respects key precedence) and measure inference (which always
+                produces a concrete result type from the aggregation default).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_join_source_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatInference.FormatTypeOpinion(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format)">
             <summary>
-              Looks up a localized string similar to join source cannot be empty.
+                Format-driven DataType opinion shared by both field and measure
+                inference. Returns <c>null</c> when no format opinion applies
+                (null or unknown format).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_measure_expr_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatInference.InferFieldType(TabularEditor.SemanticBridge.AbstractModel.DataType,TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format,System.Boolean,System.Nullable{TabularEditor.SemanticBridge.AbstractModel.AggregationType})">
             <summary>
-              Looks up a localized string similar to measure expr cannot be empty.
+                Returns the DataType to apply to a field, or <c>null</c> when no
+                change is needed. Precedence: date-family format > key Integer >
+                non-date format > String-promotion-from-aggregation. Returning
+                <c>null</c> tells the caller to leave the field's current DataType
+                untouched (which preserves any earlier opinion, e.g., a key
+                Integer set by Visit(Join) or a format-driven type set by an
+                earlier dim visit).
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_measure_name_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.TabularSupport.FormatInference.InferMeasureType(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format,System.Nullable{TabularEditor.SemanticBridge.AbstractModel.AggregationType})">
             <summary>
-              Looks up a localized string similar to measure name cannot be empty.
+                Returns the DataType to apply to a measure. Format opinion wins
+                over aggregation default; when no format is declared, Count and
+                DistinctCount produce Integer measures and other aggregations
+                (or no aggregation — Calculated / Placeholder measures) produce
+                Decimal.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_Structure">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules">
             <summary>
-              Looks up a localized string similar to Structure.
+                Provides the default set of validation rules that match the current
+                implementation of MetricViewValidationVisitor.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DeserializationValidator_Rules_view_source_cannot_be_empty">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.KnownCurrencyCodes">
             <summary>
-              Looks up a localized string similar to view source cannot be empty.
+                Known ISO 4217 currency codes derived from OS locale data via
+                RegionInfo and based on .NET System.Globalization.
             </summary>
+            <remarks>
+                >
+                This is NOT a complete ISO 4217 table — it covers active currencies
+                that map to a real OS locale/region, but omits historical codes
+                (e.g. DEM) and non-country codes (e.g. XAU for gold, XDR for SDR).
+                Because of these limitations, this should ONLY be used for
+                warnings, never errors.
+            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Dimension_AddField_A_DimensionAttribute_with_the_same_name_already_exists_for_dimension__0___Field___1__">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.ValidMetricViewRules">
             <summary>
-              Looks up a localized string similar to A DimensionAttribute with the same name already exists for dimension {0}. Field: {1}..
+                List of rules used to validate a Metric View. Used in deserialization.
             </summary>
+            <remarks>
+                These rules are derived from a reading of public Databricks
+                documentation at time of Semantic Bridge development. There are no
+                guarantees that these are complete.
+            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionAttribute_Dimension_Cannot_access_dimension_before_it_is_set_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.ForType``1">
             <summary>
-              Looks up a localized string similar to Cannot access dimension before it is set..
+                Returns validation rules for the specified type.
             </summary>
+            <typeparam name="T">The type of object to get rules for.</typeparam>
+            <returns>ValidMetricViewRules that apply to the specified type.</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionFragment_AddField_Dimension_Attribute_key_cannot_be_null_or_empty_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.InCategory(System.String)">
             <summary>
-              Looks up a localized string similar to Dimension Attribute key cannot be null or empty..
+                Returns validation rules in the specified category.
             </summary>
+            <param name="category">The category of rules to get.</param>
+            <returns>ValidMetricViewRules that belong to the specified category.</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionFragment_Build_Primary_key_field___0___not_found_in_dimension_fields">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.DefaultValidationRules.GetByName(System.String)">
             <summary>
-              Looks up a localized string similar to Primary key field &apos;{0}&apos; not found in dimension fields.
+                Returns validation rules with the specified name.
             </summary>
+            <param name="name">The name of the rule to find.</param>
+            <returns>The rule with the specified name, or null if not found.</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_AddRelationship_Relationship_key_cannot_be_null_or_empty_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor">
             <summary>
-              Looks up a localized string similar to Relationship key cannot be null or empty..
+                Visitor that validates a MetricView object graph using configurable rules.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_AddRelationship_We_do_not_yet_support_multiple_relationships_for_a_single_dimension_reference__DimRef____0____existing_relationship____1__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.#ctor(System.Collections.Generic.List{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
             <summary>
-              Looks up a localized string similar to We do not yet support multiple relationships for a single dimension reference. DimRef: &apos;{0}&apos;; existing relationship: &apos;{1}&apos;.
+                Visitor that validates a MetricView object graph using configurable rules.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Build_Dimension___0___not_found_in_built_objects__Dimensions_must_be_built_before_dimension_references_">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Rules">
             <summary>
-              Looks up a localized string similar to Dimension &apos;{0}&apos; not found in built objects. Dimensions must be built before dimension references..
+                The validation rules which will be applied during traversal.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Build_Relationship___0___could_not_be_built_or_is_not_a_relationship_type">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.#ctor(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
             <summary>
-              Looks up a localized string similar to Relationship &apos;{0}&apos; could not be built or is not a relationship type.
+                Creates a new validation visitor with only the specified rules.
             </summary>
+            <param name="rules">The validation rules to apply</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_RelationshipKeys_No_relationship_key_has_been_set_yet_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.#ctor">
             <summary>
-              Looks up a localized string similar to No relationship key has been set yet..
+                Creates a new validation visitor with the default rules.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Ambiguity_resolving_dimension_reference__Dimension_key_already_assigned_as____0____but_relationship___1___refers_to___2__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.WithDefaultRules(System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule})">
             <summary>
-              Looks up a localized string similar to Ambiguity resolving dimension reference. Dimension key already assigned as: &apos;{0}&apos;, but relationship &apos;{1}&apos; refers to &apos;{2}&apos;.
+                Creates a new validation visitor with the default rules and optional extra rules.
             </summary>
+            <param name="extraRules">Extra rules to be used in traversal of the metric view</param>
+            <returns></returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Ambiguity_resolving_fact_reference__Fact_key_already_assigned_as____0____but_relationship___1___refers_to___2__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)">
             <summary>
-              Looks up a localized string similar to Ambiguity resolving fact reference. Fact key already assigned as: &apos;{0}&apos;, but relationship &apos;{1}&apos; refers to &apos;{2}&apos;.
+                Validates a MetricView object by applying all applicable rules and
+                traversing its structure.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Dimension_reference___0___not_found_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)">
             <summary>
-              Looks up a localized string similar to Dimension reference &apos;{0}&apos; not found..
+                Validates a MetricViewJoin object by applying all applicable rules and
+                traversing any child joins.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Fact_reference___0___not_found_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field)">
             <summary>
-              Looks up a localized string similar to Fact reference &apos;{0}&apos; not found..
+                Validates a MetricView Field object by applying all applicable rules.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Failed_to_find_dimension_for_relationship____0___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Visit(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)">
             <summary>
-              Looks up a localized string similar to Failed to find dimension for relationship, &apos;{0}&apos;..
+                Validates a MetricViewMeasure object by applying all applicable rules.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Failed_to_find_fact_for_relationship___0__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.ApplyRules``1(System.Collections.Generic.List{TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule{``0}},``0)">
             <summary>
-              Looks up a localized string similar to Failed to find fact for relationship &apos;{0}&apos;.
+                Applies all applicable validation rules to the target object.
+                A rule receives a read-only view of the validation context to prevent
+                accidental mutation.
             </summary>
+            <typeparam name="T">The type of object being validated</typeparam>
+            <param name="rules">type-appropriate rules to be applied to `target`</param>
+            <param name="target">The object to validate</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Failed_to_find_LHS_fact_for_relationship____0___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Reset(System.String)">
             <summary>
-              Looks up a localized string similar to Failed to find LHS fact for relationship, &apos;{0}&apos;..
+                Reset all state in the validation context to ensure idempotent operation.
+                Filters rules by version constraint against the view's spec version.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Failed_to_find_RHS_dimension_for_relationship____0___">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor._dimensionRules">
             <summary>
-              Looks up a localized string similar to Failed to find RHS dimension for relationship, &apos;{0}&apos;..
+                Legacy rule collection that lets <c>ValidationRule&lt;Dimension&gt;</c>
+                instances (produced by <c>MakeValidationRuleForDimension</c> or by
+                <c>MakeValidationRule&lt;Dimension&gt;</c>) fire against
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field" /> instances. Generic invariance prevents the
+                canonical <c>_fieldRules</c> filter from picking them up; this
+                collection bridges that gap until <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> is
+                removed.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Left_field_reference___0___not_found_in_relationship___1___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.ResetLegacyDimensionRules(System.String)">
             <summary>
-              Looks up a localized string similar to Left field reference &apos;{0}&apos; not found in relationship &apos;{1}&apos;..
+                Populates <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor._dimensionRules" /> from the same <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.Rules" />
+                source the canonical rule lists use, filtered by version constraint.
+                Called from <c>Reset</c>.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Missing_fact__dimension__and_relationship_details_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor.ApplyLegacyDimensionRules(TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field)">
             <summary>
-              Looks up a localized string similar to Missing fact, dimension, and relationship details..
+                Applies every <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor._dimensionRules" /> rule to a field. The
+                cast <c>(Dimension)field</c> is safe because every field is
+                constructed as a <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension" /> at runtime via
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View" />'s legacy factory. Called from
+                <c>Visit(Field)</c>.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Relationship_does_not_match_cardinality">
-             <summary>
-               Looks up a localized string similar to Relationship &apos;{0}&apos; does not match the cardinality of
-            dimension &apos;{1}&apos; and fact &apos;{2}&apos;.
-            Expected: 1 to many or many to 1, but got: {3} to {4}..
-             </summary>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext">
+            <summary>
+                Read-only view of validation context state for consumption by validation rules
+            </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Relationship_reference___0___not_found_">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.JoinNames">
             <summary>
-              Looks up a localized string similar to Relationship reference &apos;{0}&apos; not found..
+                Read-only view of join names seen during traversal for uniqueness validation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Right_field_reference___0___not_found_in_relationship___1___">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.FieldNames">
             <summary>
-              Looks up a localized string similar to Right field reference &apos;{0}&apos; not found in relationship &apos;{1}&apos;..
+                Read-only view of field names seen during traversal for
+                uniqueness validation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.DimensionReferenceFragment_Resolve_Warning__facts_should_be_LHS_of_relationships____0__">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.DimensionNames">
             <summary>
-              Looks up a localized string similar to Warning, facts should be LHS of relationships. &apos;{0}&apos;.
+                Legacy name for <see cref="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.FieldNames" />. Returns the same set;
+                retained as a default-implemented alias so external rule lambdas
+                that read <c>ctx.DimensionNames</c> still compile.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Fact_AddField_Cannot_add_the_same_field_twice___0_">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.MeasureNames">
             <summary>
-              Looks up a localized string similar to Cannot add the same field twice: {0}.
+                Read-only view of measure names seen during traversal for
+                uniqueness validation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Fact_AddField_Field_name_cannot_be_blank">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.MakeError(System.String,System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,System.String)">
             <summary>
-              Looks up a localized string similar to Field name cannot be blank.
+                Creates a diagnostic error message with the current path context.
+                Errors should indicate a problem that will prevent further correct
+                functioning.
             </summary>
+            <param name="code">unique identifying code</param>
+            <param name="message">The error message</param>
+            <param name="metricViewObject">The Metric View object currently being validated</param>
+            <param name="property">The property that has the error</param>
+            <returns>A DiagnosticMessage with Error severity</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_AddDimensionReference_Dimension_reference_key_cannot_be_null_or_empty_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.MakeWarning(System.String,System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,System.String)">
             <summary>
-              Looks up a localized string similar to Dimension reference key cannot be null or empty..
+                Creates a diagnostic warning message with the current path context.
+                Warnings should indicate a problem that deserves attention, but
+                doesn't necessarily prevent correct functioning.
             </summary>
+            <param name="code">unique identifying code</param>
+            <param name="message">The warning message</param>
+            <param name="metricViewObject">The Metric View object currently being validated</param>
+            <param name="property">The property that has the warning</param>
+            <returns>A DiagnosticMessage with Warning severity</returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_AddField_Fact_field_key_cannot_be_null_or_empty_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext">
             <summary>
-              Looks up a localized string similar to Fact field key cannot be null or empty..
+                Mutable validation context for internal validation orchestration.
+                Extends the read-only interface with mutation capabilities.
+                This interface is internal to restrict mutation operations to the
+                validation framework.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_AddMeasure_Measure_key_cannot_be_null_or_empty_">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.JoinNames">
             <summary>
-              Looks up a localized string similar to Measure key cannot be null or empty..
+                Mutable set of join names seen during traversal for uniqueness validation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_Build_All_measures_in_Fact_could_not_be_built_">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.FieldNames">
             <summary>
-              Looks up a localized string similar to All measures in Fact could not be built..
+                Mutable set of field names seen during traversal for
+                uniqueness validation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_Build_Could_not_find_sourcekey____0__">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.MeasureNames">
             <summary>
-              Looks up a localized string similar to Could not find sourcekey: &apos;{0}&apos;.
+                Mutable set of measure names seen during traversal for uniqueness validation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_Build_Field___0___not_a_field_type">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IMutableValidationContext.Reset">
             <summary>
-              Looks up a localized string similar to Field &apos;{0}&apos; not a field type.
+                Resets the context state for a new validation run, ensuring idempotent operation
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_Build_Measure___0___not_a_measure_type">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext">
             <summary>
-              Looks up a localized string similar to Measure &apos;{0}&apos; not a measure type.
+                Context object that maintains state during validation traversal of a
+                MetricView object graph.
+                External consumers can instantiate this but can only access mutation
+                capabilities within the same assembly.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_Build_Source___0___not_an_ISource_type">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext.MakeError(System.String,System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,System.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext.MakeWarning(System.String,System.String,TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,System.String)">
+            <inheritdoc />
+        </member>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationContext.TabularEditor#SemanticBridge#Platforms#Databricks#Validation#IMutableValidationContext#Reset">
+            <inheritdoc />
+        </member>
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1">
             <summary>
-              Looks up a localized string similar to Source &apos;{0}&apos; not an ISource type.
+                Generic implementation of a validation rule for a specific type of
+                MetricView object.
             </summary>
+            <typeparam name="T">The type of object this rule validates</typeparam>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_Build_Table_could_not_be_built__all_fields_resulted_in_errors_only_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.#ctor(System.String,System.String,System.Func{`0,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext,System.Collections.Generic.IEnumerable{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage}})">
             <summary>
-              Looks up a localized string similar to Table could not be built; all fields resulted in errors only..
+                Generic implementation of a validation rule for a specific type of
+                MetricView object.
             </summary>
+            <typeparam name="T">The type of object this rule validates</typeparam>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_ResolveField_FactFragment_ResolveFields__Field___0___has_a_different_TableLikeKey___1___than_expected___2___">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.TargetType">
             <summary>
-              Looks up a localized string similar to FactFragment.ResolveFields: Field &apos;{0}&apos; has a different TableLikeKey &apos;{1}&apos; than expected &apos;{2}&apos;..
+                Gets the type of object this rule is designed to validate.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_ResolveField_FactFragment_ResolveFields__Field___0___not_found_or_not_a_valid_field_fragment_">
+        <member name="P:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.VersionConstraint">
             <summary>
-              Looks up a localized string similar to FactFragment.ResolveFields: Field &apos;{0}&apos; not found or not a valid field fragment..
+                Version constraint for this rule. Defaults to <see cref="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.All" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_ResolveMeasures_FactFragment_ResolveMeasures__Measure___0___has_a_different_FactKey___1___than_expected___2___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.ValidationRule`1.Validate(TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewObject,TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext)">
             <summary>
-              Looks up a localized string similar to FactFragment.ResolveMeasures: Measure &apos;{0}&apos; has a different FactKey &apos;{1}&apos; than expected &apos;{2}&apos;..
+                Validates the target object if it matches the expected type.
             </summary>
+            <param name="target">The object to validate</param>
+            <param name="context">The read-only validation context</param>
+            <returns>
+                Collection of diagnostic messages for validation failures, or an
+                empty collection if validation passes
+            </returns>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FactFragment_ResolveMeasures_FactFragment_ResolveMeasures__Measure___0___not_found_or_not_a_measure_fragment_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint">
             <summary>
-              Looks up a localized string similar to FactFragment.ResolveMeasures: Measure &apos;{0}&apos; not found or not a measure fragment..
+                Declares which metric view spec versions a validation rule applies to.
+                Used by <see cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.MetricViewValidationVisitor" /> to filter rules at traversal time.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Field_Table_Cannot_access_table_before_it_is_set_">
+        <member name="F:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.All">
             <summary>
-              Looks up a localized string similar to Cannot access table before it is set..
+                Matches all versions. This is the default for rules that are not version-specific.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FieldFragment_Resolve__0__error__Field_not_associated_with_any_table_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.AtLeast">
             <summary>
-              Looks up a localized string similar to {0} error: Field not associated with any table..
+                Matches versions greater than or equal to the specified minimum.
+                Unknown versions are treated as greater than all known versions.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FieldFragment_Resolve__0__error__Multiple_tables_contain_field__Using___1____also_found__2__">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.AtLeast.#ctor(System.String)">
             <summary>
-              Looks up a localized string similar to {0} error: Multiple tables contain field. Using &apos;{1}&apos;, also found {2}&apos;.
+                Matches versions greater than or equal to the specified minimum.
+                Unknown versions are treated as greater than all known versions.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.FieldFragment_Resolve_Field___0___references_an_invalid_table_like_object___1___">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.Specific">
             <summary>
-              Looks up a localized string similar to Field &apos;{0}&apos; references an invalid table-like object &apos;{1}&apos;..
+                Matches only the explicitly listed versions.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.JoinExtensions_ExtractJoinOn_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.Specific.#ctor(System.Collections.Immutable.ImmutableArray{System.String})">
             <summary>
-              Looks up a localized string similar to Unsupported Join.On expression. We support &apos;source.field = dim.field&apos;. Got &apos;{0}&apos;..
+                Matches only the explicitly listed versions.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.JoinExtensions_ExtractJoinOn_Join_On_expression_cannot_be_empty">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.VersionConstraint.Matches(System.String)">
             <summary>
-              Looks up a localized string similar to Join.On expression cannot be empty.
+                Returns true if this constraint matches the given version string.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.JoinExtensions_Kind_Metric_View_join_must_be__Using__xor__On__">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.DefaultTabularProviders">
             <summary>
-              Looks up a localized string similar to Metric View join must be &apos;Using&apos; xor &apos;On&apos;..
+                Composition root for first-party
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry" /> entries. New source
+                platforms register their providers here; consumers wanting to override
+                a default re-register against the same source-system type after calling
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Tabular.DefaultTabularProviders.CreateDefault" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.JoinExtensions_ParseFields_Join_kind_is_invalid">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.DefaultTabularProviders.CreateDefault">
             <summary>
-              Looks up a localized string similar to Join kind is invalid.
+                Build a registry populated with every first-party Tabular provider.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.JoinExtensions_ParseFields_Using_joins_are_not_yet_supported_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax">
             <summary>
-              Looks up a localized string similar to Using joins are not yet supported..
+                Emits DAX for an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression" /> body. Structural
+                shapes the emitter recognizes (currently
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef" />) produce clean DAX;
+                anything else falls back through
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.AbstractExpressionEmitter`1" />'s abort path to
+                <see cref="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Fallback" />, which wraps the original source as a DAX
+                comment block via the source measure's <c>Expressions</c> dict.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.LicenseFailure_Message_The_SemanticBridge_feature_is_not_enabled_for_the_current_license_tier_and_the_user_should_reach_out_to_support_to_acquire_an_appropriate_license_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Emit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId,TabularEditor.TOMWrapper.Measure},System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,TabularEditor.TOMWrapper.Table},System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.TOMWrapper.Column},System.String)">
             <summary>
-              Looks up a localized string similar to The SemanticBridge feature is not enabled for the current license tier and the user should reach out to support to acquire an appropriate license..
+                Render <paramref name="body" /> to DAX in the context of
+                <paramref name="source" />.
+                <paramref name="resolveTomMeasure" /> returns the emitted
+                <see cref="T:TabularEditor.TOMWrapper.Measure" /> for a given <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId" />, or
+                <c>null</c> if the referenced measure has not been emitted yet;
+                <see cref="P:TabularEditor.TOMWrapper.Measure.DaxObjectName" /> is the canonical
+                bracketed-and-escaped DAX reference form.
+                <paramref name="resolveTomTable" /> is the analogous lookup for
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" /> →
+                <see cref="T:TabularEditor.TOMWrapper.Table" />, consulted by
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount" /> emission;
+                <see cref="P:TabularEditor.TOMWrapper.Table.DaxObjectName" /> is the canonical
+                single-quoted-and-escaped DAX table reference form.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Build_AggregationType_is_not_set_for_simple_measure">
-            <summary>
-              Looks up a localized string similar to AggregationType is not set for simple measure.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Fallback">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Build_Could_not_build_measure">
-            <summary>
-              Looks up a localized string similar to Could not build measure.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Build_Measure_cannot_have_both_Field_and_Expression__treating_as_a_simple_measure_">
-            <summary>
-              Looks up a localized string similar to Measure cannot have both Field and Expression; treating as a simple measure..
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.String)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Resolve_Measure___0___is_associated_with_multiple_Facts___1___Using_the_first_one___2__">
-            <summary>
-              Looks up a localized string similar to Measure &apos;{0}&apos; is associated with multiple Facts: {1}. Using the first one: {2}..
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Numeric)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Resolve_Measure___0___is_not_associated_with_any_Fact_">
-            <summary>
-              Looks up a localized string similar to Measure &apos;{0}&apos; is not associated with any Fact..
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Boolean)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Resolve_Measure_Resolve__Fact___0___does_not_exist_for_field___1___">
-            <summary>
-              Looks up a localized string similar to Measure.Resolve: Fact &apos;{0}&apos; does not exist for field &apos;{1}&apos;..
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Literal.Null)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MeasureFragment_Resolve_Measure_Resolve__Field___0___not_found_">
-            <summary>
-              Looks up a localized string similar to Measure.Resolve: Field &apos;{0}&apos; not found..
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.BinaryOp)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MetricViews_Deserialize_Failed_to_deserialize_MetricView_from_YAML_string">
-            <summary>
-              Looks up a localized string similar to Failed to deserialize MetricView from YAML string.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.Paren)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MetricViews_Load_Failed_to_load_MetricView_from__0_">
-            <summary>
-              Looks up a localized string similar to Failed to load MetricView from {0}.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MetricViewYamlDeserializer_Deserialize_Failed_to_deserialize_YAML_to_MetricView___0_">
-            <summary>
-              Looks up a localized string similar to Failed to deserialize YAML to MetricView: {0}.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Visit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.ColumnAggregation)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MetricViewYamlDeserializer_Deserialize_Failed_to_deserialize_YAML_to_MetricView__One_or_more_validation_errors_occurred_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Extensions.DataTypeExtensions.GetTomType(TabularEditor.SemanticBridge.AbstractModel.DataType)">
             <summary>
-              Looks up a localized string similar to Failed to deserialize YAML to MetricView: One or more validation errors occurred..
+                Maps Abstract Model DataType to Tabular Object Model DataType.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.MetricViewYamlDeserializer_Deserialize_Failed_to_validate_MetricView">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider">
             <summary>
-              Looks up a localized string similar to Failed to validate MetricView.
+                Non-generic facet of <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider`1" /> used
+                by <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry" /> for type-erased
+                dispatch. Providers should not declare this interface directly - derive
+                from <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderBase`1" />, which supplies
+                the non-generic dispatch by switching over <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource" /> and
+                calling the typed overloads on
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider`1" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_GetByPath_Attempted_dictionary_key_lookup_on_non_collection_type___0___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider.RenderM(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource)">
             <summary>
-              Looks up a localized string similar to Attempted dictionary key lookup on non-collection type &apos;{0}&apos;..
+                Render an M (Power Query) expression for <paramref name="source" />
+                against <paramref name="system" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_GetByPath_No_item_with_Name___0___found_in_collection_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider`1">
             <summary>
-              Looks up a localized string similar to No item with Name &apos;{0}&apos; found in collection..
+                Contract implemented by each source platform to render its sources into
+                Tabular-target M expressions. One implementation per concrete
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem" /> type; registered into
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry" /> at composition time.
             </summary>
+            <typeparam name="TSystem">
+                The concrete source-system type this provider handles.
+            </typeparam>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_GetByPath_Path_must_not_be_null_or_empty_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider`1.RenderM(`0,TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
             <summary>
-              Looks up a localized string similar to Path must not be null or empty..
+                Render M for a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QueryableSource" /> against
+                <paramref name="system" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_GetByPath_Property___0___not_found_on_type___1___">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider`1.RenderM(`0,TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
             <summary>
-              Looks up a localized string similar to Property &apos;{0}&apos; not found on type &apos;{1}&apos;..
+                Render M for a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.QuerySource" /> against
+                <paramref name="system" />.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_GetByPath_Property___0___on___1___is_null_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor">
             <summary>
-              Looks up a localized string similar to Property &apos;{0}&apos; on &apos;{1}&apos; is null..
+                Visitor that maps an abstract-model <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" /> to a Tabular
+                (TOM) <see cref="T:TabularEditor.TOMWrapper.Model" />. The source <c>Root</c>, target TOM
+                model, and <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry" /> are supplied at
+                construction; <c>Visit(Root)</c> drives the traversal and returns the
+                populated TOM model. <see cref="F:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor._currentTable" /> carries scoped context
+                from <c>Visit(Fact)</c> down to <c>Visit(QueryableSource)</c>; the
+                registry resolves M-rendering for each visited source.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_GetByPath_Unknown_path_segment_type___0_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.#ctor(TabularEditor.TOMWrapper.Model,TabularEditor.SemanticBridge.AbstractModel.Root,TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry)">
             <summary>
-              Looks up a localized string similar to Unknown path segment type: {0}.
+                Visitor that maps an abstract-model <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Root" /> to a Tabular
+                (TOM) <see cref="T:TabularEditor.TOMWrapper.Model" />. The source <c>Root</c>, target TOM
+                model, and <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry" /> are supplied at
+                construction; <c>Visit(Root)</c> drives the traversal and returns the
+                populated TOM model. <see cref="F:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor._currentTable" /> carries scoped context
+                from <c>Visit(Fact)</c> down to <c>Visit(QueryableSource)</c>; the
+                registry resolves M-rendering for each visited source.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_ParsePath_Expected_closing_bracket_after_quoted_key_in_path___0_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.ResolveTomTable(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId)">
             <summary>
-              Looks up a localized string similar to Expected closing bracket after quoted key in path: {0}.
+                Polymorphic <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" /> → <see cref="T:TabularEditor.TOMWrapper.Table" />
+                lookup. Routes <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FactId" /> to
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor._tablesByFactId" /> and <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.DimensionId" /> to
+                <see cref="F:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor._tablesByDimensionId" /> so AAST nodes carrying an
+                opaque <c>ITableId</c> (e.g.,
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.RowCount" />) can resolve uniformly
+                without caring which kind of table they target.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_ParsePath_Expected_single_quote_after_____in_path___0_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractModelToTabularVisitor.BuildWindowMeasureComment(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String,System.Collections.Generic.IReadOnlyList{TabularEditor.SemanticBridge.Orchestration.DiagnosticMessage})">
             <summary>
-              Looks up a localized string similar to Expected single quote after &apos;[&apos; in path: {0}.
+                Builds the inert DAX comment body for a measure whose source carried
+                an unsupported window spec (see #6347). Documents the original source
+                expression, the attempted (window-unaware) DAX translation when one is
+                available, and the window spec re-serialized as YAML. The whole body
+                is commented out so the measure returns BLANK until the user authors
+                it.
+                <para>
+                    <paramref name="emittedDax" /> is the result of
+                    <see cref="M:TabularEditor.SemanticBridge.Platforms.Tabular.Expression.AastToDax.Emit(TabularEditor.SemanticBridge.AbstractModel.AbstractExpression,TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId,TabularEditor.TOMWrapper.Measure},System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId,TabularEditor.TOMWrapper.Table},System.Func{TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,TabularEditor.TOMWrapper.Column},System.String)" />: clean DAX when the body translated
+                    structurally, otherwise a fallback comment block (signaled by an
+                    untranslated / no-expression diagnostic in
+                    <paramref name="emitDiagnostics" />). Only the former is surfaced
+                    as a translation; the latter collapses to "not available".
+                </para>
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_ParsePath_Unterminated_quoted_key_in_path___0_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics">
             <summary>
-              Looks up a localized string similar to Unterminated quoted key in path: {0}.
+                Diagnostic codes and factories emitted by the abstract→Tabular
+                visitor. Centralizes severity, code, message template, and path
+                shape so visitor methods stay focused on traversal. Messages are
+                inlined here for now; a future pass can lift them into the resource
+                file alongside the rest of the visitor's localized strings.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.PathExtensions_Path_Node_not_found_in_MetricView_graph_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.ReferenceFieldInvalidSource(TabularEditor.SemanticBridge.AbstractModel.ReferenceField,System.String)">
             <summary>
-              Looks up a localized string similar to Node not found in MetricView graph..
+                Emitted when a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.ReferenceField" />'s
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.ReferenceField.SourceFieldId" /> does not resolve to a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" /> in the current Root (id missing or
+                points at a non-source field type). The column is still emitted
+                with the diagnostic code itself as the <c>SourceColumn</c>
+                placeholder, so the model remains buildable and the broken
+                column surfaces at refresh time with an obviously identifiable
+                marker.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Build_Left_field___0___not_found_in_built_objects__Fields_must_be_built_before_relationships_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.DerivedFieldUntranslated(TabularEditor.SemanticBridge.AbstractModel.DerivedField,System.String)">
             <summary>
-              Looks up a localized string similar to Left field &apos;{0}&apos; not found in built objects. Fields must be built before relationships..
+                Emitted alongside a successfully-rendered <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" />
+                whose source-flavor expression could not be translated to DAX. The
+                original expression is preserved as a comment in the
+                <c>CalculatedColumn.Expression</c> (so the model is buildable and
+                round-trippable) and this diagnostic surfaces to the user that the
+                column will return blank values at refresh unless they author DAX
+                for it.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Build_LeftFieldKey_is_not_set">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.DerivedFieldNoExpressions(TabularEditor.SemanticBridge.AbstractModel.DerivedField,System.String)">
             <summary>
-              Looks up a localized string similar to LeftFieldKey is not set.
+                Emitted alongside a placeholder calculated column when a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.DerivedField" /> has no entries in its
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.DerivedField.Expressions" /> dictionary. The visitor
+                still emits the column (with a one-line "no source expression"
+                comment as the body) so the model is buildable and the field's
+                intended slot is visible; this diagnostic surfaces that the
+                column has no source SQL to translate and will return blank
+                values at refresh.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Build_Required_properties__cardinalities__join_kind__or_filter_direction__are_not_set">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.MeasureWindowUnsupported(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String)">
             <summary>
-              Looks up a localized string similar to Required properties (cardinalities, join kind, or filter direction) are not set.
+                Emitted when a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" /> carries an
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.UnsupportedWindowSpec" /> (a windowed /
+                cumulative / semiadditive spec from the source). The windowing
+                semantics aren't representable yet, so the measure is left inert with
+                a comment documenting the original SQL, the window-unaware DAX, and
+                the window spec. This diagnostic surfaces that the measure needs
+                manual authoring before it returns correct values.
+                TODO (#6347): remove once windowed measures translate natively.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Build_Right_field___0___not_found_in_built_objects__Fields_must_be_built_before_relationships_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.MeasureUnresolvedAtEmit(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.MeasureId)">
             <summary>
-              Looks up a localized string similar to Right field &apos;{0}&apos; not found in built objects. Fields must be built before relationships..
+                Emitted when a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" />'s AAST root is an
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef" /> whose
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.AbstractExpression.MeasureRef.Target" /> does not
+                resolve to a TOM-emitted measure name at emit time. The visitor
+                falls back to the platform-keyed <c>Expressions</c> dict (or
+                placeholder body if empty); this diagnostic surfaces the
+                resolution failure so the user can correct the upstream reference.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Build_RightFieldKey_is_not_set">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.TableUnresolvedAtEmit(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId)">
             <summary>
-              Looks up a localized string similar to RightFieldKey is not set.
+                Emitted when any AAST node carrying an <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ITableId" />
+                reference cannot resolve its target to a TOM-emitted table at
+                emit time. Tables are normally visited before measures so this
+                should not happen — surface it loudly when it does so the wiring
+                gap is identifiable. The visitor falls back to the platform-keyed
+                verbatim source.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Resolve__0____1___does_not_reference_a_valid_field_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.ColumnUnresolvedAtEmit(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId)">
             <summary>
-              Looks up a localized string similar to {0} &apos;{1}&apos; does not reference a valid field..
+                Emitted when any AAST node carrying a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId" />
+                reference cannot resolve its target to a TOM-emitted column at
+                emit time. Fields are normally visited before measures so this
+                should not happen — surface it loudly when it does so the wiring
+                gap is identifiable. The visitor falls back to the platform-keyed
+                verbatim source.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Resolve__0____1___is_missing_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.MeasureUntranslated(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String)">
             <summary>
-              Looks up a localized string similar to {0} &apos;{1}&apos; is missing..
+                Emitted alongside a successfully-rendered <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" />
+                whose source-flavor expression could not be translated to DAX. The
+                original expression is preserved as a comment in the
+                <c>Measure.Expression</c> (so the model is buildable and
+                round-trippable) and this diagnostic surfaces to the user that the
+                measure will return blank values until they author DAX for it.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Resolve__0__is_not_set_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.MeasureNoExpressions(TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated,System.String)">
             <summary>
-              Looks up a localized string similar to {0} is not set..
+                Emitted alongside a placeholder TOM measure when a
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated" /> has no entries in its
+                <see cref="P:TabularEditor.SemanticBridge.AbstractModel.Measure.Calculated.Expressions" /> dictionary. The
+                visitor still emits the measure (with a one-line "no source
+                expression" comment as the body) so the model is buildable and the
+                measure's intended slot is visible; this diagnostic surfaces that
+                the measure has no source SQL to translate and will return blank
+                values until DAX is authored.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Resolve_FilterDirection_is_not_set_and_could_not_be_inferred_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.RelationshipInvalidCardinality(TabularEditor.SemanticBridge.AbstractModel.Relationship)">
             <summary>
-              Looks up a localized string similar to FilterDirection is not set and could not be inferred..
+                Emitted when a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" /> has both sides set to
+                <c>Many</c> or both sides set to <c>One</c>. The relationship is
+                skipped so the model stays buildable; the diagnostic surfaces the
+                invalid pair so the user can correct one side.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.RelationshipFragment_Resolve_Relationship_must_be_between_a_fact_and_a_dimension_">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.Mapping.AbstractToTabularDiagnostics.RelationshipEndpointMissing(TabularEditor.SemanticBridge.AbstractModel.Relationship,TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId,System.String)">
             <summary>
-              Looks up a localized string similar to Relationship must be between a fact and a dimension..
+                Emitted when one of a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Relationship" />'s
+                <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.FieldId" /> endpoints does not resolve to a TOM column
+                (the field was never visited, or points at a <see cref="T:TabularEditor.SemanticBridge.AbstractModel.SourceField" />
+                with no table-side counterpart). The relationship is skipped so the
+                model stays buildable.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Root_CheckForDuplicateDimensionReference_Fact___0___already_has_a_reference_to_dimension___1___with_relationship_on_fields___2___and___3__">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderBase`1">
             <summary>
-              Looks up a localized string similar to Fact &apos;{0}&apos; already has a reference to dimension &apos;{1}&apos; with relationship on fields &apos;{2}&apos; and &apos;{3}&apos;.
+                Default base class for <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider`1" />
+                implementations. Provides "not supported" defaults for every per-source
+                overload — implementations override only the source types they support.
+                Centralises the non-generic dispatch over <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource" /> so
+                <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry" /> can resolve providers by
+                runtime <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem" /> type without per-platform
+                switching.
             </summary>
+            <typeparam name="TSystem">
+                The concrete source-system type this provider handles.
+            </typeparam>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Root_FindDimension_Dimension___0___not_found_in_Root_Dimensions">
-            <summary>
-              Looks up a localized string similar to Dimension &apos;{0}&apos; not found in Root.Dimensions.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderBase`1.RenderM(`0,TabularEditor.SemanticBridge.AbstractModel.QueryableSource)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Root_FindFact_Fact___0___not_found_in_Root_Facts">
-            <summary>
-              Looks up a localized string similar to Fact &apos;{0}&apos; not found in Root.Facts.
-            </summary>
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderBase`1.RenderM(`0,TabularEditor.SemanticBridge.AbstractModel.QuerySource)">
+            <inheritdoc />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Root_FindField_Field___0___not_found_in__1___Searched_TechnicalName_and_Name_">
+        <member name="T:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry">
             <summary>
-              Looks up a localized string similar to Field &apos;{0}&apos; not found in {1}. Searched TechnicalName and Name..
+                Registry of <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider" /> instances keyed by the
+                concrete <see cref="T:TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem" /> runtime type they handle. The
+                Abstract-to-Tabular visitor consults this registry to resolve
+                M-rendering for each source it visits; one entry per source platform.
             </summary>
+            <remarks>
+                Re-registering the same source system type replaces the prior
+                entry: the natural mechanism for consumer-side overrides of first-party
+                defaults supplied by <see cref="T:TabularEditor.SemanticBridge.Platforms.Tabular.DefaultTabularProviders" />.
+            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Root_ValidateRelationshipFields_Relationship_left_field___0___does_not_belong_to_fact___1___or_its_source">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry.Register``1(TabularEditor.SemanticBridge.Platforms.Tabular.ITabularSourceProvider{``0})">
             <summary>
-              Looks up a localized string similar to Relationship left field &apos;{0}&apos; does not belong to fact &apos;{1}&apos; or its source.
+                Register a typed provider for source-system type
+                <typeparamref name="T" />, replacing any prior registration for the
+                same type.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Root_ValidateRelationshipFields_Relationship_right_field___0___does_not_belong_to_dimension___1___or_its_source">
+        <member name="M:TabularEditor.SemanticBridge.Platforms.Tabular.TabularSourceProviderRegistry.RenderM(TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISourceSystem,TabularEditor.SemanticBridge.AbstractModel.Interfaces.ISource)">
             <summary>
-              Looks up a localized string similar to Relationship right field &apos;{0}&apos; does not belong to dimension &apos;{1}&apos; or its source.
+                Resolve a provider by the runtime type of <paramref name="system" />
+                and render M for <paramref name="source" />.
             </summary>
+            <exception cref="T:System.Collections.Generic.KeyNotFoundException">
+                Thrown when no provider is registered for <paramref name="system" />'s
+                runtime type.
+            </exception>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SemanticBridgeService_TryCreate_">
+        <member name="T:TabularEditor.SemanticBridge.SemanticBridgeService">
             <summary>
-              Looks up a localized string similar to Failed to initialize SemanticBridge service with an unexpected exception. See more details in the `Exception` property..
+                Main entry point for cross-platform semantic model operations.
             </summary>
+            <remarks>
+                <para>
+                    <b>Access Pattern:</b> This service is accessed via <c>ScriptHost.SemanticBridge</c> in C# scripts.
+                    It is initialized once during application startup in the main routine
+                    and remains constant for the application lifetime.
+                </para>
+                <para>
+                    <b>Lifecycle:</b> Unlike <c>ScriptHost.Model</c> and <c>ScriptHost.Selected</c>, which are set per
+                    script execution, SemanticBridge is an application-level singleton service. This allows service state
+                    (such as the currently loaded MetricView) to persist across multiple script executions.
+                </para>
+                <para>
+                    <b>Feature Flag:</b> Requires the SemanticBridge feature flag to be enabled for the current license tier.
+                    Construction will fail with <see cref="T:System.InvalidOperationException" /> if the feature is not enabled.
+                </para>
+            </remarks>
+            <example>
+                Load and validate a MetricView in a C# script:
+                <code>
+            SemanticBridge.MetricView.Load(@"C:\path\to\metricview.yaml");
+            var diagnostics = SemanticBridge.MetricView.Validate();
+            foreach (var diag in diagnostics)
+            {
+                Output($"{diag.Severity}: {diag.Message}");
+            }
+            </code>
+                Import a MetricView into the current Tabular model:
+                <code>
+            SemanticBridge.MetricView.Load(@"C:\path\to\metricview.yaml");
+            var success = SemanticBridge.MetricView.ImportToTabular(
+                Model,
+                "databricks-host.cloud.databricks.com",
+                "/sql/1.0/warehouses/abc123",
+                out var diagnostics);
+            if (!success)
+            {
+                foreach (var error in diagnostics)
+                    Error($"Import failed: {error.Message}");
+            }
+            </code>
+            </example>
+            <seealso cref="T:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService" />
+            <seealso cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult" />
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SemanticBridgeService_TryCreate_Feature_check_service_is_not_available__Maybe_you_are_running_it_outside_of_Tabular_Editor_3_">
+        <member name="P:TabularEditor.SemanticBridge.SemanticBridgeService.MetricView">
             <summary>
-              Looks up a localized string similar to Feature check service is not available. Maybe you are running it outside of Tabular Editor 3?.
+                Gets the Databricks MetricView operations and state management service.
             </summary>
+            <remarks>
+                This service manages a single MetricView instance at a time. Loading a new MetricView
+                replaces the current view. The view state persists across multiple script executions.
+            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SimpleMeasureExtensions_TryGenerateDax_AggregationType___0___is_not_supported_for_DAX_generation_">
+        <member name="M:TabularEditor.SemanticBridge.SemanticBridgeService.#ctor">
             <summary>
-              Looks up a localized string similar to AggregationType &apos;{0}&apos; is not supported for DAX generation..
+                Create a new instance of the SemanticBridgeService.
+                Only intended to be called in the `TryCreate` method with feature
+                flag checks and wrapping in a `ServiceInitializationResult`.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SimpleMeasureExtensions_TryGenerateDax_SimpleMeasure___0___references_column___1___which_does_not_exist_in_table___2___">
+        <member name="M:TabularEditor.SemanticBridge.SemanticBridgeService.TryCreate(TabularEditor.SemanticBridge.ISemanticBridgeFeatureCheck)">
             <summary>
-              Looks up a localized string similar to SimpleMeasure &apos;{0}&apos; references column &apos;{1}&apos; which does not exist in table &apos;{2}&apos;..
+                Attempts to create a SemanticBridgeService instance with structured error handling.
             </summary>
+            <remarks>
+                <para>
+                    This factory method uses the Result pattern to provide explicit handling of different failure modes:
+                    - <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult.Success" />: Service initialized successfully
+                    - <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult.LicenseFailure" />: Feature not enabled for license
+                    - <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure" />: Unexpected initialization error
+                </para>
+                <para>
+                    The Result includes the service instance when successful, making it self-contained and easy to use.
+                </para>
+            </remarks>
+            <param name="featureCheck">Feature check implementation to determine if SemanticBridge is enabled</param>
+            <returns>
+                A <see cref="T:TabularEditor.SemanticBridge.ServiceInitializationResult" /> containing either the initialized service instance
+                or detailed information about why initialization failed.
+            </returns>
+            <example>
+                Initialize service with explicit error handling:
+                <code>
+            var result = SemanticBridgeService.TryCreate(featureCheck);
+            
+            switch (result)
+            {
+                case ServiceInitializationResult.Success success:
+                    ScriptHost.SemanticBridge = success.Service;
+                    break;
+            
+                case ServiceInitializationResult.LicenseFailure license:
+                    // Expected failure - log if needed
+                    telemetry.TrackEvent("SemanticBridge.LicenseNotEnabled");
+                    break;
+            
+                case ServiceInitializationResult.InitializationFailure failure:
+                    // Unexpected failure - log with details
+                    telemetry.TrackException(failure.Exception, "SemanticBridge.InitializationFailure");
+                    break;
+            }
+            </code>
+            </example>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SimpleMeasureExtensions_TryGenerateDax_The_table_referenced_by_measure_does_not_exist_in_the_model">
+        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult">
             <summary>
-              Looks up a localized string similar to The table &apos;{0}&apos; referenced by measure &apos;{1}&apos; does not exist in the model.
+                Represents the result of attempting to initialize the SemanticBridge service.
+                This discriminated union provides structured error handling that distinguishes
+                between license restrictions, unexpected failures, and successful initialization.
             </summary>
+            <remarks>
+                The Result pattern encapsulates both the success/failure state and the service instance,
+                allowing callers to handle different failure modes explicitly while maintaining access
+                to the initialized service when successful.
+            </remarks>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SimpleRelationshipExtensions_TryCreateTomRelationship_Column___0___not_found_in_table___1___for_relationship___2___">
+        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.Message">
             <summary>
-              Looks up a localized string similar to Column &apos;{0}&apos; not found in table &apos;{1}&apos; for relationship &apos;{2}&apos;..
+            	Helpful information for the user about the success or failure of
+            	the service initialization, with instructions or details in the
+            	case of failure.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SimpleRelationshipExtensions_TryCreateTomRelationship_Relationship___0___has_invalid_cardinality_configuration__Expected_one_side_with_Many_and_one_side_with_One_cardinality_">
+        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult.Success">
             <summary>
-              Looks up a localized string similar to Relationship &apos;{0}&apos; has invalid cardinality configuration. Expected one side with Many and one side with One cardinality..
+                Service was successfully initialized and is ready for use.
+                The service instance is available via pattern matching (see
+            	example)
             </summary>
+            <example>
+            var initResult = SemanticBridgeService.TryCreate(semanticBridgeFeatureCheck);
+            switch (initResult)
+            {
+            	case ServiceInitializationResult.Success success:
+            		var service = success.Service;
+            		// use `service` for work
+            		break;
+            	case ServiceInitializationResult.SomeOtherCase otherCase:
+            		//handle other case
+            		...
+            }
+            </example>
+            <param name="Service">The successfully initialized SemanticBridgeService instance</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SourceFragment_AddField_Source_field_key_cannot_be_null_or_empty_">
+        <member name="M:TabularEditor.SemanticBridge.ServiceInitializationResult.Success.#ctor(TabularEditor.SemanticBridge.SemanticBridgeService)">
             <summary>
-              Looks up a localized string similar to Source field key cannot be null or empty..
+                Service was successfully initialized and is ready for use.
+                The service instance is available via pattern matching (see
+            	example)
             </summary>
+            <example>
+            var initResult = SemanticBridgeService.TryCreate(semanticBridgeFeatureCheck);
+            switch (initResult)
+            {
+            	case ServiceInitializationResult.Success success:
+            		var service = success.Service;
+            		// use `service` for work
+            		break;
+            	case ServiceInitializationResult.SomeOtherCase otherCase:
+            		//handle other case
+            		...
+            }
+            </example>
+            <param name="Service">The successfully initialized SemanticBridgeService instance</param>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.Success.Service">
+            <summary>The successfully initialized SemanticBridgeService instance</summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SourceFragment_Build_Could_not_build_source_system">
+        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult.LicenseFailure">
             <summary>
-              Looks up a localized string similar to Could not build source system.
+                Service initialization failed due to licensing restrictions.
+                The SemanticBridge feature is not enabled for the current license
+                tier and the user should reach out to support to acquire an
+                appropriate license.
             </summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.SourceFragment_Build_Source_fragment_has_no_valid_object_or_query_defined">
+        <member name="T:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure">
             <summary>
-              Looks up a localized string similar to Source fragment has no valid object or query defined..
+                Service initialization failed due to an unexpected error beyond licensing.
+                This typically indicates a configuration or dependency resolution issue.
             </summary>
+            <param name="Message">Description of the initialization failure</param>
+            <param name="Exception">The underlying exception, if available</param>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.Success_Message_">
+        <member name="M:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure.#ctor(System.String,System.Exception)">
             <summary>
-              Looks up a localized string similar to Service was successfully initialized and can be accessed through the `Success` record&apos;s `Service` property..
+                Service initialization failed due to an unexpected error beyond licensing.
+                This typically indicates a configuration or dependency resolution issue.
             </summary>
+            <param name="Message">Description of the initialization failure</param>
+            <param name="Exception">The underlying exception, if available</param>
+        </member>
+        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.InitializationFailure.Exception">
+            <summary>The underlying exception, if available</summary>
         </member>
-        <member name="P:TabularEditor.SemanticBridge.Strings.ValidationRule_Validate_Cannot_use_validation_rule_for__0__on_node_of__1__">
+        <member name="P:TabularEditor.SemanticBridge.ServiceInitializationResult.IsSuccess">
             <summary>
-              Looks up a localized string similar to Cannot use validation rule for {0} on node of {1}..
+                Indicates whether initialization was successful.
+                This convenience property allows simple boolean checks without pattern matching.
             </summary>
         </member>
         <member name="T:TabularEditor.SemanticBridge.Util.CollectionEquality">
@@ -4105,148 +7123,5 @@
                 of internal ordering.
             </remarks>
         </member>
-        <member name="T:System.Text.RegularExpressions.Generated.JoinOnRegex_0">
-            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the JoinOnRegex method.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.JoinOnRegex_0.Instance">
-            <summary>Cached, thread-safe singleton instance.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.JoinOnRegex_0.#ctor">
-            <summary>Initializes the instance.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.JoinOnRegex_0.RunnerFactory">
-            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.JoinOnRegex_0.RunnerFactory.CreateInstance">
-            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.JoinOnRegex_0.RunnerFactory.Runner">
-            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.JoinOnRegex_0.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
-            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.JoinOnRegex_0.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if a possible match was found; false if no more matches are possible.</returns>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.JoinOnRegex_0.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.SqlAggRegex_1">
-            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the SqlAggRegex method.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.SqlAggRegex_1.Instance">
-            <summary>Cached, thread-safe singleton instance.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlAggRegex_1.#ctor">
-            <summary>Initializes the instance.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.SqlAggRegex_1.RunnerFactory">
-            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlAggRegex_1.RunnerFactory.CreateInstance">
-            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.SqlAggRegex_1.RunnerFactory.Runner">
-            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlAggRegex_1.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
-            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlAggRegex_1.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if a possible match was found; false if no more matches are possible.</returns>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlAggRegex_1.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.DistinctCountRegex_2">
-            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the DistinctCountRegex method.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.Instance">
-            <summary>Cached, thread-safe singleton instance.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.#ctor">
-            <summary>Initializes the instance.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.RunnerFactory">
-            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.RunnerFactory.CreateInstance">
-            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.RunnerFactory.Runner">
-            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
-            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if a possible match was found; false if no more matches are possible.</returns>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.DistinctCountRegex_2.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.SqlObjectPattern_3">
-            <summary>Custom <see cref="T:System.Text.RegularExpressions.Regex"/>-derived type for the SqlObjectPattern method.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.Instance">
-            <summary>Cached, thread-safe singleton instance.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.#ctor">
-            <summary>Initializes the instance.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.RunnerFactory">
-            <summary>Provides a factory for creating <see cref="T:System.Text.RegularExpressions.RegexRunner"/> instances to be used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.RunnerFactory.CreateInstance">
-            <summary>Creates an instance of a <see cref="T:System.Text.RegularExpressions.RegexRunner"/> used by methods on <see cref="T:System.Text.RegularExpressions.Regex"/>.</summary>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.RunnerFactory.Runner">
-            <summary>Provides the runner that contains the custom logic implementing the specified regular expression.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.RunnerFactory.Runner.Scan(System.ReadOnlySpan{System.Char})">
-            <summary>Scan the <paramref name="inputSpan"/> starting from base.runtextstart for the next match.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.RunnerFactory.Runner.TryFindNextPossibleStartingPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Search <paramref name="inputSpan"/> starting from base.runtextpos for the next location a match could possibly start.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if a possible match was found; false if no more matches are possible.</returns>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.SqlObjectPattern_3.RunnerFactory.Runner.TryMatchAtCurrentPosition(System.ReadOnlySpan{System.Char})">
-            <summary>Determine whether <paramref name="inputSpan"/> at base.runtextpos is a match for the regular expression.</summary>
-            <param name="inputSpan">The text being scanned by the regular expression.</param>
-            <returns>true if the regular expression matches at the current position; otherwise, false.</returns>
-        </member>
-        <member name="T:System.Text.RegularExpressions.Generated.Utilities">
-            <summary>Helper methods used by generated <see cref="T:System.Text.RegularExpressions.Regex"/>-derived implementations.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_defaultTimeout">
-            <summary>Default timeout value set in <see cref="T:System.AppContext"/>, or <see cref="F:System.Text.RegularExpressions.Regex.InfiniteMatchTimeout"/> if none was set.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_hasTimeout">
-            <summary>Whether <see cref="F:System.Text.RegularExpressions.Generated.Utilities.s_defaultTimeout"/> is non-infinite.</summary>
-        </member>
-        <member name="M:System.Text.RegularExpressions.Generated.Utilities.IsWordChar(System.Char)">
-            <summary>Determines whether the character is part of the [\w] set.</summary>
-        </member>
-        <member name="F:System.Text.RegularExpressions.Generated.Utilities.s_asciiWordChars">
-            <summary>Supports searching for characters in or not in "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz".</summary>
-        </member>
     </members>
 </doc>
diff --git a/content/_apiSource/TOMWrapper.dll b/content/_apiSource/TOMWrapper.dll
index c6a9d32af..4b445df5d 100644
Binary files a/content/_apiSource/TOMWrapper.dll and b/content/_apiSource/TOMWrapper.dll differ
diff --git a/content/_apiSource/TOMWrapper.xml b/content/_apiSource/TOMWrapper.xml
index e7b5b25fd..29c8ce5a6 100644
--- a/content/_apiSource/TOMWrapper.xml
+++ b/content/_apiSource/TOMWrapper.xml
@@ -95,6 +95,37 @@
             CTOR - only called from static factory methods on the class
             </summary>
         </member>
+        <member name="T:TabularEditor.TOMWrapper.DatabaseInfo">
+            <summary>
+            Lightweight, read-only snapshot of a database on an Analysis Services / Power BI server,
+            sourced from the DBSCHEMA_CATALOGS DMV. Use this instead of enumerating
+            <see cref="P:Microsoft.AnalysisServices.Tabular.Server.Databases"/> when you only need name/ID/CL/modified-date, since the
+            TOM enumeration causes models to be swapped into memory on the server.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.DatabaseInfo.ID">
+            <summary>Server-assigned database identifier (DATABASE_ID).</summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.DatabaseInfo.Name">
+            <summary>Database (catalog) display name (CATALOG_NAME).</summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.DatabaseInfo.CompatibilityLevel">
+            <summary>Compatibility level of the database (COMPATIBILITY_LEVEL).</summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.DatabaseInfo.LastUpdate">
+            <summary>UTC timestamp of the last metadata modification (DATE_MODIFIED). Null when not requested.</summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.DatabaseInfo.Description">
+            <summary>Database description (DESCRIPTION). Null when not requested, empty string when set but empty.</summary>
+        </member>
+        <member name="M:TabularEditor.TOMWrapper.DatabaseInfo.GetDatabasesFromServer(Microsoft.AnalysisServices.Tabular.Server)">
+            <summary>
+            Returns the list of databases on the server by querying the DBSCHEMA_CATALOGS DMV.
+            Unlike enumerating <see cref="P:Microsoft.AnalysisServices.Tabular.Server.Databases"/>, this does not cause models to be
+            swapped into memory on the server (critical for the Power BI service, which may evict
+            other models to honor the implicit load).
+            </summary>
+        </member>
         <member name="M:TabularEditor.TOMWrapper.Utils.TabularDeployer.Deploy(Microsoft.AnalysisServices.Tabular.Database,System.String,System.String,TabularEditor.TOMWrapper.Utils.DeploymentOptions,System.Threading.CancellationToken)">
             <summary>
             Deploys the specified database to the specified target server and database ID, using the specified options.
@@ -107,6 +138,12 @@
             <param name="cancellationToken"></param>
             <returns></returns>
         </member>
+        <member name="M:TabularEditor.TOMWrapper.Utils.TabularDeployer.DetectRefreshPolicyChanges(Microsoft.AnalysisServices.Tabular.Model,Microsoft.AnalysisServices.Tabular.Model)">
+            <summary>
+            Compares RefreshPolicy expressions between source model and destination model.
+            Returns list of changes where SourceExpression or PollingExpression changed.
+            </summary>
+        </member>
         <member name="M:TabularEditor.TOMWrapper.Utils.TabularDeployer.TransformCreateOrReplaceTmsl(Newtonsoft.Json.Linq.JObject,Microsoft.AnalysisServices.Tabular.Database,Microsoft.AnalysisServices.Tabular.Database,TabularEditor.TOMWrapper.Utils.DeploymentOptions)">
             <summary>
             This method transforms a JObject representing a CreateOrReplace TMSL script, so that the script points
@@ -286,6 +323,33 @@
             not be deployed, they are stripped from the TMSL script.
             </summary>
         </member>
+        <member name="T:TabularEditor.TOMWrapper.Utils.RefreshPolicyChange">
+            <summary>
+            Represents a change detected in a table's RefreshPolicy expressions.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.TOMWrapper.Utils.RefreshPolicyChange.#ctor(System.String,System.Boolean,System.Boolean)">
+            <summary>
+            Represents a change detected in a table's RefreshPolicy expressions.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.TOMWrapper.Utils.RefreshPolicyChangeEventArgs">
+            <summary>
+            Event args for the RefreshPolicyChangePrompt callback, containing detected changes
+            and allowing the caller to approve or deny the deployment.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Utils.RefreshPolicyChangeEventArgs.Changes">
+            <summary>
+            List of tables with RefreshPolicy expression changes detected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Utils.RefreshPolicyChangeEventArgs.ApproveChanges">
+            <summary>
+            Set to true to approve deploying the changes (which will reset incremental refresh partitions).
+            Set to false or leave default to cancel the deployment.
+            </summary>
+        </member>
         <member name="M:TabularEditor.TOMWrapper.Utils.DaxDependencyHelper.Tokenize(TabularEditor.TOMWrapper.IDaxDependantObject)">
             <summary>
             Return a list of tokens representing the DAX expression on the current object.
@@ -611,6 +675,17 @@
             Removes all columns from the collection of related columns
             </summary>
         </member>
+        <member name="T:TabularEditor.TOMWrapper.SpecificObjectType">
+            <summary>
+            A more specific version of <see cref="T:TabularEditor.TOMWrapper.ObjectType" /> that maps directly to specific TOMWrapper types, which
+            all are creatable (i.e. they have a public static `CreateNew` method).
+            </summary>
+        </member>
+        <member name="F:TabularEditor.TOMWrapper.ObjectMetadata.SpecificObjectParent">
+            <summary>
+            A dictionary that specifies the parent <see cref="T:TabularEditor.TOMWrapper.ObjectType" /> of each individual <see cref="T:TabularEditor.TOMWrapper.SpecificObjectType" />.
+            </summary>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.AggregateFunction">
             <summary>
             Specifies the aggregate function to be used by reporting tools to summarize column values.
@@ -956,6 +1031,31 @@
             Enforces fallback. Uses DirectQuery unconditionally.
             </summary>
         </member>
+        <member name="T:TabularEditor.TOMWrapper.DirectLakeIndexingBehavior">
+            <summary>
+            Controls how the AnalysisServices engine builds and persists DirectLake specific indexes.
+            </summary><remarks>This enum is only supported when the compatibility level of the database is at Preview or above.</remarks>
+        </member>
+        <member name="F:TabularEditor.TOMWrapper.DirectLakeIndexingBehavior.Auto">
+            <summary>
+            The semantic model might build in-memory index during data load or query execution.
+            </summary>
+        </member>
+        <member name="F:TabularEditor.TOMWrapper.DirectLakeIndexingBehavior.Explicit">
+            <summary>
+            The semantic model will build and persist the index only when explicitly requested via a refresh indexes operation. Refresh types other than refresh indexes do not perform indexing.
+            </summary>
+        </member>
+        <member name="F:TabularEditor.TOMWrapper.DirectLakeIndexingBehavior.Full">
+            <summary>
+            The semantic model builds and persists indexes as part of refresh full, refresh calculate and refresh indexes operations.
+            </summary>
+        </member>
+        <member name="F:TabularEditor.TOMWrapper.DirectLakeIndexingBehavior.Default">
+            <summary>
+            Applies the semantic model default index building and persistence behavior.
+            </summary>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.EncodingHintType">
             <summary>
             Encoding hint to suggest whether a column should use hash encoding.
@@ -976,24 +1076,19 @@
             Value encoding
             </summary>
         </member>
-        <member name="T:TabularEditor.TOMWrapper.EvaluationBehavior">
+        <member name="T:TabularEditor.TOMWrapper.ExpressionContext">
             <summary>
-            Evaluation behavior for calculated column.
-            </summary><remarks>This enum is only supported when the compatibility level of the database is at Preview or above.</remarks>
-        </member>
-        <member name="F:TabularEditor.TOMWrapper.EvaluationBehavior.Automatic">
-            <summary>
-            Default value, used for backward compatibility. Maps to Static or Dynamic depending on the table properties.
-            </summary>
+            Expression Context for calculated column.
+            </summary><remarks>This enum is only supported when the compatibility level of the database is at 1705 or above.</remarks>
         </member>
-        <member name="F:TabularEditor.TOMWrapper.EvaluationBehavior.Static">
+        <member name="F:TabularEditor.TOMWrapper.ExpressionContext.Standard">
             <summary>
-            Evaluation is performed during processing and the result is materialized.
+            Expression uses only standard functions.
             </summary>
         </member>
-        <member name="F:TabularEditor.TOMWrapper.EvaluationBehavior.Dynamic">
+        <member name="F:TabularEditor.TOMWrapper.ExpressionContext.UserContext">
             <summary>
-            Evaluation is performed dynamically and the result is not materialized.
+            Expression can include user-context functions.
             </summary>
         </member>
         <member name="T:TabularEditor.TOMWrapper.ExpressionKind">
@@ -1071,29 +1166,29 @@
             Do not reference this member directly in your code. It supports the Analysis Services infrastructure.
             </summary>
         </member>
-        <member name="T:TabularEditor.TOMWrapper.IndexBuildingMode">
+        <member name="T:TabularEditor.TOMWrapper.IndexingBehavior">
             <summary>
-            Column index's building behavior.
+            Controls how the AnalysisServices engine builds and persists indexes.
             </summary><remarks>This enum is only supported when the compatibility level of the database is at Preview or above.</remarks>
         </member>
-        <member name="F:TabularEditor.TOMWrapper.IndexBuildingMode.Off">
+        <member name="F:TabularEditor.TOMWrapper.IndexingBehavior.Off">
             <summary>
-            Default behavior - the server will not build string column's suffix index
+            Indexing is disabled. The semantic model will not perform indexing during refresh operations.
             </summary>
         </member>
-        <member name="F:TabularEditor.TOMWrapper.IndexBuildingMode.Auto">
+        <member name="F:TabularEditor.TOMWrapper.IndexingBehavior.Auto">
             <summary>
-            The server will build but not persist string column's suffix index
+            The semantic model might build in-memory index during data load or query execution.
             </summary>
         </member>
-        <member name="F:TabularEditor.TOMWrapper.IndexBuildingMode.Explicit">
+        <member name="F:TabularEditor.TOMWrapper.IndexingBehavior.Explicit">
             <summary>
-            The server will build and persist string column's suffix index by RefreshIndex command
+            The semantic model will build and persist the index only when explicitly requested via a refresh indexes operation. Refresh types other than refresh indexes do not perform indexing.
             </summary>
         </member>
-        <member name="F:TabularEditor.TOMWrapper.IndexBuildingMode.Full">
+        <member name="F:TabularEditor.TOMWrapper.IndexingBehavior.Full">
             <summary>
-            The server will build and persist string column's suffix index by either RefreshRecalc, RefreshFull or RefreshIndex command
+            The semantic model builds and persists indexes as part of refresh full, refresh calculate and refresh indexes operations.
             </summary>
         </member>
         <member name="T:TabularEditor.TOMWrapper.MetadataCategory">
@@ -1426,6 +1521,11 @@
             Defragment the data in the specified table. As data is added to or removed from a table, the dictionaries of each column can become polluted with values that no longer exist in the actual column values. The defragment option will clean up the values in the dictionaries that are no longer used.
             </summary>
         </member>
+        <member name="F:TabularEditor.TOMWrapper.RefreshType.Indexes">
+            <summary>
+            Refresh indexes.
+            </summary><remarks>This value is only supported when the compatibility level of the database is at Preview or above.</remarks>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.RelationshipEndCardinality">
             <summary>
             An enumeration of possible values for defining cardinality on either side of a table relationship.
@@ -2040,10 +2140,10 @@
             The DAX expression that is evaluated for the calculated column.
             </summary>
         </member>
-        <member name="P:TabularEditor.TOMWrapper.CalculatedColumn.EvaluationBehavior">
+        <member name="P:TabularEditor.TOMWrapper.CalculatedColumn.ExpressionContext">
             <summary>
-            Evaluation behavior for calculated column.
-            </summary><remarks>This property is only supported when the compatibility level of the database is at Preview or above.</remarks>
+            Expression context for calculated column.
+            </summary><remarks>This property is only supported when the compatibility level of the database is at 1705 or above.</remarks>
         </member>
         <member name="M:TabularEditor.TOMWrapper.CalculatedColumn.CreateNew(TabularEditor.TOMWrapper.Table,System.String)">
             <summary>
@@ -2309,7 +2409,7 @@
             A tag that represents the lineage of the source for the object.
             </summary><remarks>This property is only supported when the compatibility level of the database is at 1550 or above.</remarks>
         </member>
-        <member name="P:TabularEditor.TOMWrapper.Column.StringIndex">
+        <member name="P:TabularEditor.TOMWrapper.Column.StringIndexingBehavior">
             <summary>
             This property allows building and persisting of string column's index. A column may use one of the following values: Off, Auto, Explicit or Full. Default value for the property is Auto. Setting it to Auto will build an index but not persist it. Setting it to Explicit will build and persist an index by running command RefreshIndex. Setting it to Full will build and persist an index by running either RefreshRecalc, RefreshFull or RefreshIndex command.
             </summary><remarks>This property is only supported when the compatibility level of the database is at Preview or above.</remarks>
@@ -2333,9 +2433,9 @@
             </summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Column.InPerspective">
-            <Summary>
+            <summary>
             Collection of perspectives in which this Column is visible.
-            </Summary>
+            </summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Column.TranslatedDescriptions">
             <summary>
@@ -2578,9 +2678,9 @@
             Sets the SourceLineageTag property of all objects in the collection at once.
             </summary>
         </member>
-        <member name="P:TabularEditor.TOMWrapper.ColumnCollection.StringIndex">
+        <member name="P:TabularEditor.TOMWrapper.ColumnCollection.StringIndexingBehavior">
             <summary>
-            Sets the StringIndex property of all objects in the collection at once.
+            Sets the StringIndexingBehavior property of all objects in the collection at once.
             </summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.ColumnCollection.SortByColumn">
@@ -2914,6 +3014,9 @@
             Deletes this column mapping from the calendar.
             </summary>
         </member>
+        <member name="M:TabularEditor.TOMWrapper.CalendarColumnGroup.OnPropertyChanged(System.String,System.Object,System.Object)">
+            <inheritdoc/>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.CalendarColumnGroupCollection">
             <summary>
             Collection class for CalendarColumnGroup. Provides convenient properties for setting a property on multiple objects at once.
@@ -3002,6 +3105,9 @@
             <returns>A string that represents the object. The format is either "(Unassigned)" if the primary column is null, or
             "<c>PrimaryColumn.DaxObjectName</c> (<c>TimeUnit</c>)" with the time unit formatted.</returns>
         </member>
+        <member name="M:TabularEditor.TOMWrapper.TimeUnitColumnAssociation.OnPropertyChanged(System.String,System.Object,System.Object)">
+            <inheritdoc/>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.TimeRelatedColumnGroup">
             <summary>
             Represents a group of columns that are related to time information.
@@ -3213,9 +3319,9 @@
             <summary>The parent table of the current Hierarchy.</summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Hierarchy.InPerspective">
-            <Summary>
+            <summary>
             Collection of perspectives in which this Hierarchy is visible.
-            </Summary>
+            </summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Hierarchy.TranslatedDescriptions">
             <summary>
@@ -3948,9 +4054,9 @@
             <summary>The parent table of the current Measure.</summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Measure.InPerspective">
-            <Summary>
+            <summary>
             Collection of perspectives in which this Measure is visible.
-            </Summary>
+            </summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Measure.TranslatedDescriptions">
             <summary>
@@ -4300,9 +4406,14 @@
         </member>
         <member name="P:TabularEditor.TOMWrapper.Model.MetadataAccessPolicy">
             <summary>
-            The policy that applies to the users with read permissions only and controls their access to various metadata elements.
+            The policy applies to users with read permissions only and controls their access to various metadata elements.
             </summary><remarks>This property is only supported when the compatibility level of the database is at 1703 or above.</remarks>
         </member>
+        <member name="P:TabularEditor.TOMWrapper.Model.DefaultDirectLakeIndexingBehavior">
+            <summary>
+            The default indexing behavior for Direct Lake.
+            </summary><remarks>This property is only supported when the compatibility level of the database is at Preview or above.</remarks>
+        </member>
         <member name="P:TabularEditor.TOMWrapper.Model.DefaultMeasure">
             <summary>
             A reference to a default measure.
@@ -5865,10 +5976,15 @@
             An indication whether the table is excluded from the automatic aggregations feature.
             </summary><remarks>This property is only supported when the compatibility level of the database is at 1572 or above.</remarks>
         </member>
+        <member name="P:TabularEditor.TOMWrapper.Table.DirectLakeIndexingBehavior">
+            <summary>
+            Table indexing behavior for Direct Lake.
+            </summary><remarks>This property is only supported when the compatibility level of the database is at Preview or above.</remarks>
+        </member>
         <member name="P:TabularEditor.TOMWrapper.Table.InPerspective">
-            <Summary>
+            <summary>
             Collection of perspectives in which this Table is visible.
-            </Summary>
+            </summary>
         </member>
         <member name="P:TabularEditor.TOMWrapper.Table.TranslatedDescriptions">
             <summary>
@@ -6280,6 +6396,11 @@
             Sets the ExcludeFromAutomaticAggregations property of all objects in the collection at once.
             </summary>
         </member>
+        <member name="P:TabularEditor.TOMWrapper.TableCollection.DirectLakeIndexingBehavior">
+            <summary>
+            Sets the DirectLakeIndexingBehavior property of all objects in the collection at once.
+            </summary>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.WindowsModelRoleMember">
             <summary>
             Represents an individual Windows user account or a Windows security group.
@@ -7428,6 +7549,12 @@
             <param name="column">The column to check</param>
             <returns>True if the column is in a time-related column group; otherwise, false</returns>
         </member>
+        <member name="M:TabularEditor.TOMWrapper.Calendar.OnPropertyChanging(System.String,System.Object,System.Boolean@,System.Boolean@)">
+            <inheritdoc/>
+        </member>
+        <member name="M:TabularEditor.TOMWrapper.Calendar.OnPropertyChanged(System.String,System.Object,System.Object)">
+            <inheritdoc/>
+        </member>
         <member name="M:TabularEditor.TOMWrapper.Calendar.MoveTo(TabularEditor.TOMWrapper.Table)">
             <summary>
             Moves this calendar to a different table by deleting it and recreating it on the target table.
@@ -7498,6 +7625,9 @@
             clicked.
             </summary>
         </member>
+        <member name="E:TabularEditor.TOMWrapper.CalendarCollection.PropertyChanged">
+            <inheritdoc/>
+        </member>
         <member name="P:TabularEditor.TOMWrapper.CalculatedTable.Expression">
             <summary>
             The Expression of this Calculated Table.
@@ -8271,6 +8401,13 @@
             </summary>
             <returns></returns>
         </member>
+        <member name="P:TabularEditor.TOMWrapper.TabularModelHandler.Version">
+            <summary>
+            -1 indicates that the TabularModelHandler is not connected, i.e. the TOM.Database object
+            does not have a connection to a TOM.Server object. Any other value indicates connection
+            (the value itself is tracked by the server).
+            </summary>
+        </member>
         <member name="M:TabularEditor.TOMWrapper.TabularModelHandler.BeginUpdate(System.String,TabularEditor.TOMWrapper.Undo.UndoGroup)">
             <summary>
             Begins a batch update
@@ -8441,6 +8578,16 @@
             When this is set to true, the TOMWrapper will not allow you to create DirectLake partitions.
             </summary>
         </member>
+        <member name="P:TabularEditor.TOMWrapper.TabularModelHandlerSettings.SynchronousSemanticAnalysisAfterRollback">
+            <summary>
+            When true, <see cref="M:TabularEditor.TOMWrapper.TabularModelHandler.EndUpdate(System.Boolean,System.Boolean,System.Boolean)"/> and <see cref="M:TabularEditor.TOMWrapper.TabularModelHandler.EndUpdateAll(System.Boolean)"/> synchronously runs and waits for a full
+            semantic re-analysis before returning, so subsequent mutations see a consistent
+            dependency graph (e.g. auto-fixup on a rename will correctly find DAX references to
+            the renamed object). The default (false) preserves async UI behaviour where the slight
+            delay before the analysis settles is acceptable; the CLI sets this to true so a
+            follow-up command never observes mid-rebuild state.
+            </summary>
+        </member>
         <member name="T:TabularEditor.TOMWrapper.TabularNamedObject">
             <summary>
             A TabularObject is a wrapper for the Microsoft.AnalysisServices.Tabular.NamedMetadataObject class.
@@ -8732,6 +8879,36 @@
             Returns true if no changes have been done relative to the last checkpoint set.
             </summary>
         </member>
+        <member name="P:TabularEditor.TOMWrapper.Undo.UndoManager.UndoSize">
+            <summary>
+            The number of items in the UndoStack including batch action begin/end markers
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Undo.UndoManager.UndoActions">
+            <summary>
+            The number of atomic actions in the UndoStack (doesn't include batch action begin/end markers)
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Undo.UndoManager.UndoSteps">
+            <summary>
+            The number of steps in the UndoStack. This only counts actions at the root level (i.e. a batch action is only counted once, regardless of how many actions is inside the batch)
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Undo.UndoManager.RedoSize">
+            <summary>
+            The number of items in the RedoStack including batch action begin/end markers
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Undo.UndoManager.RedoActions">
+            <summary>
+            The number of atomic actions in the RedoStack (doesn't include batch action begin/end markers)
+            </summary>
+        </member>
+        <member name="P:TabularEditor.TOMWrapper.Undo.UndoManager.RedoSteps">
+            <summary>
+            The number of steps in the RedoStack. This only counts actions at the root level (i.e. a batch action is only counted once, regardless of how many actions is inside the batch)
+            </summary>
+        </member>
         <member name="M:TabularEditor.TOMWrapper.Undo.UndoManager.Rollback(System.Boolean)">
             <summary>
             Rolls back all changes done to the model.
@@ -9049,6 +9226,11 @@
             {0}.
              </summary>
         </member>
+        <member name="P:TabularEditor.LocalizableStrings.UnableToQueryDatabasesFromServer">
+            <summary>
+              Looks up a localized string similar to Unable to query databases from server: {0}.
+            </summary>
+        </member>
         <member name="T:TabularEditor.NonLocalizableStrings">
             <summary>
               A strongly-typed resource class, for looking up localized strings, etc.
@@ -9611,6 +9793,12 @@
             <returns></returns>
             <exception cref="T:System.ArgumentException"></exception>
         </member>
+        <member name="M:TabularEditor.TabularNamedObjectExtension.GetObjectId(TabularEditor.TOMWrapper.TabularNamedObject)">
+            <summary>
+            Returns the server-assigned object ID of the underlying TOM metadata object,
+            or <c>null</c> if no ID has been assigned (e.g. the model is not connected to a server).
+            </summary>
+        </member>
         <member name="T:TabularEditor.XmlaResultExtension">
             <summary>
             Extension methods for <see cref="T:Microsoft.AnalysisServices.XmlaResultCollection"/>
diff --git a/content/_apiSource/TabularEditor3.Shared.dll b/content/_apiSource/TabularEditor3.Shared.dll
index 2085564f7..b52d94e0d 100644
Binary files a/content/_apiSource/TabularEditor3.Shared.dll and b/content/_apiSource/TabularEditor3.Shared.dll differ
diff --git a/content/_apiSource/TabularEditor3.Shared.xml b/content/_apiSource/TabularEditor3.Shared.xml
index 0b8594c6f..4e5308c94 100644
--- a/content/_apiSource/TabularEditor3.Shared.xml
+++ b/content/_apiSource/TabularEditor3.Shared.xml
@@ -82,6 +82,233 @@
             <param name="input"></param>
             <returns></returns>
         </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.AIChatCSharpArtifact.IsSafe">
+            <summary>Whether the script is considered safe (no #r directives and only safe namespaces).</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.AIChatCSharpArtifact.HasReferenceDirective">
+            <summary>Whether the script contains #r (reference) directives.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.AIChatCSharpArtifact.UnsafeNamespaces">
+            <summary>List of namespaces used that are not in the safe list.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.AIChatCSharpArtifact.SafetyWarning">
+            <summary>Human-readable warning message for unsafe scripts.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.AI.ConsentResult">
+            <summary>
+            The result of a consent request.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.ConsentResult.Granted">
+            <summary>Whether consent was granted.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.ConsentResult.Duration">
+            <summary>The duration for which consent was granted.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.ConsentResult.Denied">
+            <summary>Creates a denied result.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.ConsentResult.Grant(TabularEditor.Shared.Contracts.AI.ConsentDuration)">
+            <summary>Creates a granted result with specified duration.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.AI.ConsentDuration">
+            <summary>
+            Duration options for consent.
+            </summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Contracts.AI.ConsentDuration.Denied">
+            <summary>Consent was denied.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Contracts.AI.ConsentDuration.ThisTime">
+            <summary>Allow for this single request only.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Contracts.AI.ConsentDuration.ThisSession">
+            <summary>Allow for the remainder of this session.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Contracts.AI.ConsentDuration.ForThisModel">
+            <summary>Allow for this specific model.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Contracts.AI.ConsentDuration.Always">
+            <summary>Always allow (update preference).</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.AI.IAIConsentService">
+            <summary>
+            Service for managing user consent for AI data sharing.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IAIConsentService.CheckOrRequestConsentAsync(TabularEditor.Shared.Services.AI.ConsentType,System.String)">
+            <summary>
+            Checks if consent is already granted for the specified type, or requests it from the user.
+            </summary>
+            <param name="consentType">The type of data being shared.</param>
+            <param name="context">A description of what data will be shared (for the consent dialog).</param>
+            <returns>The consent result.</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IAIConsentService.ClearTurnConsent">
+            <summary>
+            Clears turn-scoped consents. Call this when a turn completes so that
+            one-time ("Allow") consents do not carry over to the next turn.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.GetScriptViewById(System.Int32)">
+            <summary>
+            Gets the script handle for an existing document by its ID.
+            Returns null if the document doesn't exist or is not a script view.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.ReplaceScriptContent(System.Object,System.String)">
+            <summary>
+            Replaces the content of an existing script view.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.ShowToolCallProgress(System.String)">
+            <summary>
+            Shows a tool call progress indicator in the UI (bottom of chat).
+            </summary>
+            <param name="toolName">The name of the tool being executed.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.HideToolCallProgress">
+            <summary>
+            Hides the tool call progress indicator (bottom of chat).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.GetToolCallMarker(System.String,System.String,System.String,System.String)">
+            <summary>
+            Gets a tool call marker tag that can be injected into the message stream.
+            This allows tool calls to appear inline in the conversation history.
+            </summary>
+            <param name="toolName">The internal tool name (e.g., "execute_dax_query").</param>
+            <param name="callId">Unique identifier for the tool call (used for completion updates).</param>
+            <param name="displayName">User-friendly display name for the tool.</param>
+            <param name="details">Optional details to show in tooltip (e.g., the DAX query being executed).</param>
+            <returns>A marker string like &lt;toolcall tool="..." id="..." display="..." details="..."/&gt;</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.MarkToolCallComplete(System.String)">
+            <summary>
+            Marks a tool call as complete in the UI, stopping the animation and showing "Done!".
+            </summary>
+            <param name="callId">The call ID of the tool call to mark complete.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.ShowConsentRequest(System.String,System.String,System.String,System.Collections.Generic.IList{TabularEditor.Shared.Contracts.AI.ConsentOption})">
+            <summary>
+            Shows a consent request in the chat UI.
+            </summary>
+            <param name="requestId">Unique identifier for this consent request.</param>
+            <param name="title">The title of the consent request.</param>
+            <param name="message">The message explaining what consent is being requested.</param>
+            <param name="options">The available consent options.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.RemoveConsentRequest(System.String)">
+            <summary>
+            Removes a consent request from the chat UI (after user responds or on timeout).
+            </summary>
+            <param name="requestId">The request ID to remove.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.SetAvailableSkills(System.Collections.Generic.IList{TabularEditor.Shared.Contracts.AI.SkillInfo})">
+            <summary>
+            Sets the available custom instructions for the /instruction-id autocomplete popup.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.UpdateContextUsage(System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32,System.Int32)">
+            <summary>
+            Updates the context window usage indicator in the UI.
+            </summary>
+            <param name="usedTokens">Total tokens used so far (input + output).</param>
+            <param name="maxTokens">Maximum context window size.</param>
+            <param name="inputTokens">Input tokens from the latest API call (context pressure).</param>
+            <param name="outputTokens">Accumulated output tokens this turn (context pressure).</param>
+            <param name="cachedTokens">Input tokens read from prompt cache (context pressure).</param>
+            <param name="cacheCreationTokens">Input tokens used to create cache entries (context pressure).</param>
+            <param name="billedInputTokens">Cumulative input tokens billed across all API calls.</param>
+            <param name="billedOutputTokens">Cumulative output tokens billed across all API calls.</param>
+            <param name="billedCachedTokens">Cumulative cached input tokens across all API calls.</param>
+            <param name="billedCacheCreationTokens">Cumulative cache creation tokens across all API calls.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.SetDbConnected(System.Boolean)">
+            <summary>
+            Pushes the current database connection state to the chat UI.
+            When not connected, DAX artifact "Execute" buttons are disabled.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatInterop.NavigateToObjectReference(System.String)">
+            <summary>
+            Navigates to the TOM object referenced by the given string in the TOM Explorer.
+            </summary>
+            <param name="reference">The object reference (e.g., "Sales", "[Total Amount]", "Sales[Amount]").</param>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.AI.SkillInfo">
+            <summary>
+            Represents a custom instruction available for explicit invocation via /instruction-id.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.SkillInfo.Id">
+            <summary>The unique skill identifier (used as /skill-id).</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.SkillInfo.Name">
+            <summary>The display name of the skill.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.SkillInfo.Description">
+            <summary>Optional description shown in the autocomplete popup.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.AI.ConsentOption">
+            <summary>
+            Represents an option in a consent request.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.ConsentOption.Label">
+            <summary>The display label for the option.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.ConsentOption.Value">
+            <summary>The value returned when this option is selected.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Contracts.AI.ConsentOption.IsPrimary">
+            <summary>Whether this is the primary/recommended option.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatService.ConfigureConsent(System.Func{TabularEditor.Shared.Services.AI.AIConsentPreferences},System.Action,System.Func{System.String},System.Func{TabularEditor.Shared.Services.AI.ModelAIConsentState},System.Action{TabularEditor.Shared.Services.AI.ModelAIConsentState},System.Func{TabularEditor.Shared.Services.AI.ConsentType,System.String,System.Threading.Tasks.Task{TabularEditor.Shared.Contracts.AI.ConsentResult}})">
+            <summary>
+            Configures the consent system with callbacks for preferences and UI.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatService.SetDocumentAccessProvider(TabularEditor.Shared.Services.AI.IDocumentAccessProvider)">
+            <summary>
+            Sets the document access provider for AI tools to access open documents.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatService.SetBpaAnalyzer(TabularEditor.Shared.BPA.Analyzer)">
+            <summary>
+            Sets the BPA analyzer for AI tools.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatService.StopGeneration">
+            <summary>
+            Stops the current generation/response in progress.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IChatService.PushAvailableSkills(TabularEditor.Shared.Contracts.AI.IChatInterop)">
+            <summary>
+            Re-pushes available skills to the chat interop (call after WebView is ready).
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.AI.IMacroProvider">
+            <summary>
+            Provides read-only access to the user's macro library for AI tools.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.AI.IMacroProvider.GetMacros">
+            <summary>
+            Gets the current list of macros.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Contracts.UIAction">
+            <summary>
+            Represents a UI action that the AI should be able to request, such as launching the "New model dialog", or the "Preferences" dialog.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Contracts.UIAction.#ctor(System.String,System.Action,System.Nullable{TabularEditor.Shared.Contracts.CommonAction})">
+            <summary>
+            Represents a UI action that the AI should be able to request, such as launching the "New model dialog", or the "Preferences" dialog.
+            </summary>
+        </member>
         <member name="M:TabularEditor.Shared.FormHelper.GetActiveForm">
             <summary>
             Form.ActiveForm is null when Tabular Editor does not have focus (this can happen for example when debugging,
@@ -95,12 +322,41 @@
             Contains Azure AD client IDs and scopes used for authentication.
             </summary>
         </member>
+        <member name="F:TabularEditor.Shared.Infrastructure.AuthenticationConstants.AasScope">
+            <summary>Azure Analysis Services scope pattern.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Infrastructure.AuthenticationConstants.DefaultPowerBiScope">
+            <summary>Default Power BI / Fabric XMLA scope (commercial cloud).</summary>
+        </member>
         <member name="M:TabularEditor.Shared.Infrastructure.AuthenticationConstants.GetPowerBiScopes(System.String)">
             <summary>
             Gets the Power BI scopes based on the Power BI REST API endpoint URL.
             Different cloud environments (commercial, government, Germany, China) require different scopes.
             </summary>
         </member>
+        <member name="M:TabularEditor.Shared.Infrastructure.AuthenticationConstants.GetScopeForServer(System.String)">
+            <summary>
+            Determine the appropriate auth scope from a server connection string.
+            Supports Power BI XMLA (multi-cloud), Azure AS, and localhost.
+            Server URLs follow patterns like:
+              powerbi://api.powerbi.com/v1.0/myorg/Workspace
+              powerbi://api.powerbigov.us/v1.0/myorg/Workspace
+              asazure://region.asazure.windows.net/server
+              localhost:port
+            </summary>
+        </member>
+        <member name="E:TabularEditor.Shared.Infrastructure.AzureIdentityClientHelper.InteractiveSignInStarting">
+            <summary>
+            Raised just before an interactive browser/WAM sign-in dialog is shown.
+            Subscribers should hide any overlay UI (e.g. wait forms) so the auth dialog is visible.
+            </summary>
+        </member>
+        <member name="E:TabularEditor.Shared.Infrastructure.AzureIdentityClientHelper.InteractiveSignInCompleted">
+            <summary>
+            Raised after an interactive sign-in dialog has completed (success or failure).
+            Subscribers should restore any overlay UI that was hidden.
+            </summary>
+        </member>
         <member name="M:TabularEditor.Shared.Infrastructure.AzureIdentityClientHelper.GetClientAsync(TabularEditor.Shared.Services.IPreferencesProvider,System.String,System.Boolean,System.IntPtr,System.Threading.CancellationToken)">
             <summary>
             Gets an ExtendedFabricClient object - either from the cache (i.e. the most recently used one) or by creating a new one if the cache is empty.
@@ -119,6 +375,61 @@
             Handles Azure.Identity, MSAL (used by TOM), SqlClient, and OleDb authentication cancellations.
             </summary>
         </member>
+        <member name="M:TabularEditor.Shared.Interaction.ContextExtensions.GetDescription(TabularEditor.Shared.Interaction.Context)">
+            <summary>
+            Returns the localized display name for the given Context, using Smart.Format for pluralization.
+            Singular contexts (e.g. Table, Measure) return the singular form; group/collection contexts
+            (e.g. Tables, PartitionCollection) return the plural form.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.ContextExtensions.GetTypeNameFormat(TabularEditor.Shared.Interaction.Context)">
+            <summary>
+            Returns the Smart.Format template string for the given Context, or null if not mapped.
+            This is the single source of truth for Context-to-localized-name mapping.
+            Resolved against <see cref="P:System.Globalization.CultureInfo.CurrentUICulture"/>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.ContextExtensions.GetTypeNameFormat(TabularEditor.Shared.Interaction.Context,System.Globalization.CultureInfo)">
+            <summary>
+            Culture-aware variant of <see cref="M:TabularEditor.Shared.Interaction.ContextExtensions.GetTypeNameFormat(TabularEditor.Shared.Interaction.Context)"/>. Resolves the resource in the
+            specified <paramref name="culture"/>, allowing callers (e.g. AI context injection) to force
+            invariant/English output regardless of the UI culture.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.GetLocalizedTypeNameFormat(TabularEditor.TOMWrapper.ITabularObject)">
+            <summary>
+            Returns the Smart.Format template string for the localized type name of the given object.
+            Use with <see cref="M:TabularEditor.Utils.Smart.Format(System.String,System.Object[])"/> and a count to get singular/plural form.
+            Handles concrete subtypes (CalculatedTable, CalculatedColumn, etc.) that don't have Context equivalents.
+            Resolved against <see cref="P:System.Globalization.CultureInfo.CurrentUICulture"/>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.GetLocalizedTypeNameFormat(TabularEditor.TOMWrapper.ITabularObject,System.Globalization.CultureInfo)">
+            <summary>
+            Culture-aware variant of <see cref="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.GetLocalizedTypeNameFormat(TabularEditor.TOMWrapper.ITabularObject)"/>. Passing a specific
+            <paramref name="culture"/> (e.g. <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>) forces the resource lookup
+            into that culture so callers can produce language-stable output independent of the current UI culture.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.GetLocalizedTypeNameFormat(TabularEditor.TOMWrapper.ObjectType)">
+            <summary>
+            Returns the Smart.Format template string for the localized type name of the given ObjectType.
+            Use with <see cref="M:TabularEditor.Utils.Smart.Format(System.String,System.Object[])"/> and a count to get singular/plural form.
+            Delegates to the Context mapping for types that have a corresponding Context value.
+            Resolved against <see cref="P:System.Globalization.CultureInfo.CurrentUICulture"/>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.GetLocalizedTypeNameFormat(TabularEditor.TOMWrapper.ObjectType,System.Globalization.CultureInfo)">
+            <summary>
+            Culture-aware variant of <see cref="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.GetLocalizedTypeNameFormat(TabularEditor.TOMWrapper.ObjectType)"/>.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Interaction.LocalizedTypeNameHelper.ToContext(TabularEditor.TOMWrapper.ObjectType)">
+            <summary>
+            Maps an <see cref="T:TabularEditor.TOMWrapper.ObjectType"/> to the corresponding singular <see cref="T:TabularEditor.Shared.Interaction.Context"/> value.
+            Returns <see cref="F:TabularEditor.Shared.Interaction.Context.None"/> for types that have no direct Context mapping (Model, Group, Folder).
+            </summary>
+        </member>
         <member name="T:TabularEditor.Shared.Interaction.NamedObjectEditableCollection`1">
             <summary>
             Provides a set of methods for changing multiple object properties at once, as well
@@ -297,12 +608,21 @@
         <member name="M:TabularEditor.Shared.Interaction.SelectionHelper.Summary(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Boolean,System.Boolean)">
             <summary>
             Returns a string with a short description of the types of objects in the <paramref name="items"/> collection.
+            Resolved against <see cref="P:System.Globalization.CultureInfo.CurrentUICulture"/>.
             </summary>
             <param name="items">The collection to summarize</param>
             <param name="onlyTypeNames">Set to false to always show the types of objects in the collection</param>
             <param name="capitalize"></param>
             <returns></returns>
         </member>
+        <member name="M:TabularEditor.Shared.Interaction.SelectionHelper.Summary(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Globalization.CultureInfo,System.Boolean,System.Boolean)">
+            <summary>
+            Culture-aware variant of <see cref="M:TabularEditor.Shared.Interaction.SelectionHelper.Summary(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Boolean,System.Boolean)"/>. Resolves all
+            resource strings and casing through the supplied <paramref name="culture"/> so callers can produce a
+            language-stable summary independent of the current UI culture. Pass <see cref="P:System.Globalization.CultureInfo.InvariantCulture"/>
+            to obtain the English/neutral form (e.g. for feeding the AI assistant, whose prompts and skills are English-only).
+            </summary>
+        </member>
         <member name="M:TabularEditor.Shared.Interaction.SelectionHelper.Edit``1(System.Collections.Generic.IEnumerable{``0})">
             <summary>
             Convenient extension method for converting an <see cref="T:System.Collections.Generic.IEnumerable`1"/> to a <see cref="T:TabularEditor.Shared.Interaction.NamedObjectEditableCollection`1"/>, the latter containing
@@ -526,6 +846,11 @@
             The name of the current table group (if exactly one table group is selected, or if one or more tables within a single table group is selected)
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.SelectedItem">
+            <summary>
+            The currently selected item (if exactly one item is selected in the explorer tree).
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.DirectCount">
             <summary>
             The number of objects directly selected in the Explorer Tree (not counting any child objects).
@@ -579,6 +904,11 @@
             he currently selected KPI.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.KPIs">
+            <summary>
+            All currently selected KPIs.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.Levels">
             <summary>
             The currently selected levels.
@@ -604,6 +934,11 @@
             The currently selected object (if exactly one object is selected in the explorer tree).
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.Objects">
+            <summary>
+            All currently selected objects.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.Columns">
             <summary>
             All currently selected columns (including columns within selected Display Folders).
@@ -639,11 +974,21 @@
             All currently selected roles.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.Role">
+            <summary>
+            The currently selected role (if exactly one role is selected in the explorer tree).
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.SingleColumnRelationships">
             <summary>
             All currently selected relationships.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.SingleColumnRelationship">
+            <summary>
+            The currently selected relationship (if exactly one relationship is selected in the explorer tree).
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.Perspectives">
             <summary>
             All currently selected perspectives.
@@ -664,6 +1009,11 @@
             All currently selected table permissions.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.TablePermission">
+            <summary>
+            The currently selected table permission (if exactly one table permission is selected in the explorer tree).
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.CalculationGroup">
             <summary>
             The currently selected calculation group (if exactly one calculation group is selected in the explorer tree.)
@@ -689,6 +1039,11 @@
             All currently selected calculated table columns (including calculated table columns within selected Display Folders).
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.CalculatedTableColumn">
+            <summary>
+            The currently selected calculated table column (if exactly one calculated table column is selected in the explorer tree).
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.DataColumn">
             <summary>
             The currently selected data column (if exactly one data column is selected in the explorer tree).
@@ -762,7 +1117,12 @@
         </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.Folders">
             <summary>
-            Gets the currently selected display folders in the explorer tree.
+            All currently selected display folders in the explorer tree.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Interaction.Selection.Folder">
+            <summary>
+            The currently selected folder (if exactly one folder is selected in the explorer tree).
             </summary>
         </member>
         <member name="P:TabularEditor.Shared.Interaction.Selection.Groups">
@@ -792,6 +1152,126 @@
               resource lookups using this strongly typed resource class.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentDocumentRead">
+            <summary>
+              Looks up a localized string similar to Read documents.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentDocumentReadDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs the content from open documents.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentDocumentReadTooltip">
+            <summary>
+              Looks up a localized string similar to This setting controls whether the AI assistant will have access to read the text content of any documents (scripts, queries, etc.) that are currently open in Tabular Editor..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentDocumentWrite">
+            <summary>
+              Looks up a localized string similar to Modify documents.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentDocumentWriteDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs to modify content in open documents.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentDocumentWriteTooltip">
+            <summary>
+              Looks up a localized string similar to This setting controls whether the AI assistant will be able to modify the content of any documents (scripts, queries, etc.) that are currently open in Tabular Editor..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentEditBpaRules">
+            <summary>
+              Looks up a localized string similar to Edit BPA rules.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentEditBpaRulesDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs to add or modify Best Practice Analyzer rules.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentEditBpaRulesTooltip">
+            <summary>
+              Looks up a localized string similar to This setting controls whether the AI assistant will be able to add or modify Best Practice Analyzer rules in your local user rule collection..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentGenericDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs to access this data.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentMacroRead">
+            <summary>
+              Looks up a localized string similar to Read macros.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentMacroReadDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs to read macros from your macro library.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentMacroReadTooltip">
+            <summary>
+              Looks up a localized string similar to This setting controls whether the AI assistant will be able to read the macros in your macro library, including their C# code..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentModelMetadata">
+            <summary>
+              Looks up a localized string similar to Model metadata.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentModelMetadataDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs to access model metadata.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentModelMetadataTooltip">
+            <summary>
+              Looks up a localized string similar to This setting controls whether the AI assistant will have access to the metadata of the semantic model currently loaded in Tabular Editor (table names, column names, measure definitions, etc.)..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentQueryData">
+            <summary>
+              Looks up a localized string similar to Query data.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentQueryDataDescription">
+            <summary>
+              Looks up a localized string similar to The AI assistant needs to execute DAX queries and read results.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiConsentQueryDataTooltip">
+            <summary>
+              Looks up a localized string similar to This setting controls whether the AI will be able to execute DAX queries against the semantic model and read the results of those queries..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiProviderAnthropic">
+            <summary>
+              Looks up a localized string similar to Anthropic.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiProviderAzureOpenAI">
+            <summary>
+              Looks up a localized string similar to Azure OpenAI.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiProviderCustom">
+            <summary>
+              Looks up a localized string similar to Custom (OpenAI-compatible).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiProviderNone">
+            <summary>
+              Looks up a localized string similar to None (AI disabled).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.AiProviderOpenAI">
+            <summary>
+              Looks up a localized string similar to OpenAI.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Localization.Strings.AuthenticationModeIntegrated">
             <summary>
               Looks up a localized string similar to Integrated.
@@ -963,8 +1443,8 @@
         <member name="P:TabularEditor.Shared.Localization.Strings.BpaRuleIsAvailableInMdxDescription">
              <summary>
                Looks up a localized string similar to Hidden columns that are not used for sorting or in hierarchies should have their IsAvailableInMdx property set to false. This prevents unnecessary attribute hierarchy creation, reducing processing time and memory consumption.
-            
-            Reference: https://blog.crossjoin.co.uk/2018/07/02/isavailableinmdx-ssas-tabular/.
+                
+            NOTE: Ignore this rule if the columns is to be used in Excel PivotTable and Analyze in Excel..
              </summary>
         </member>
         <member name="P:TabularEditor.Shared.Localization.Strings.BpaRuleIsAvailableInMdxName">
@@ -1124,6 +1604,16 @@
               Looks up a localized string similar to Trim object names.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.BpaRuleUdfUseCompoundNamesDescription">
+            <summary>
+              Looks up a localized string similar to User-defined function names should contain a dot or underscore separator (e.g., &apos;MyLib.MyFunction&apos; or &apos;MyLib_MyFunction&apos;) to form a compound/namespaced name. Simple names without a separator are at risk of conflicting with new DAX functions introduced in the future, which could break existing DAX expressions that reference the UDF..
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.BpaRuleUdfUseCompoundNamesName">
+            <summary>
+              Looks up a localized string similar to User-defined functions should use compound names.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Localization.Strings.BpaRuleVisibleCalculationGroupsNoDescriptionDescription">
             <summary>
               Looks up a localized string similar to Visible calculation groups should have descriptions to explain their purpose and how the calculation items modify measure behavior. Descriptions appear in tooltips in Power BI Desktop and can be used to generate automated data documentation..
@@ -1219,27 +1709,112 @@
               Looks up a localized string similar to File upload to the DAX Optimizer service is disabled by a local policy..
             </summary>
         </member>
-        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_DisabledDueToLowModelCompatibilityLevel">
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxOptimizerObfuscationDictionaryMissingTitle">
             <summary>
-              Looks up a localized string similar to Disabled due to low model compatibility level ({0} &lt; {1}).
+              Looks up a localized string similar to Previous obfuscation dictionary not found.
             </summary>
         </member>
-        <member name="P:TabularEditor.Shared.Localization.Strings.DefaultSemanticModel">
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxOptimizerObfuscationDictionaryMissingMessage">
             <summary>
-              Looks up a localized string similar to Semantic Model (Default).
+              Looks up a localized string similar to The obfuscation dictionary for the previously uploaded version of this model could not be found on this computer. The new version will be uploaded with freshly obfuscated object names, so the DAX Optimizer service may no longer recognize issues you previously marked as ignored for this model..
             </summary>
         </member>
-        <member name="P:TabularEditor.Shared.Localization.Strings.Error">
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_AuthorsLabel">
             <summary>
-              Looks up a localized string similar to Error.
+              Looks up a localized string similar to Authors:.
             </summary>
         </member>
-        <member name="P:TabularEditor.Shared.Localization.Strings.ErrorLoadingUserOptionsDetails">
-             <summary>
-               Looks up a localized string similar to An error occurred while trying to deserialize the User Options (.tmuo) file:
-            
-            {0}.
-             </summary>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_DescriptionHeader">
+            <summary>
+              Looks up a localized string similar to Description.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_DetailsHeader">
+            <summary>
+              Looks up a localized string similar to Details.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_DisabledDueToLowModelCompatibilityLevel">
+            <summary>
+              Looks up a localized string similar to Disabled due to low model compatibility level ({0} &lt; {1}).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_DownloadsLabel">
+            <summary>
+              Looks up a localized string similar to Downloads:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_InstallCaption">
+            <summary>
+              Looks up a localized string similar to Install.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_InstalledCaption">
+            <summary>
+              Looks up a localized string similar to Installed.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_OwnersLabel">
+            <summary>
+              Looks up a localized string similar to Owners:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_ProjectUrlLabel">
+            <summary>
+              Looks up a localized string similar to Project URL:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_ProviderLabel">
+            <summary>
+              Looks up a localized string similar to Provider:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_PublishDateLabel">
+            <summary>
+              Looks up a localized string similar to Publish Date:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_ReleaseNotesHeader">
+            <summary>
+              Looks up a localized string similar to Release Notes.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_RemoveCaption">
+            <summary>
+              Looks up a localized string similar to Remove.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_RepositoryUrlLabel">
+            <summary>
+              Looks up a localized string similar to Repository URL:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_TagsLabel">
+            <summary>
+              Looks up a localized string similar to Tags:.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DaxPackageManager_UpToDateCaption">
+            <summary>
+              Looks up a localized string similar to Up-to-date.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.DefaultSemanticModel">
+            <summary>
+              Looks up a localized string similar to Semantic Model (Default).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.Error">
+            <summary>
+              Looks up a localized string similar to Error.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ErrorLoadingUserOptionsDetails">
+             <summary>
+               Looks up a localized string similar to An error occurred while trying to deserialize the User Options (.tmuo) file:
+            
+            {0}.
+             </summary>
         </member>
         <member name="P:TabularEditor.Shared.Localization.Strings.ErrorLoadingUserOptionsTitle">
             <summary>
@@ -1336,6 +1911,131 @@
               Looks up a localized string similar to OAuth.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_CalculatedColumn">
+            <summary>
+              Looks up a localized string similar to {0:Calculated Column|Calculated Columns}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_CalculatedTable">
+            <summary>
+              Looks up a localized string similar to {0:Calculated Table|Calculated Tables}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_CalculatedTableColumn">
+            <summary>
+              Looks up a localized string similar to {0:Calculated Table Column|Calculated Table Columns}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_CalculationGroupTable">
+            <summary>
+              Looks up a localized string similar to {0:Calculation Group Table|Calculation Group Tables}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_CalculationItem">
+            <summary>
+              Looks up a localized string similar to {0:Calculation Item|Calculation Items}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Calendar">
+            <summary>
+              Looks up a localized string similar to {0:Calendar|Calendars}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Column">
+            <summary>
+              Looks up a localized string similar to {0:Column|Columns}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_DataSource">
+            <summary>
+              Looks up a localized string similar to {0:Data Source|Data Sources}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Folder">
+            <summary>
+              Looks up a localized string similar to Folder.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Function">
+            <summary>
+              Looks up a localized string similar to {0:Function|Functions}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Group">
+            <summary>
+              Looks up a localized string similar to Group.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Hierarchy">
+            <summary>
+              Looks up a localized string similar to {0:Hierarchy|Hierarchies}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_KPI">
+            <summary>
+              Looks up a localized string similar to {0:KPI|KPIs}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Level">
+            <summary>
+              Looks up a localized string similar to {0:Level|Levels}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Measure">
+            <summary>
+              Looks up a localized string similar to {0:Measure|Measures}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Model">
+            <summary>
+              Looks up a localized string similar to Model.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Objects">
+            <summary>
+              Looks up a localized string similar to objects.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Partition">
+            <summary>
+              Looks up a localized string similar to {0:Partition|Partitions}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Perspective">
+            <summary>
+              Looks up a localized string similar to {0:Perspective|Perspectives}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Relationship">
+            <summary>
+              Looks up a localized string similar to {0:Relationship|Relationships}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Role">
+            <summary>
+              Looks up a localized string similar to {0:Role|Roles}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_SharedExpression">
+            <summary>
+              Looks up a localized string similar to {0:Shared Expression|Shared Expressions}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Table">
+            <summary>
+              Looks up a localized string similar to {0:Table|Tables}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_TablePermission">
+            <summary>
+              Looks up a localized string similar to {0:Table Permission|Table Permissions}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.ObjectTypeName_Translation">
+            <summary>
+              Looks up a localized string similar to {0:Translation|Translations}.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Localization.Strings.PartitionRefreshDescription">
             <summary>
               Looks up a localized string similar to {0} refresh of {1:partition {2}|{} partitions}.
@@ -1381,6 +2081,31 @@
               Looks up a localized string similar to Scalar expression.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.SelectionSummary_MultipleObjects">
+            <summary>
+              Looks up a localized string similar to {0} {1}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.SelectionSummary_Nothing">
+            <summary>
+              Looks up a localized string similar to Nothing.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.SelectionSummary_NothingSelected">
+            <summary>
+              Looks up a localized string similar to (Nothing selected).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.SelectionSummary_SingleObjectTypeOnly">
+            <summary>
+              Looks up a localized string similar to 1 {0}.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Localization.Strings.SelectionSummary_SingleObjectWithName">
+            <summary>
+              Looks up a localized string similar to {0} &quot;{1}&quot;.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Localization.Strings.SemanticBridge_NotAvailable_InitializationFailure">
              <summary>
                Looks up a localized string similar to SemanticBridge service failed to initialize.
@@ -1489,16 +2214,208 @@
               Looks up a localized string similar to Warning.
             </summary>
         </member>
+        <member name="T:TabularEditor.Shared.ModelDiff.ModelDiffResult">
+            <summary>
+            Output of <see cref="T:TabularEditor.Shared.ModelDiff.ModelDiffComparer"/>: a hierarchical JSON-level diff tree between two models.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Models.UserOptions.AIConsent">
+            <summary>
+            AI consent state for this model.
+            </summary>
+        </member>
         <member name="T:TabularEditor.Shared.Models.UserEncryptedConnectionStringSerializer">
             <summary>
             This class ensures that a connection string is encrypted/decrypted in case it contains sensitive data.
             </summary>
         </member>
+        <member name="T:TabularEditor.Shared.Scripting.BpaResult">
+            <summary>
+            Result of evaluating a single BPA rule against a model object.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.BpaResult.FixExpression">
+            <summary>
+            The fix expression for this rule (if any).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.BpaResult.Object">
+            <summary>
+            Reference to the violating TOM object (for fix expression execution).
+            Not serialized to JSON.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.BpaResult.CanFix">
+            <summary>
+            Whether this violation can be auto-fixed.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.BpaRuleError">
+            <summary>
+            Result of a BPA rule that failed to compile or evaluate.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.BpaAnalysisResult">
+            <summary>
+            Complete result of running BPA analysis on a model.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.IScriptMessageSink">
+            <summary>
+            Hook for redirecting script messages (Info / Warning / Error / Output) in
+            command-line / headless hosts. When a sink is registered through
+            <c>ScriptHelper.InitScriptHelper</c> and <see cref="P:TabularEditor.IApp.CommandLineMode"/> is true,
+            all script messaging routes through the sink instead of writing directly to
+            <see cref="T:System.Console"/>. The UI app passes <c>null</c> (legacy behavior preserved).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.IScriptMessageSink.Info(System.String,System.Int32)">
+            <summary>Called when a script invokes <c>Info(message)</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.IScriptMessageSink.Warning(System.String,System.Int32,System.Boolean)">
+            <summary>Called when a script invokes <c>Warning(message)</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.IScriptMessageSink.Error(System.String,System.Int32,System.Boolean)">
+            <summary>Called when a script invokes <c>Error(message)</c>.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.IScriptMessageSink.Output(System.Object,System.Int32)">
+            <summary>Called when a script invokes <c>Output(value)</c>.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.MacroJsonCollection">
+            <summary>
+            Root container for MacroActions.json. Shared schema between TE3 desktop and CLI.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.MacroJson.Folder">
+            <summary>
+            Parsed folder path (from backslash-separated <see cref="P:TabularEditor.Shared.Scripting.MacroJson.Name"/>). Not serialised.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.MacroJson.DisplayName">
+            <summary>
+            Display name without the folder prefix. Not serialised.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.MacroJson.ParseFolderHierarchy">
+            <summary>
+            Parse folder hierarchy from a backslash-separated <see cref="P:TabularEditor.Shared.Scripting.MacroJson.Name"/> into
+            <see cref="P:TabularEditor.Shared.Scripting.MacroJson.Folder"/> and <see cref="P:TabularEditor.Shared.Scripting.MacroJson.DisplayName"/>. Used by both TE3 desktop
+            (via the macro tree UI) and the CLI (`te macro list`/`run`).
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.ScriptBpa">
+            <summary>
+            Script-accessible Best Practice Analyzer helper. Exposed as <c>ScriptHost.Bpa</c>.
+            Delegates are wired by the host (CLI or TE3 UI) at startup.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptBpa.AnalyzeDelegate">
+            <summary>
+            Delegate that runs BPA analysis and returns results.
+            Signature: (tableFilter) -&gt; <see cref="T:TabularEditor.Shared.Scripting.BpaAnalysisResult"/>.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptBpa.RulesDelegate">
+            <summary>
+            Delegate that returns the current set of BPA rules (built-in + model).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptBpa.Analyze(System.String[])">
+            <summary>
+            Run BPA analysis on the current model. Optionally filter to specific tables.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptBpa.Rules">
+            <summary>
+            Get the current set of BPA rules (built-in + model-embedded, deduplicated).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptBpa.ExportCsv(TabularEditor.Shared.Scripting.BpaAnalysisResult,System.String)">
+            <summary>
+            Export BPA analysis results to a CSV file at the specified path.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.ScriptConstants">
+            <summary>
+            Shared constants and helpers for C# script compilation.
+            Used by both TE3 desktop and CLI script engines.
+            </summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Scripting.ScriptConstants.CoreUsings">
+            <summary>
+            Core usings available in all TE3/CLI scripts.
+            Each engine may add its own additional usings on top.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptConstants.GetPreprocessorSymbols">
+            <summary>
+            Preprocessor symbols for TE3 script compilation:
+            
+            - `TE3`
+            - `TE3_3_10_OR_GREATER`
+            - `TE3_3_11_OR_GREATER`
+            - ...
+            - `TE3_3_X_OR_GREATER` (where X is the current minor version number of TE3)
+            
+            For TE CLI script compilation, we ONLY define the following symbol:
+            
+            - `TECLI`
+            
+            This allows script authors to have sections of code in their script that only gets compiled under a specific version
+            Tabular Editor 3 or the CLI. That way, a script can contain UI code that gets compiled only when the script is executed
+            in TE3 and ommitted when the script is compiled/executed in TE CLI.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptConstants.WithParseOptions(Microsoft.CodeAnalysis.Scripting.ScriptOptions,Microsoft.CodeAnalysis.CSharp.CSharpParseOptions)">
+            <summary>
+            Apply CSharpParseOptions to ScriptOptions via reflection.
+            The WithParseOptions method is internal in Roslyn.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptEngine.QuickAnalyzeScriptSafety(System.String)">
+            <summary>
+            Performs a quick safety analysis on a C# script without full compilation.
+            Checks for #r reference directives and unsafe using statements.
+            </summary>
+            <param name="script">The C# script code to analyze.</param>
+            <returns>A quick safety analysis result.</returns>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.QuickScriptSafetyResult">
+            <summary>
+            Result of a quick script safety analysis (without full compilation).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.QuickScriptSafetyResult.HasReferenceDirective">
+            <summary>Whether the script contains #r reference directives.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.QuickScriptSafetyResult.UnsafeNamespaces">
+            <summary>Namespaces used in using statements that are not in the safe list.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.QuickScriptSafetyResult.IsSafe">
+            <summary>Whether the script appears safe (no reference directives and no unsafe namespaces).</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.QuickScriptSafetyResult.GetWarningMessage">
+            <summary>Generates a human-readable safety warning message.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptError.ToString">
+            <summary>
+            Formatted error string suitable for human display: <c>(line,col): error: message</c>
+            or <c>(line,col): warning: message</c>. When <see cref="P:TabularEditor.Shared.Scripting.ScriptError.Line"/> is non-positive the
+            position prefix is omitted.
+            </summary>
+        </member>
         <member name="T:TabularEditor.Shared.Scripting.ScriptHelper">
             <summary>
             Contains various extension methods which are commonly used in scripts
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptHelper.MessageSink">
+            <summary>
+            Optional sink for command-line / headless hosts. When non-null and
+            <see cref="P:TabularEditor.IApp.CommandLineMode"/> is true, <see cref="M:TabularEditor.Shared.Scripting.ScriptHelper.Info(System.String,System.Int32)"/>/<see cref="M:TabularEditor.Shared.Scripting.ScriptHelper.Warning(System.String,System.Int32,System.Boolean)"/>/<see cref="M:TabularEditor.Shared.Scripting.ScriptHelper.Error(System.String,System.Int32,System.Boolean)"/>/<see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Output(System.Object)"/>
+            route through the sink instead of writing directly to <see cref="T:System.Console"/>.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.Scripting.ScriptHelper.WaitFormVisible">
             <summary>
             Toggle the "Please wait" spinner on/off. Useful if you want to display custom dialogs / UI to the end user.
@@ -1744,16 +2661,41 @@
             An object that represents the current selection in the TOM Explorer.
             </summary>
         </member>
-        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.SemanticBridge">
-             <summary>
-             SemanticBridge service for cross-platform semantic model operations.
-             </summary>
-             <remarks>
-             <para>
-             <b>State Persistence:</b> The service maintains state (e.g., currently loaded MetricView)
-             that persists across multiple script executions, allowing workflows like:
-             <code>
-             // Script 1: Load and validate
+        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.Bpa">
+            <summary>
+            Best Practice Analyzer scripting helper. Use <c>Bpa.Analyze()</c>, <c>Bpa.Rules</c>, <c>Bpa.ExportCsv()</c>.
+            </summary>
+            <remarks>
+            Delegates (<see cref="P:TabularEditor.Shared.Scripting.ScriptBpa.AnalyzeDelegate"/> / <see cref="P:TabularEditor.Shared.Scripting.ScriptBpa.RulesDelegate"/>) are wired
+            by the host application during startup. If unwired, calls throw <see cref="T:System.InvalidOperationException"/>.
+            </remarks>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.Vpa">
+            <summary>
+            VertiPaq Analyzer read helper. Use <c>Vpa.Summary</c>, <c>Vpa.Tables</c>, <c>Vpa.Columns</c>, etc.
+            Call <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.CollectVertiPaqAnalyzerStats"/> first to populate the data.
+            </summary>
+            <remarks>
+            Provider delegates are wired by the host application during startup. If unwired,
+            collections return empty and <see cref="P:TabularEditor.Shared.Scripting.ScriptVpa.Summary"/> returns null.
+            </remarks>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.Viz">
+            <summary>
+            Visualization report builder. Use <c>Viz.CreateReport()</c> to create reports from scripts.
+            Commands are accumulated during script execution and processed by the frontend afterwards.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.SemanticBridge">
+             <summary>
+             SemanticBridge service for cross-platform semantic model operations.
+             </summary>
+             <remarks>
+             <para>
+             <b>State Persistence:</b> The service maintains state (e.g., currently loaded MetricView)
+             that persists across multiple script executions, allowing workflows like:
+             <code>
+             // Script 1: Load and validate
              SemanticBridge.MetricView.Load(@"C:\data.yaml");
              var diag = SemanticBridge.MetricView.Validate();
             
@@ -1848,341 +2790,768 @@
         </member>
         <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectTable(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Table},TabularEditor.TOMWrapper.Table,System.String)">
             <summary>
-            Displays a dialog that allows the user to select a table from the specified list of tables.
+            Displays a dialog that allows the user to select a table from the specified list of tables.
+            </summary>
+            <param name="tables">A list of tables to be shown to the user</param>
+            <param name="preselect">(Optional) A table from the list of tables, which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected table or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectTable(TabularEditor.TOMWrapper.Table,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a table from the model.
+            </summary>
+            <param name="preselect">(Optional) A table which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected table or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectTable(TabularEditor.TOMWrapper.Model,TabularEditor.TOMWrapper.Table,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a table from the model.
+            </summary>
+            <param name="model">The model from which a table should be selected by the user</param>
+            <param name="preselect">(Optional) A table which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected table or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a measure from the specified list of measures.
+            </summary>
+            <param name="measures">A list of measures to be shown to the user</param>
+            <param name="preselect">(Optional) A measure from the list of measures, which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected measure or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(TabularEditor.TOMWrapper.Table,TabularEditor.TOMWrapper.Measure,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a measure from the specified table.
+            </summary>
+            <param name="table">A table containing the measures that will be shown to the user</param>
+            <param name="preselect">(Optional) A measure from the table, which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected measure or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(TabularEditor.TOMWrapper.Measure,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a measure from the model.
+            </summary>
+            <param name="preselect">(Optional) A measure from the model, which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected measure or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(TabularEditor.TOMWrapper.Model,TabularEditor.TOMWrapper.Measure,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a measure from the model.
+            </summary>
+            <param name="model">The model from which a measure should be selected by the user</param>
+            <param name="preselect">(Optional) A measure from the model, which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected measure or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectObject``1(System.Collections.Generic.IEnumerable{``0},``0,System.String)">
+            <summary>
+            Displays a dialog that allows the user to select a model object from a list of objects.
+            </summary>
+            <typeparam name="T">The type of objects shown to the user</typeparam>
+            <param name="objects">A list of objects to be shown to the user</param>
+            <param name="preselect">(Optional) An object from the list, which is preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected object or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectObjects``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.String)">
+            <summary>
+            Displays a dialog that allows the user to select one or more model objects from a list of objects.
+            </summary>
+            <typeparam name="T">The type of objects shown to the user</typeparam>
+            <param name="objects">A list of objects to be shown to the user</param>
+            <param name="preselect">(Optional) A list of objects which are preselected when the dialog is shown</param>
+            <param name="label">(Optional) A label to be shown within the dialog</param>
+            <returns>The selected object(s) or null if the user cancels out of the dialog</returns>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.WaitFormVisible">
+            <summary>
+            Toggle the "Please wait" spinner on/off. Useful if you want to display custom dialogs / UI to the end user.
+            </summary>
+            <remarks>Built-in script UI such as the <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/> and <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)"/> functionality will automatically
+            hide the "Please wait" spinner.</remarks>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SuspendWaitForm(System.Action)">
+            <summary>
+            Hides the "Please wait" spinner while performing the specified action. Useful if the action displays custom dialogs / UI to the end user.
+            </summary>
+            <remarks>Built-in script UI such as the <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/> and <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)"/> functionality will automatically
+            hide the "Please wait" spinner.</remarks>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SuspendWaitForm``1(System.Func{``0})">
+            <summary>
+            Hides the "Please wait" spinner while performing the specified action. Useful if the action displays custom dialogs / UI to the end user.
+            </summary>
+            <remarks>Built-in script UI such as the <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/> and <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)"/> functionality will automatically
+            hide the "Please wait" spinner.</remarks>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.EvaluateDax(System.String)">
+            <summary>
+            Evaluates the specified DAX expression against the connected database and returns a data table or scalar value containing the result.
+            </summary>
+            <param name="dax">The DAX expression to be evaluated</param>
+            <returns>A <see cref="T:System.Data.DataTable"/> if the DAX expression returns a table value, otherwise a primitive type representing the scalar value of the evaluation.</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExecuteDax(System.String)">
+            <summary>
+            Executes the specified DAX query.
+            </summary>
+            <param name="dax">A DAX query which contains one or more EVALUATE statements.</param>
+            <returns>A <see cref="T:System.Data.DataSet"/> object which contains the resulting datasets from the query.</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExecuteReader(System.String)">
+            <summary>
+            Executes the specified DAX query.
+            </summary>
+            <param name="dax">A DAX query which contains one or more EVALUATE statements.</param>
+            <returns>An <see cref="T:System.Data.IDataReader"/>-object that allows you to iterate the results of the query.</returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExecuteCommand(System.String,System.Boolean)">
+            <summary>
+            Executes the specified TMSL or XMLA command.
+            </summary>
+            <param name="tmslOrXmla">A TMSL or XMLA string.</param>
+            <param name="isXmla">Set to true if <paramref name="tmslOrXmla"/> is XMLA.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.String)">
+            <summary>
+            Run a macro. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.String)"/>.
+            </summary>
+            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)">
+            <summary>
+            Run a macro on a selection of objects. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)"/>
+            </summary>
+            <param name="selection">The object selection on which the macro should run.</param>
+            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(TabularEditor.TOMWrapper.ITabularNamedObject,System.String)">
+            <summary>
+            Run a macro on an object. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.String)"/>
+            </summary>
+            <param name="selection">The object on which the macro should be run.</param>
+            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.Int32)">
+            <summary>
+            Run a macro. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Int32)"/>
+            </summary>
+            <param name="macroId">Id of the macro</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Int32)">
+            <summary>
+            Run a macro on a selection of objects. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Int32)"/>
+            </summary>
+            <param name="selection">The object selection on which the macro should run.</param>
+            <param name="macroId">Id of the macro</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(TabularEditor.TOMWrapper.ITabularNamedObject,System.Int32)">
+            <summary>
+            Run a macro on an object. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.Int32)"/>
+            </summary>
+            <param name="selection">The object on which the macro should be run.</param>
+            <param name="macroId">Id of the macro</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.String)">
+            <summary>
+            Run a macro.
+            </summary>
+            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)">
+            <summary>
+            Run a macro on a selection of objects.
+            </summary>
+            <param name="selection">The object selection on which the macro should run.</param>
+            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.String)">
+            <summary>
+            Run a macro on an object.
+            </summary>
+            <param name="selection">The object on which the macro should be run.</param>
+            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Int32)">
+            <summary>
+            Run a macro.
+            </summary>
+            <param name="macroId">Id of the macro</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Int32)">
+            <summary>
+            Run a macro on a selection of objects.
+            </summary>
+            <param name="selection">The object selection on which the macro should run.</param>
+            <param name="macroId">Id of the macro</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.Int32)">
+            <summary>
+            Run a macro on an object.
+            </summary>
+            <param name="selection">The object on which the macro should be run.</param>
+            <param name="macroId">Id of the macro</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExportProperties(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)">
+            <summary>
+            Export properties of the specified set of objects to a TSV (tab-separated) string.
+            Use <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.ImportProperties(System.String)"/> to import properties from a TSV string.
+            </summary>
+            <param name="objects">Set of objects whose properties should be serialized</param>
+            <param name="properties">(Optional) Comma-separated list of properties to export. If omitted, a default set of properties are exported.</param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ImportProperties(System.String)">
+            <summary>
+            Applies properties to objects based on a string representation (tab separated format) of property values to assign,
+            such as obtained by <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.ExportProperties(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)"/>.
+            </summary>
+            <param name="tsvData">The tab separated property values to assign</param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.GetObjectPath(TabularEditor.TOMWrapper.TabularObject)">
+            <summary>
+            Returns a string representation that uniquely identifies the specified object within the model.
+            </summary>
+            <param name="obj"></param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ResolveObjectPath(System.String)">
+            <summary>
+            Resolves an object within the model based on a string such as the one obtained by <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.GetObjectPath(TabularEditor.TOMWrapper.TabularObject)"/>.
+            </summary>
+            <param name="path"></param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.LineBreakFirstChar(System.String,System.Boolean)">
+            <summary>
+            Ensures that a DAX expression starts with a line break.
+            </summary>
+            <remarks>
+            In Power BI Desktop, DAX expressions are shown on a formula bar with the name of the object prepended. For this reason, it is often useful to have a line break as the first character of the actual DAX expression.
+            </remarks>
+            <param name="dax">The DAX expression</param>
+            <param name="onlyIfMultiline">Set to true if the line break character should only be inserted when the DAX expression itself spans multiple lines.</param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ConvertDax(System.String,System.Boolean)">
+            <summary>
+            Changes the character used for decimals and list separators in a DAX expression.
+            </summary>
+            <param name="dax">The original DAX expression</param>
+            <param name="useSemicolons">Set to true when converting from Non-US-style DAX to US-style DAX, or false for vice versa.</param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.FormatDax(TabularEditor.TOMWrapper.IDaxDependantObject)">
+            <summary>
+            Flags the specified object for formatting after script execution or the next time <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.CallDaxFormatter(System.Nullable{System.Boolean},System.Nullable{System.Boolean})"/> is called.
+            </summary>
+            <param name="obj"></param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CallDaxFormatter(System.Nullable{System.Boolean},System.Nullable{System.Boolean})">
+            <summary>
+            Format all DAX expressions on objects currently flagged for formatting.
+            </summary>
+            <param name="shortFormat"></param>
+            <param name="skipSpaceAfterFunctionName"></param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.FormatDax(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.IDaxDependantObject},System.Nullable{System.Boolean},System.Nullable{System.Boolean})">
+            <summary>
+            Format all DAX expressions on the specified objects.
+            </summary>
+            <param name="objects"></param>
+            <param name="shortFormat"></param>
+            <param name="skipSpaceAfterFunctionName"></param>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.FormatDax(System.String,System.Nullable{System.Boolean},System.Boolean)">
+            <summary>
+            Format the specified DAX expression
+            </summary>
+            <param name="dax"></param>
+            <param name="shortFormat"></param>
+            <param name="skipSpaceAfterFunctionName"></param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ReadFile(System.String)">
+            <summary>
+            Read the specified file as text
+            </summary>
+            <param name="filePath"></param>
+            <returns></returns>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SaveFile(System.String,System.String,System.Text.Encoding)">
+            <summary>
+            Saves the specified text to a file
+            </summary>
+            <param name="filePath">Path of the file - file will be created if it does not already exist, and overwritten otherwise</param>
+            <param name="content">Content to write to the file</param>
+            <param name="encoding">(Optional) Encoding to use</param>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.ScriptMethodAttribute">
+            <summary>
+            Public static methods that are decorated with this attribute, will be exposed to
+            the scripting engine as top-level methods, so that the end-user does not need to
+            specify the class name to invoke the method.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.ScriptRewriter">
+            <summary>
+            The <see cref="T:TabularEditor.Shared.Scripting.ScriptRewriter"/> is used to rewrite C# scripts before compilation.
+            </summary>
+            <remarks>
+            The ScriptRewriter uses Roslyn to construct a <see cref="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree"/> of the code, for purposes of rewriting the code in a few ways.
+            
+            1) Some global method calls have an optional lineNumber parameter, for example <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/>. The ScriptRewriter will add the line
+            number to this call, when it is omitted in the script.
+            
+            2) Macros are stored as a collection of C# scripts in a JSON file. A macro may have an Enabled-script, which is just a script that must return a boolean value.
+            For performance reasons, we combine all macros into a single C# code file before compiling. This code file is not a script, since it will be constructed as
+            a number of namespaces, each containing a class representing the macro. As each macro script may contain "#r"-directives or "using" directives, we must first
+            parse the macro code separately, remove the directives, then put them back in when the combind code is generated. All unique "#r" directives are added at the
+            top of the code file, where as the "using" directives for each macro is added within the namespace of that class.
+            </remarks>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.ScriptViz">
+            <summary>
+            Script-accessible visualization builder. Exposed as <c>ScriptHost.Viz</c>.
+            Accumulates <see cref="T:TabularEditor.Shared.Scripting.VizCommand"/> objects that the frontend processes into store actions.
+            Thread safety: <see cref="P:TabularEditor.Shared.Scripting.ScriptViz.Commands"/> is static; cleared at request start, drained at request end.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptViz.ClearCommands">
+            <summary>
+            Clear accumulated commands. Called before script execution.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptViz.DrainCommands">
+            <summary>
+            Get and clear accumulated commands. Called after script execution.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.ScriptViz.CreateReport(System.String)">
+            <summary>
+            Create a new visualization report with the given name. Returns a builder for fluent configuration.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.VizReportBuilder">
+            <summary>
+            Fluent builder for configuring a viz report.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizReportBuilder.AddPage(System.String)">
+            <summary>Add a page to the report.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizReportBuilder.SetPalette(System.String)">
+            <summary>Set the color palette by preset name (e.g. "default", "warm-earth", "ocean").</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizReportBuilder.SetPalette(System.String[])">
+            <summary>Set a custom color palette from hex color strings.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizReportBuilder.SetFont(System.String)">
+            <summary>Set the report font family.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.VizPageBuilder">
+            <summary>
+            Fluent builder for configuring a viz page.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizPageBuilder.AddVisual(System.String,System.Nullable{System.Int32},System.Nullable{System.Int32},System.Nullable{System.Int32},System.Nullable{System.Int32})">
+            <summary>
+            Add a visual to the page. Supported types: bar, line, donut, kpi, table, matrix,
+            scatter, histogram, heatmap, radar, sankey, waterfall, treemap, choropleth, distribution.
+            Position and size are optional (auto-layout if omitted).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizPageBuilder.SetName(System.String)">
+            <summary>Set the page name.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizPageBuilder.AddPageFilter(System.String,System.String)">
+            <summary>Add a page-level filter (slicer) for the specified table column.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.VizVisualBuilder">
+            <summary>
+            Fluent builder for configuring a visual within a page.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizVisualBuilder.AddField(System.String,System.String,System.String,System.String,System.String)">
+            <summary>
+            Add a field to a well. Wells: rows, values, legend, targets.
+            objectType: "Column" (default) or "Measure".
+            aggregation: "Sum" (default), "Count", "Average", "Min", "Max", "None".
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizVisualBuilder.SetTitle(System.String)">
+            <summary>Set the visual title.</summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizVisualBuilder.SetOption(System.String,System.Object)">
+            <summary>
+            Set a visual option (e.g. "horizontal" = true, "showLegend" = false).
+            Value must be a primitive type (bool, int, double, string).
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizVisualBuilder.SetSize(System.Int32,System.Int32)">
+            <summary>Set the visual size explicitly.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.VizCommand">
+            <summary>
+            A serializable command emitted by the viz scripting API.
+            The frontend viz-script-bridge processes these into store actions.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Scripting.VizCommand.#ctor(System.String,System.Object)">
+            <summary>
+            A serializable command emitted by the viz scripting API.
+            The frontend viz-script-bridge processes these into store actions.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.ScriptVpa">
+            <summary>
+            Script-accessible VPA (VertiPaq Analyzer) read helper. Exposed as <c>ScriptHost.Vpa</c>.
+            Provides read access to previously collected VPA statistics.
+            Call <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.CollectVertiPaqAnalyzerStats"/> first to populate the data.
+            </summary>
+            <remarks>
+            The data-source delegates are wired by the host (CLI or TE3 UI) during startup.
+            In environments where no provider has been wired, properties return empty results.
+            </remarks>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.SummaryDelegate">
+            <summary>
+            Delegate that returns the VPA summary. Returns null if not collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.IsCollectedDelegate">
+            <summary>
+            Lightweight delegate that checks if VPA stats have been collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.TablesDelegate">
+            <summary>
+            Delegate that returns per-table VPA statistics.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.ColumnsDelegate">
+            <summary>
+            Delegate that returns per-column VPA statistics.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.RelationshipsDelegate">
+            <summary>
+            Delegate that returns relationship VPA statistics.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.PartitionsDelegate">
+            <summary>
+            Delegate that returns per-partition VPA statistics.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.Summary">
+            <summary>
+            Model-level VPA summary (size, counts, dates). Null if stats not yet collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.Tables">
+            <summary>
+            Per-table statistics. Empty list if stats not yet collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.Columns">
+            <summary>
+            Per-column statistics. Empty list if stats not yet collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.Relationships">
+            <summary>
+            Relationship statistics. Empty list if stats not yet collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.Partitions">
+            <summary>
+            Per-partition statistics. Empty list if stats not yet collected.
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Scripting.ScriptVpa.IsCollected">
+            <summary>
+            Whether VPA statistics have been collected for the current model.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.VertipaqSummary">
+            <summary>
+            Model-level VertiPaq Analyzer summary. Returned by <see cref="P:TabularEditor.Shared.Scripting.ScriptVpa.Summary"/>.
+            </summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Scripting.TableStats">
+            <summary>
+            Per-table VertiPaq Analyzer statistics. Returned by <see cref="P:TabularEditor.Shared.Scripting.ScriptVpa.Tables"/>.
             </summary>
-            <param name="tables">A list of tables to be shown to the user</param>
-            <param name="preselect">(Optional) A table from the list of tables, which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected table or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectTable(TabularEditor.TOMWrapper.Table,System.String)">
+        <member name="T:TabularEditor.Shared.Scripting.ColumnStats">
             <summary>
-            Displays a dialog that allows the user to select a table from the model.
+            Per-column VertiPaq Analyzer statistics. Returned by <see cref="P:TabularEditor.Shared.Scripting.ScriptVpa.Columns"/>.
             </summary>
-            <param name="preselect">(Optional) A table which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected table or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectTable(TabularEditor.TOMWrapper.Model,TabularEditor.TOMWrapper.Table,System.String)">
+        <member name="T:TabularEditor.Shared.Scripting.RelationshipStats">
             <summary>
-            Displays a dialog that allows the user to select a table from the model.
+            Per-relationship VertiPaq Analyzer statistics. Returned by <see cref="P:TabularEditor.Shared.Scripting.ScriptVpa.Relationships"/>.
             </summary>
-            <param name="model">The model from which a table should be selected by the user</param>
-            <param name="preselect">(Optional) A table which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected table or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)">
+        <member name="T:TabularEditor.Shared.Scripting.PartitionStats">
             <summary>
-            Displays a dialog that allows the user to select a measure from the specified list of measures.
+            Per-partition VertiPaq Analyzer statistics. Returned by <see cref="P:TabularEditor.Shared.Scripting.ScriptVpa.Partitions"/>.
             </summary>
-            <param name="measures">A list of measures to be shown to the user</param>
-            <param name="preselect">(Optional) A measure from the list of measures, which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected measure or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(TabularEditor.TOMWrapper.Table,TabularEditor.TOMWrapper.Measure,System.String)">
+        <member name="T:TabularEditor.Shared.SensitiveException">
             <summary>
-            Displays a dialog that allows the user to select a measure from the specified table.
+            Represents an exception that may contain PII/sensitive information in the message text. When the exception is sent to the telemetry service,
+            the telemetry will use the message string
             </summary>
-            <param name="table">A table containing the measures that will be shown to the user</param>
-            <param name="preselect">(Optional) A measure from the table, which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected measure or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(TabularEditor.TOMWrapper.Measure,System.String)">
+        <member name="P:TabularEditor.Shared.SensitiveException.PublicMessage">
             <summary>
-            Displays a dialog that allows the user to select a measure from the model.
+            A message that has been stripped of sensitive information.
             </summary>
-            <param name="preselect">(Optional) A measure from the model, which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected measure or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(TabularEditor.TOMWrapper.Model,TabularEditor.TOMWrapper.Measure,System.String)">
+        <member name="T:TabularEditor.Shared.Services.AI.ConsentType">
             <summary>
-            Displays a dialog that allows the user to select a measure from the model.
+            Defines the type of data being sent to the AI provider.
             </summary>
-            <param name="model">The model from which a measure should be selected by the user</param>
-            <param name="preselect">(Optional) A measure from the model, which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected measure or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectObject``1(System.Collections.Generic.IEnumerable{``0},``0,System.String)">
+        <member name="F:TabularEditor.Shared.Services.AI.ConsentType.QueryData">
+            <summary>DAX query execution results.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Services.AI.ConsentType.DocumentRead">
+            <summary>Reading content from open document editors.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Services.AI.ConsentType.DocumentWrite">
+            <summary>Modifying content in open document editors.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Services.AI.ConsentType.ModelMetadata">
+            <summary>Accessing model metadata.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Services.AI.ConsentType.EditBpaRules">
+            <summary>Adding or modifying Best Practice Analyzer rules.</summary>
+        </member>
+        <member name="F:TabularEditor.Shared.Services.AI.ConsentType.MacroRead">
+            <summary>Reading macros from the user's macro library.</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Services.AI.ConsentTypeMetadata">
             <summary>
-            Displays a dialog that allows the user to select a model object from a list of objects.
+            Provides metadata and display information for consent types.
             </summary>
-            <typeparam name="T">The type of objects shown to the user</typeparam>
-            <param name="objects">A list of objects to be shown to the user</param>
-            <param name="preselect">(Optional) An object from the list, which is preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected object or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SelectObjects``1(System.Collections.Generic.IEnumerable{``0},System.Collections.Generic.IEnumerable{``0},System.String)">
+        <member name="P:TabularEditor.Shared.Services.AI.ConsentTypeMetadata.All">
             <summary>
-            Displays a dialog that allows the user to select one or more model objects from a list of objects.
+            All available consent types.
             </summary>
-            <typeparam name="T">The type of objects shown to the user</typeparam>
-            <param name="objects">A list of objects to be shown to the user</param>
-            <param name="preselect">(Optional) A list of objects which are preselected when the dialog is shown</param>
-            <param name="label">(Optional) A label to be shown within the dialog</param>
-            <returns>The selected object(s) or null if the user cancels out of the dialog</returns>
         </member>
-        <member name="P:TabularEditor.Shared.Scripting.ScriptHost.WaitFormVisible">
+        <member name="M:TabularEditor.Shared.Services.AI.ConsentTypeMetadata.GetDescription(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Toggle the "Please wait" spinner on/off. Useful if you want to display custom dialogs / UI to the end user.
+            Gets a description for a consent type.
             </summary>
-            <remarks>Built-in script UI such as the <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/> and <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)"/> functionality will automatically
-            hide the "Please wait" spinner.</remarks>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SuspendWaitForm(System.Action)">
+        <member name="M:TabularEditor.Shared.Services.AI.ConsentTypeMetadata.GetPreferencesLabel(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Hides the "Please wait" spinner while performing the specified action. Useful if the action displays custom dialogs / UI to the end user.
+            Gets the label text for the preferences dialog.
             </summary>
-            <remarks>Built-in script UI such as the <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/> and <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)"/> functionality will automatically
-            hide the "Please wait" spinner.</remarks>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SuspendWaitForm``1(System.Func{``0})">
+        <member name="M:TabularEditor.Shared.Services.AI.ConsentTypeMetadata.GetPreferencesTooltip(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Hides the "Please wait" spinner while performing the specified action. Useful if the action displays custom dialogs / UI to the end user.
+            Gets the tooltip text for the preferences dialog.
             </summary>
-            <remarks>Built-in script UI such as the <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/> and <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.SelectMeasure(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.Measure},TabularEditor.TOMWrapper.Measure,System.String)"/> functionality will automatically
-            hide the "Please wait" spinner.</remarks>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.EvaluateDax(System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.ConsentTypeMetadata.SupportsPerModelConsent(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Evaluates the specified DAX expression against the connected database and returns a data table or scalar value containing the result.
+            Returns true if the consent type supports per-model consent storage.
+            Only QueryData and ModelMetadata support "ForThisModel" consent option.
             </summary>
-            <param name="dax">The DAX expression to be evaluated</param>
-            <returns>A <see cref="T:System.Data.DataTable"/> if the DAX expression returns a table value, otherwise a primitive type representing the scalar value of the evaluation.</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExecuteDax(System.String)">
+        <member name="T:TabularEditor.Shared.Services.AI.ModelAIConsentState">
             <summary>
-            Executes the specified DAX query.
+            Stores per-model AI consent state. Stored in UserOptions (.tmuo file).
             </summary>
-            <param name="dax">A DAX query which contains one or more EVALUATE statements.</param>
-            <returns>A <see cref="T:System.Data.DataSet"/> object which contains the resulting datasets from the query.</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExecuteReader(System.String)">
+        <member name="P:TabularEditor.Shared.Services.AI.ModelAIConsentState.GrantedConsents">
             <summary>
-            Executes the specified DAX query.
+            The set of consent types that have been granted for this model.
             </summary>
-            <param name="dax">A DAX query which contains one or more EVALUATE statements.</param>
-            <returns>An <see cref="T:System.Data.IDataReader"/>-object that allows you to iterate the results of the query.</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExecuteCommand(System.String,System.Boolean)">
+        <member name="P:TabularEditor.Shared.Services.AI.ModelAIConsentState.ConsentGrantedAt">
             <summary>
-            Executes the specified TMSL or XMLA command.
+            When consent was last granted.
             </summary>
-            <param name="tmslOrXmla">A TMSL or XMLA string.</param>
-            <param name="isXmla">Set to true if <paramref name="tmslOrXmla"/> is XMLA.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.ModelAIConsentState.HasConsent(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Run a macro. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.String)"/>.
+            Checks if consent has been granted for a specific type.
             </summary>
-            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.ModelAIConsentState.GrantConsent(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Run a macro on a selection of objects. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)"/>
+            Grants consent for a specific type.
             </summary>
-            <param name="selection">The object selection on which the macro should run.</param>
-            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(TabularEditor.TOMWrapper.ITabularNamedObject,System.String)">
+        <member name="P:TabularEditor.Shared.Services.AI.ModelAIConsentState.HasAnyConsent">
             <summary>
-            Run a macro on an object. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.String)"/>
+            Returns true if any consent has been granted.
             </summary>
-            <param name="selection">The object on which the macro should be run.</param>
-            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.Int32)">
+        <member name="T:TabularEditor.Shared.Services.AI.AIConsentPreferences">
             <summary>
-            Run a macro. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Int32)"/>
+            Stores global AI consent preferences. Only stores "Always" consents.
+            Stored in Preferences.json.
             </summary>
-            <param name="macroId">Id of the macro</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Int32)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIConsentPreferences.AlwaysGrantedConsents">
             <summary>
-            Run a macro on a selection of objects. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Int32)"/>
+            The set of consent types that are always granted (without prompting).
             </summary>
-            <param name="selection">The object selection on which the macro should run.</param>
-            <param name="macroId">Id of the macro</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CustomAction(TabularEditor.TOMWrapper.ITabularNamedObject,System.Int32)">
+        <member name="M:TabularEditor.Shared.Services.AI.AIConsentPreferences.HasAlwaysConsent(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Run a macro on an object. Alias for <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.Int32)"/>
+            Checks if a consent type is always granted.
             </summary>
-            <param name="selection">The object on which the macro should be run.</param>
-            <param name="macroId">Id of the macro</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.AIConsentPreferences.GrantAlwaysConsent(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Run a macro.
+            Grants "always" consent for a specific type.
             </summary>
-            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.AIConsentPreferences.RevokeAlwaysConsent(TabularEditor.Shared.Services.AI.ConsentType)">
             <summary>
-            Run a macro on a selection of objects.
+            Revokes "always" consent for a specific type.
             </summary>
-            <param name="selection">The object selection on which the macro should run.</param>
-            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.String)">
+        <member name="F:TabularEditor.Shared.Services.AI.AISkillsHelper.CustomInstructionsPath">
             <summary>
-            Run a macro on an object.
+            User overlay directory path.
             </summary>
-            <param name="selection">The object on which the macro should be run.</param>
-            <param name="macroName">Name of the macro. Use fully path of macro in case of ambiguity.</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Int32)">
+        <member name="T:TabularEditor.Shared.Services.AI.OpenDocumentInfo">
             <summary>
-            Run a macro.
+            Represents information about an open document in the editor.
             </summary>
-            <param name="macroId">Id of the macro</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.Int32)">
+        <member name="P:TabularEditor.Shared.Services.AI.OpenDocumentInfo.Id">
+            <summary>Unique identifier for this document instance.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Services.AI.OpenDocumentInfo.Type">
+            <summary>Document type: "dax-query", "csharp", or "dax-script".</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Services.AI.OpenDocumentInfo.Title">
+            <summary>Display title shown in the editor tab.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Services.AI.OpenDocumentInfo.IsDirty">
+            <summary>Whether the document has unsaved changes.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Services.AI.OpenDocumentInfo.FileName">
+            <summary>Optional file path if the document is saved to disk.</summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Services.AI.OpenDocumentInfo.Content">
+            <summary>The document content (only populated if requested and consented).</summary>
+        </member>
+        <member name="T:TabularEditor.Shared.Services.AI.IDocumentAccessProvider">
             <summary>
-            Run a macro on a selection of objects.
+            Provides access to open documents in the editor for AI tools.
             </summary>
-            <param name="selection">The object selection on which the macro should run.</param>
-            <param name="macroId">Id of the macro</param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.Macro(TabularEditor.TOMWrapper.ITabularNamedObject,System.Int32)">
+        <member name="M:TabularEditor.Shared.Services.AI.IDocumentAccessProvider.GetOpenDocumentsAsync(System.Boolean)">
             <summary>
-            Run a macro on an object.
+            Gets a list of open documents in the editor.
             </summary>
-            <param name="selection">The object on which the macro should be run.</param>
-            <param name="macroId">Id of the macro</param>
+            <param name="includeContent">If true, includes the document content (requires consent).</param>
+            <returns>List of open document information.</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ExportProperties(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.IDocumentAccessProvider.UpdateDocumentContentAsync(System.Int32,System.String)">
             <summary>
-            Export properties of the specified set of objects to a TSV (tab-separated) string.
-            Use <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.ImportProperties(System.String)"/> to import properties from a TSV string.
+            Updates the content of an open document.
             </summary>
-            <param name="objects">Set of objects whose properties should be serialized</param>
-            <param name="properties">(Optional) Comma-separated list of properties to export. If omitted, a default set of properties are exported.</param>
-            <returns></returns>
+            <param name="documentId">The document ID to update.</param>
+            <param name="content">The new content for the document.</param>
+            <returns>True if the update was successful, false if the document was not found.</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ImportProperties(System.String)">
+        <member name="M:TabularEditor.Shared.Services.AI.IDocumentAccessProvider.GetDocumentContentAsync(System.Int32)">
             <summary>
-            Applies properties to objects based on a string representation (tab separated format) of property values to assign,
-            such as obtained by <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.ExportProperties(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.ITabularNamedObject},System.String)"/>.
+            Gets the content of a specific open document.
             </summary>
-            <param name="tsvData">The tab separated property values to assign</param>
+            <param name="documentId">The document ID.</param>
+            <returns>The document content, or null if the document was not found.</returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.GetObjectPath(TabularEditor.TOMWrapper.TabularObject)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.Endpoint">
             <summary>
-            Returns a string representation that uniquely identifies the specified object within the model.
+            Endpoint URL for Azure OpenAI (e.g., "https://your-resource.openai.azure.com")
+            or Custom provider base URL (e.g., "https://openrouter.ai/api/v1").
             </summary>
-            <param name="obj"></param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ResolveObjectPath(System.String)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.Model">
             <summary>
-            Resolves an object within the model based on a string such as the one obtained by <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.GetObjectPath(TabularEditor.TOMWrapper.TabularObject)"/>.
+            Model name or deployment ID. If empty, uses the provider's default model.
             </summary>
-            <param name="path"></param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.LineBreakFirstChar(System.String,System.Boolean)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.MaxOutputTokens">
             <summary>
-            Ensures that a DAX expression starts with a line break.
+            The DefaultMaxOutputTokens config setting used when creating the Anthropic IChatClient.
+            When the value is set to 0, we use the maximum number of output tokens available for any
+            given Anthropic model. Set the value to any value greater than 0 to override the defaults.
             </summary>
-            <remarks>
-            In Power BI Desktop, DAX expressions are shown on a formula bar with the name of the object prepended. For this reason, it is often useful to have a line break as the first character of the actual DAX expression.
-            </remarks>
-            <param name="dax">The DAX expression</param>
-            <param name="onlyIfMultiline">Set to true if the line break character should only be inserted when the DAX expression itself spans multiple lines.</param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ConvertDax(System.String,System.Boolean)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.ShowSelectionContext">
             <summary>
-            Changes the character used for decimals and list separators in a DAX expression.
+            Show the "Context:" selection indicator above assistant replies.
             </summary>
-            <param name="dax">The original DAX expression</param>
-            <param name="useSemicolons">Set to true when converting from Non-US-style DAX to US-style DAX, or false for vice versa.</param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.FormatDax(TabularEditor.TOMWrapper.IDaxDependantObject)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.ShowCustomInstructions">
             <summary>
-            Flags the specified object for formatting after script execution or the next time <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.CallDaxFormatter(System.Nullable{System.Boolean},System.Nullable{System.Boolean})"/> is called.
+            Show the "Custom Instructions:" / "Invoked:" skill pills above assistant replies.
             </summary>
-            <param name="obj"></param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.CallDaxFormatter(System.Nullable{System.Boolean},System.Nullable{System.Boolean})">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.ShowKnowledgeBaseSearch">
             <summary>
-            Format all DAX expressions on objects currently flagged for formatting.
+            Show the "Searching knowledge base..." indicator during tool calls.
             </summary>
-            <param name="shortFormat"></param>
-            <param name="skipSpaceAfterFunctionName"></param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.FormatDax(System.Collections.Generic.IEnumerable{TabularEditor.TOMWrapper.IDaxDependantObject},System.Nullable{System.Boolean},System.Nullable{System.Boolean})">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.AutoCompact">
             <summary>
-            Format all DAX expressions on the specified objects.
+            Automatically compact conversations when context window usage exceeds the threshold.
             </summary>
-            <param name="objects"></param>
-            <param name="shortFormat"></param>
-            <param name="skipSpaceAfterFunctionName"></param>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.FormatDax(System.String,System.Nullable{System.Boolean},System.Boolean)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.AutoCompactThreshold">
             <summary>
-            Format the specified DAX expression
+            Percentage of context window usage that triggers auto-compaction (50-90).
             </summary>
-            <param name="dax"></param>
-            <param name="shortFormat"></param>
-            <param name="skipSpaceAfterFunctionName"></param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.ReadFile(System.String)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.EffectiveModel">
             <summary>
-            Read the specified file as text
+            Gets the effective model to use, falling back to the provider's default if not specified.
             </summary>
-            <param name="filePath"></param>
-            <returns></returns>
         </member>
-        <member name="M:TabularEditor.Shared.Scripting.ScriptHost.SaveFile(System.String,System.String,System.Text.Encoding)">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.ShowScriptPreview">
             <summary>
-            Saves the specified text to a file
+            Whether or not to display the "Script preview" dialog after C# script execution
             </summary>
-            <param name="filePath">Path of the file - file will be created if it does not already exist, and overwritten otherwise</param>
-            <param name="content">Content to write to the file</param>
-            <param name="encoding">(Optional) Encoding to use</param>
         </member>
-        <member name="T:TabularEditor.Shared.Scripting.ScriptMethodAttribute">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.CheckForKbUpdatesOnStartup">
             <summary>
-            Public static methods that are decorated with this attribute, will be exposed to
-            the scripting engine as top-level methods, so that the end-user does not need to
-            specify the class name to invoke the method.
+            Whether to check for knowledge base updates when the AI assistant starts.
             </summary>
         </member>
-        <member name="T:TabularEditor.Shared.Scripting.ScriptRewriter">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.OrganizationId">
             <summary>
-            The <see cref="T:TabularEditor.Shared.Scripting.ScriptRewriter"/> is used to rewrite C# scripts before compilation.
+            For OpenAI endpoints, users can specify an optional Organization (in case they belong to multiple organizations)
             </summary>
-            <remarks>
-            The ScriptRewriter uses Roslyn to construct a <see cref="T:Microsoft.CodeAnalysis.CSharp.CSharpSyntaxTree"/> of the code, for purposes of rewriting the code in a few ways.
-            
-            1) Some global method calls have an optional lineNumber parameter, for example <see cref="M:TabularEditor.Shared.Scripting.ScriptHost.Info(System.String,System.Int32)"/>. The ScriptRewriter will add the line
-            number to this call, when it is omitted in the script.
-            
-            2) Macros are stored as a collection of C# scripts in a JSON file. A macro may have an Enabled-script, which is just a script that must return a boolean value.
-            For performance reasons, we combine all macros into a single C# code file before compiling. This code file is not a script, since it will be constructed as
-            a number of namespaces, each containing a class representing the macro. As each macro script may contain "#r"-directives or "using" directives, we must first
-            parse the macro code separately, remove the directives, then put them back in when the combind code is generated. All unique "#r" directives are added at the
-            top of the code file, where as the "using" directives for each macro is added within the namespace of that class.
-            </remarks>
         </member>
-        <member name="T:TabularEditor.Shared.SensitiveException">
+        <member name="P:TabularEditor.Shared.Services.AI.AIPreferences.ProjectId">
             <summary>
-            Represents an exception that may contain PII/sensitive information in the message text. When the exception is sent to the telemetry service,
-            the telemetry will use the message string
+            For OpenAI endpoints, users can specify an optional Project (to direct billing to that project)
             </summary>
         </member>
-        <member name="P:TabularEditor.Shared.SensitiveException.PublicMessage">
+        <member name="M:TabularEditor.Shared.Services.AI.AIProviderExtensions.GetDefaultModel(TabularEditor.Shared.Services.AI.AIProvider)">
             <summary>
-            A message that has been stripped of sensitive information.
+            Returns the default model for the provider, or null if user must specify.
             </summary>
         </member>
         <member name="P:TabularEditor.Shared.Services.AppCache.Ppu">
@@ -2209,7 +3578,13 @@
             TODO: Handle DirectQuery / user-delegated credentials
             </summary>
         </member>
-        <member name="M:TabularEditor.Shared.Services.Connectivity.Fabric.FabricInfoProvider.#ctor(TabularEditor.Shared.Services.IPreferencesProvider)">
+        <member name="M:TabularEditor.Shared.Services.Connectivity.Databricks.DatabricksInfoProvider.BuildConnectionString(System.String,System.String,TabularEditor.Shared.Services.DatabricksAuthMode,System.String,System.String)">
+            <summary>
+            Builds a Databricks ODBC connection string builder with driver, host, and auth parameters.
+            Does not include Catalog/Schema. Callers may add additional parameters before calling ToString().
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Services.Connectivity.Fabric.FabricInfoProvider.#ctor(TabularEditor.Shared.Services.IPreferencesProvider,TabularEditor.Shared.Services.ITelemetry)">
             <summary>
             This object must be constructed on the UI thread, as it uses the WindowsFormsSynchronizationContext
             </summary>
@@ -2276,6 +3651,12 @@
             <param name="writable"></param>
             <returns>RegistryKey For the complex Subkey. </returns>
         </member>
+        <member name="M:TabularEditor.Shared.Services.DaxOptimizer.DaxOptimizerService.TryLoadObfuscationDictionary(System.String)">
+            <summary>
+            Loads the obfuscation dictionary for the given id from cache or disk (null if empty/not found). Unlike
+            <see cref="M:TabularEditor.Shared.Services.DaxOptimizer.DaxOptimizerService.ResolveObfuscationDictionary(System.String)"/>, it does not touch <see cref="P:TabularEditor.Shared.Services.DaxOptimizer.DaxOptimizerService.ObfuscationDictionaryNeeded"/>.
+            </summary>
+        </member>
         <member name="M:TabularEditor.Shared.Services.FileSystemHelper.DirectoryFromPath(System.String)">
             <summary>
             Returns the directory of the provided filePath.
@@ -2550,6 +3931,25 @@
             <param name="externalQuery"></param>
             <returns></returns>
         </member>
+        <member name="P:TabularEditor.Shared.Services.Policies.DisableAi">
+            <summary>
+            Disables all AI functionality (when flag is set, the TabularEditor3.AI module isn't loaded)
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Services.Policies.DisableAiChat">
+            <summary>
+            Specifically disables the AI Chat feature, aka. AI Assistant. Other AI features may still be available.
+            </summary>
+        </member>
+        <member name="M:TabularEditor.Shared.Services.LocalInstance.StripPowerBIDesktopSuffix(System.String)">
+            <summary>
+            Removes known Power BI Desktop/Designer suffixes from a window title string.
+            Only removes suffixes that appear at the end of the string to avoid incorrectly
+            truncating model names that legitimately contain " - ".
+            </summary>
+            <param name="windowTitle">The window title string to process</param>
+            <returns>The window title with known suffixes removed, or the original string if no suffix is present</returns>
+        </member>
         <member name="P:TabularEditor.Shared.Services.Preferences.ProxyUseDefaultCredentials">
             <summary>
             Indicate whether the system credentials of the application are sent with requests.
@@ -2571,6 +3971,13 @@
             Stores an encrypted version of the user password. Use the string Decrypt() extension method to decrypt.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Services.DataBrowsingPreferences.MaxUnindexedSortRows">
+            <summary>
+            Maximum number of (filtered) rows the data preview will sort by a column that has no attribute hierarchy
+            when no primary key / WINDOW support is available. Above this, sorting falls back to a plain in-memory TOPN
+            that materializes the whole table, so we refuse instead of risking an out-of-memory error.
+            </summary>
+        </member>
         <member name="T:TabularEditor.Shared.Services.KeepSortingAndFilteringOption">
             <summary>
             Specifies the options for retaining sorting and filtering settings in grid views.
@@ -2591,6 +3998,11 @@
             Always: Sorting and filtering are never reset if the columns still exist.
             </summary>
         </member>
+        <member name="F:TabularEditor.Shared.Services.PreferencesService.TE3AppDataPath">
+            <summary>
+            Path to the Tabular Editor 3 local application data folder, typically `%LocalAppData%\TabularEditor3`
+            </summary>
+        </member>
         <member name="T:TabularEditor.Shared.Services.RefreshConfig">
             <summary>
             Provides additional configuration options for data refresh operations.
@@ -2708,6 +4120,12 @@
             Checks if the given exception represents an authentication cancellation by the user.
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Services.IDatabricksTableImportSettings.IsMulticloud">
+            <summary>
+            True if the connection uses DatabricksMultiCloud.Catalogs (i.e. non-Azure Databricks).
+            Azure AD authentication is not supported for multicloud connections.
+            </summary>
+        </member>
         <member name="F:TabularEditor.Shared.Services.IdentifierQuoting.Backtick">
             <summary>
             Indicates that every identifier must be enclosed in a pair of backticks
@@ -2744,6 +4162,13 @@
         <member name="M:TabularEditor.Shared.Services.UserOptionsService.GetTabularModelUserOptionsFileName(System.String)">
             <param name="modelFileName">Can be a folder or a file</param>
         </member>
+        <member name="M:TabularEditor.Shared.Services.VertiPaqAnalyzer.IVertiPaqAnalyzerService.GetObfuscatedVpax(Dax.Vpax.Obfuscator.Common.ObfuscationDictionary@,Dax.Vpax.Obfuscator.Common.ObfuscationDictionary)">
+            <summary>
+            Obfuscates the current model and returns the obfuscated VPAX bytes.
+            </summary>
+            <param name="obfuscationDictionary">The dictionary describing the applied obfuscation, to be persisted for later deobfuscation.</param>
+            <param name="baseDictionary">Optional dictionary from a previous obfuscation of the same model; when supplied, obfuscation is incremental so obfuscated names stay stable across versions.</param>
+        </member>
         <member name="P:TabularEditor.Shared.Services.VertiPaqAnalyzer.PreloadVpaxResult.ReconstructedTom">
             <summary>
             This flag, if true, indicates that the TOM model has to be reconstructed from the VPAX model
@@ -2772,6 +4197,19 @@
               3) Name
             </summary>
         </member>
+        <member name="P:TabularEditor.Shared.Snapshot.SnapshotTable.UsesDirectQuery">
+            <summary>
+            True if at least one partition on the table is in DirectQuery mode (considering the model's DefaultMode).
+            DirectQuery tables don't support paginated data preview (TOPNSKIP only works with Skip=0).
+            </summary>
+        </member>
+        <member name="P:TabularEditor.Shared.Snapshot.SnapshotTable.IsUnique">
+            <summary>
+            True if the table has a primary key - i.e. a column marked IsKey, or the table sits on the "one" side
+            of a one-to-many relationship. This is a prerequisite for paginating via the WINDOW function when
+            sorting by a column that has no attribute hierarchy.
+            </summary>
+        </member>
         <member name="P:TabularEditor.Shared.TextServices.QueryTextTransformer.EvaluateStatement.ShouldLimitRows">
             <summary>
             If an EVALUATE statement uses a START AT clause, or if the main table expression returned is surrounded by "TOPN", the assumption is that
diff --git a/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation.png b/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation.png
index 4e314581b..c8aafcd24 100644
Binary files a/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation.png and b/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation.png differ
diff --git a/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation2.png b/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation2.png
index 5772cdf0e..4e034f04d 100644
Binary files a/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation2.png and b/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation2.png differ
diff --git a/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation3.png b/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation3.png
index 64e15f96d..b62312756 100644
Binary files a/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation3.png and b/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation3.png differ
diff --git a/content/features/semantic-bridge-metric-view-fields-and-dimensions.md b/content/features/semantic-bridge-metric-view-fields-and-dimensions.md
new file mode 100644
index 000000000..04720649d
--- /dev/null
+++ b/content/features/semantic-bridge-metric-view-fields-and-dimensions.md
@@ -0,0 +1,133 @@
+---
+uid: semantic-bridge-metric-view-fields-and-dimensions
+title: Fields and Dimensions in Metric Views
+author: Greg Baldini
+updated: 2026-06-25
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      none: true
+    - product: Tabular Editor 3
+      since: 3.26.2
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          none: true
+        - edition: Enterprise
+          full: true
+---
+# Fields and Dimensions in Metric Views
+
+<!--
+SUMMARY: Explains the Databricks Metric View `dimensions` -> `fields` keyword rename and the
+matching Semantic Bridge C# API rename (Dimension -> Field): what changed, that the old names
+still work, migration guidance, and what Tabular Editor emits on round-trip.
+-->
+
+In spring 2026, the Metric View spec redefined a canonical top-level key in the Metric View YAML specification from `dimensions` (now legacy) to `fields`.
+These both refer to the collection of columns—whether direct references to source columns or defined by a SQL expression—that is available to query in the Metric View.
+[The documentation indicates that, `fields` is to be preferred, but both terms remain valid](https://learn.microsoft.com/azure/databricks/business-semantics/metric-views/yaml-reference#dimensions).
+We have updated the Metric View object model in the Semantic Bridge to align with this.
+Serialization and deserialization continue to work with either key in conformance with the Metric View spec.
+We offer backward-compatibility shims in the object model for the old "dimension"-associated names.
+Users of the object model in C# scripts should migrate to "field"-associated names when they can.
+
+**Who this affects**: anyone writing Metric View YAML by hand, anyone using the Metric View object model in C# scripts in Tabular Editor.
+
+## Versioning
+
+This change came after the v1.1 spec was published, and with no new spec version.
+As such, we take a conservative approach in the Semantic Bridge.
+We treat `dimensions` as the default for v0.1 and v1.1 Metric Views.
+In the future, we will treat `fields` as the default for any newer-versioned Metric Views.
+This is out of caution and a desire to offer the most interoperability with any other tools that may not be up to date with the latest published Metric View spec.
+
+## Serialization and deserialization
+
+Per [Metric View documentation](https://learn.microsoft.com/azure/databricks/business-semantics/metric-views/yaml-reference#dimensions), both keys remain valid for serialization.
+
+| YAML source uses | Version | Deserialization succeeds | Warning emitted on deserialization   | Reserializes with          |
+|------------------|---------|--------------------------|--------------------------------------|----------------------------|
+| `fields`         | <1.1    | yes                      | yes                                  | `fields`                   |
+| `dimensions`     | <1.1    | yes                      | no                                   | `dimensions`               |
+| neither          | <1.1    | yes                      | no                                   | `dimensions`               |
+| `fields`         | 1.1     | yes                      | no                                   | `fields`                   |
+| `dimensions`     | 1.1     | yes                      | yes                                  | `dimensions`               |
+| neither          | 1.1     | yes                      | no                                   | `dimensions`               |
+| `fields`         | >1.1    | yes                      | no                                   | `fields`                   |
+| `dimensions`     | >1.1    | yes                      | yes                                  | `dimensions`               |
+| neither          | >1.1    | yes                      | no                                   | `fields`                   |
+| both             | any     | no                       | yes (error, failing deserialization) | n/a, deserialization fails |
+
+We will continue to support both keywords in all Metric View versions unless a future spec update indicates otherwise.
+You can continue to freely use either as you prefer, with notes about the warnings and defaults above for serialization and deserialization.
+
+You may note that we warn on `dimensions` in a v1.1 Metric View, and also that we choose `dimensions` as the default if none is provided for the same v1.1.
+This is our conservative default because of the mid-1.1 introduction of `fields` as preferred.
+The warning is in line with Metric View documentation saying that `fields` is to be considered the default.
+The default of `dimensions` is to support interoperability with any other tools that may have only targeted the original v1.1 specification from when it was first published.
+
+We treat the case of both keys in a definition as an error and will fail to deserialize such a Metric View.
+We are aware of no way to generate such a case other than by hand-editing YAML; certainly you cannot accidentally do this via the Semantic Bridge or any operations we expose.
+Such a Metric View definition, which uses both `dimensions` and `fields`, will need manual remediation.
+
+An important note on the `materialization` block of the Metric View YAML definition: this section of YAML continues to use only `dimensions` regardless of the top-level key used.
+[See the documentation for authoritative guidance on materialization](https://learn.microsoft.com/azure/databricks/business-semantics/metric-views/yaml-reference#materialization).
+
+Finally, there is no behavior or semantic difference in using either of `dimensions` or `fields`.
+These keywords are simply synonyms, with guidance that `fields` is to be preferred.
+
+## Metric View object model API change: `Dimension` to `Field`
+
+In light of guidance that `fields` is to be preferred, we have aligned to this throughout the Semantic Bridge.
+We ship a [Metric View object model for programmatic interaction with a Metric View](xref:semantic-bridge-metric-view-object-model), necessary for implementing the translations in the Semantic Bridge.
+We have deprecated the `Dimension` object, and all associated methods and properties that used "dimension" or "dimensions" in their name.
+We have created a new `Field` object, and new "field"-named methods and properties.
+The `Dimension` object and associated methods and properties will now give you a warning about their obsolete state.
+All `Dimension`-based code will continue to work, but we may remove these after a suitable amount of time has passed.
+Like Databricks, we recommend that you use `Field` and associated methods for all new work.
+
+In terms of implementation, all `Dimension`-based code passes through or mirrors the implementation of the `Field`-based code.
+While we recommend using `Field`, you can use both interchangeably.
+In general, migrating from `Dimension` to `Field` should be transparent.
+
+A technical note, [`Dimension`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension) is a subclass of `Field`.
+As such, there are a few ways in which you might observe differences between `Field` and `Dimension` code, and there are reasonable workarounds.
+To write code that survives `Dimension`'s removal, branch and declare against `Field`; never name or test the concrete `Dimension` type. Given a field `f`:
+
+| Avoid                                                            | Use instead                                            | Why it breaks when `Dimension` is removed                                 |
+|------------------------------------------------------------------|--------------------------------------------------------|---------------------------------------------------------------------------|
+| `f is Dimension`                                                 | `f is Field`                                           | `Dimension` stops compiling; `is Field` is true in both eras              |
+| `f is Dimension x`                                               | `f is Field x`                                         | same                                                                      |
+| `case Dimension x:`                                              | `case Field x:`                                        | same                                                                      |
+| `(Dimension)f`, `f as Dimension`                                 | use `f` directly as a `Field` (no cast)                | the cast target disappears; `f` already is a `Field`                      |
+| `f.GetType() == typeof(Dimension)`                               | `f is Field`                                           | `typeof(Dimension)` stops compiling                                       |
+| `f.GetType() == typeof(Field)`                                   | `f is Field`                                           | false now (runtime type is `Dimension`), true later, so it silently flips |
+| `f.GetType().Name == "Dimension"` (or `== "Field"`)              | `f is Field`; for a label, `f.ToString()` or `f.Name`  | the type-name string is `"Dimension"` now, `"Field"` later                |
+| `Dimension x = ...`, `List<Dimension>`, `IEnumerable<Dimension>` | `Field x = ...`, `view.Fields`, `IReadOnlyList<Field>` | the `Dimension` type name goes away                                       |
+| `typeof(Dimension)`, `nameof(Dimension)`                         | `typeof(Field)`, `nameof(Field)`                       | the `Dimension` symbol is removed                                         |
+| `MakeValidationRule<MetricView.Dimension>(...)`                  | `MakeValidationRule<MetricView.Field>(...)`            | the type argument references a removed type                               |
+
+> [!NOTE]
+> The object model deprecation of the `Dimension` type and any future removal of this type and associated methods will have no effect on serializing or deserializing with either YAML keyword.
+
+## Name reference: `Dimension` to `Field`
+
+The following table lists each deprecated `Dimension`-based name and its canonical `Field`-based replacement. The legacy names still compile (with an obsolete warning) and behave identically; prefer the canonical names in new scripts.
+
+| Legacy name (obsolete)                                          | Canonical name                                              | Where                                                                  |
+|-----------------------------------------------------------------|-------------------------------------------------------------|------------------------------------------------------------------------|
+| `MetricView.Dimension` (type)                                   | `MetricView.Field` (type)                                   | Object model                                                           |
+| `view.Dimensions`                                               | `view.Fields`                                               | `View` collection                                                      |
+| `view.Dimensions["name"]`                                       | `view.Fields["name"]`                                       | Name-based indexing into the collection                                |
+| `view.AddDimension(name, expr)`                                 | `view.AddField(name, expr)`                                 | `View` method                                                          |
+| `SemanticBridge.MetricView.MakeValidationRuleForDimension(...)` | `SemanticBridge.MetricView.MakeValidationRuleForField(...)` | Validation rule helper (both overloads, with and without `minVersion`) |
+| `context.DimensionNames`                                        | `context.FieldNames`                                        | Context passed to a validation rule                                    |
+
+## Related
+
+- @semantic-bridge
+- @semantic-bridge-metric-view-object-model
+- @semantic-bridge-metric-view-validation
+- [Metric View API](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView)
diff --git a/content/features/semantic-bridge-metric-view-object-model.md b/content/features/semantic-bridge-metric-view-object-model.md
index 62ec8efc7..c6a1faafd 100644
--- a/content/features/semantic-bridge-metric-view-object-model.md
+++ b/content/features/semantic-bridge-metric-view-object-model.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-metric-view-object-model
 title: Semantic Bridge Metric View Object Model
 author: Greg Baldini
-updated: 2026-04-17
+updated: 2026-06-29
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -24,24 +24,22 @@ SUMMARY: Overview of the Metric View object model built into the Semantic Bridge
 -->
 
 > [!NOTE]
-> The Semantic Bridge as released in 3.25.0 is in public preview.
-> It has limitations as documented below, and the API and feature surface area are subject to change.
-> The object model here conspicuously lacks many affordances available in the TOMWrapper which users may be familiar with from C# scripts that manipulate a Tabular model.
-> As noted in the [limitations of the Semantic Bridge](xref:semantic-bridge#public-preview-limitations), we currently only support Metric View v0.1 metadata.
+> The Semantic Bridge is in public preview.
+> The 3.25.0 release supports Metric View v0.1 metadata, and the 3.26.2 release supports Metric View v1.1 metadata.
 
-The Semantic Bridge includes an object model representing a Databricks Metric View.
+The Semantic Bridge includes an object model representing a [Metric View](https://learn.microsoft.com/azure/databricks/business-semantics/).
 This allows you to work with Metric Views programmatically through C# scripts, similar to how you work with a Tabular model through the TOMWrapper.
 
 Other than the [import GUI](xref:semantic-bridge#interface), all access to and interaction with a Metric View is through C# scripts.
-All content in this document is referring to C# code that you will use in a [C# script](xref:csharp-scripts).
+All content in this document is referring to C# code that you would use in a [C# script](xref:csharp-scripts).
 
 ## Loading and accessing the Metric View
 
-You can load a Metric view with [`SemanticBridge.MetricView.Load`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Load_System_String_) or [`SemanticBridge.MetricView.Deserialize`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Deserialize_System_String_).
-This stores the deserialized Metric View as [`SemanticBridge.MetricView.Model`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Model).
+You can load a Metric View with [`SemanticBridge.MetricView.Load`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Load%2A) or [`SemanticBridge.MetricView.Deserialize`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Deserialize%2A).
+This stores the deserialized Metric View as [`SemanticBridge.MetricView.Model`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Model).
 This property returns a [`View`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View) object, which is the root of the Metric View object graph.
 
-```csharp
+```csharp {compile}
 // Load a Metric View from disk
 SemanticBridge.MetricView.Load("C:/path/to/metricview.yaml");
 
@@ -55,74 +53,94 @@ This means that you can load a Metric View once, and reference it from subsequen
 There is only ever a single Metric View loaded, and it is available in all scripts as `SemanticBridge.MetricView.Model` as mentioned above.
 This behavior is similar to the Tabular model in C# scripts, which is always available simply as `Model`.
 
+[!INCLUDE [sample](../how-tos/includes/sample-metricview.md)]
+
 ## Domain objects
 
-The object model consists of four main types that correspond to the structure of a Metric View YAML file:
-We do not repeat the entire specification here, so we encourage you to reference the [Databricks Metric View documentation](https://learn.microsoft.com/en-us/azure/databricks/metric-views/).
+The object model consists of four main types that correspond to the structure of a Metric View YAML file.
+We do not repeat the entire specification here, so we encourage you to reference the [Metric View documentation](https://learn.microsoft.com/azure/databricks/business-semantics/)
+and our [own API reference for the object model](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView).
+
+| API Reference                                                                          | Description                                                |
+|----------------------------------------------------------------------------------------|------------------------------------------------------------|
+| [`View`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)       | The root object representing the entire Metric View        |
+| [`Join`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)       | A join definition connecting a dimension table to the fact |
+| [`Field`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field)     | A field definition (column) in the Metric View             |
+| [`Measure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure) | An aggregation definition representing business logic      |
 
-| API Reference                                                                              | Description                                                |
-|--------------------------------------------------------------------------------------------|------------------------------------------------------------|
-| [`View`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View)           | The root object representing the entire Metric View        |
-| [`Join`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join)           | A join definition connecting a dimension table to the fact |
-| [`Dimension`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension) | A field definition (column) in the Metric View             |
-| [`Measure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure)     | An aggregation definition representing business logic      |
+Most properties and attributes of a Metric View have a structured representation in the object model,
+but we defer discussion of these in this document,
+as those are all direct representations of the Metric View spec and documented in our API reference, mentioned above.
 
 > [!NOTE]
-> In the object model, we follow C# naming conventions, and so use `PascalCase` for all type and property names in the object model.
+> The object model was introduced in Tabular Editor 3.25.0 with support for Metric View v0.1.
+> Support for Metric View v1.1 was added in Tabular Editor 3.26.2;
+> this includes the `Comment` and `Materialization` properties on the `View`,
+> `Cardinality` and `Rely` on `Join`,
+> `Comment`, `DisplayName`, `Synonyms`, and `Format` on `Field` and `Measure`,
+> `Window` on `Measure`.
+
+> [!NOTE]
+> In the object model, we follow C# naming conventions: `PascalCase` for all type and property names.
 > The Metric View YAML specification follows a naming convention of `snake_case`.
-> In general, we focus on the C# object model that is a component of the Semantic Bridge.
-> Other than changing the case, we do not change any naming convention from the YAML.
+> Serialization and deserialization convert between these, so C# scripts use `PascalCase` and the YAML we read and write stays spec-compliant `snake_case`.
 
 ### View
 
-The [`View`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View) object is the root of the Metric View and contains:
+[The `View`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View) object is the root of the Metric View and contains:
 
-- `Version`: The Metric View specification version (e.g., "0.1")
+- `Version`: The Metric View specification version (e.g., "1.1")
 - `Source`: The source data for the fact table (e.g., "catalog.schema.table")
 - `Filter`: Optional SQL boolean expression that applies to all queries
-- `Joins`: Collection of join definitions
-- `Dimensions`: Collection of dimension (field) definitions
-- `Measures`: Collection of measure definitions
+- `Comment`: Optional description of the Metric View
+- `Joins`: Collection of join definitions; non-null empty collection if there are no `Join`s
+- `Fields`: Collection of field definitions; non-null empty collection if there are no `Field`s
+- `Measures`: Collection of measure definitions; non-null empty collection if there are no `Measure`s
+- `Materialization`: Materialization configuration for query acceleration when hosted on Databricks; [see the `Materialization` API reference](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Materialization)
 
-```csharp
+```csharp {run id=view-props setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
 sb.AppendLine($"Version: {view.Version}");
 sb.AppendLine($"Source: {view.Source}");
 sb.AppendLine($"Filter: {view.Filter ?? "(none)"}");
-sb.AppendLine($"Joins: {view.Joins?.Count ?? 0}");
-sb.AppendLine($"Dimensions: {view.Dimensions?.Count ?? 0}");
-sb.AppendLine($"Measures: {view.Measures?.Count ?? 0}");
+sb.AppendLine($"Joins: {view.Joins.Count}");
+sb.AppendLine($"Fields: {view.Fields.Count}");
+sb.AppendLine($"Measures: {view.Measures.Count}");
 
 Output(sb.ToString());
 ```
 
-#### `View` translation and validation
-
-The `View.Source` property becomes the fact table in the Tabular model, named `'Fact'`.
-If the `Source` is a 3-part table or view reference, it is translated to an M partition that accesses the SQL object by name.
-If the `Source` is not a 3-part table or view reference, it is translated to an M partition with an embedded SQL query, with the entirety of the `Source` string as the SQL query.
-The `Filter` property is ignored for purposes of translation.
+**Output**
 
-For purposes of evaluating validation rules, the `View` is checked first, then each collection is validated in order: `Joins`, then `Dimensions`, then `Measures`.
-Validation of the fact table, `Source` is done in a validation rule for the `View` object.
+```
+Version: 1.1
+Source: sales.fact.orders
+Filter: (none)
+Joins: 3
+Fields: 6
+Measures: 6
+```
 
 ### Join
 
-A [`Join`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join) represents a dimension table that is joined to the fact table:
+[A `Join`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Join) represents a dimension table that is joined to the fact table:
 
 - `Name`: Name of the joined table (used as an alias)
 - `Source`: Source table or query for the join (e.g., "catalog.schema.dimension_table")
 - `On`: Optional SQL boolean expression for the join condition
 - `Using`: Optional list of column names for the join (alternative to `On`)
 - `Joins`: Child joins (for snowflake schemas)
+- `ParentJoin`: if this is a nested join, then `ParentJoin` is a pointer to the parent, otherwise null
+- `Cardinality`: controls the relationship between `View.Source` or `ParentJoin` and this `Join`; [see the `JoinCardinality` API reference](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality)
+- `Rely`: Optimizer hints about the `Join`'s relationship to its parent; [see the `Rely` API reference](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Rely)
 
-```csharp
+```csharp {run id=join-props setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
-foreach (var join in view.Joins ?? [])
+foreach (var join in view.Joins)
 {
     sb.AppendLine($"Join: {join.Name}");
     sb.AppendLine($"  Source: {join.Source}");
@@ -135,70 +153,78 @@ foreach (var join in view.Joins ?? [])
 Output(sb.ToString());
 ```
 
-#### `Join` translation and validation
-
-Nested `Join`s are not supported, i.e., only a strict star schema can be translated.
-Only `On` joins with a single-field equijoin are supported for translation.
-`Join`s each become a Tabular table, with an M partition defined according to the same rules as for the `View.Source` property.
+**Output**
 
-`Join`s are validated in the order they appear in the Metric View definition.
+```
+Join: product
+  Source: sales.dim.product
+  On: source.product_id = product.product_id
+Join: customer
+  Source: sales.dim.customer
+  On: source.customer_id = customer.customer_id
+Join: date
+  Source: sales.dim.date
+  On: source.order_date = date.date_key
+```
 
-### Dimension
+### Field
 
-A [`Dimension`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension) represents a field (column) in the Metric View:
+[A `Field`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field) represents a field (column) in the Metric View:
 
-- `Name`: The display name for the dimension
-- `Expr`: The SQL expression defining the dimension (either a column reference or a SQL expression)
+- `Name`: The name of the field, referenced in Metric View expressions
+- `Expr`: The SQL expression defining the field (either a column reference or a SQL expression)
+- `Comment`: Optional description of the field
+- `DisplayName`: Optional human-readable display name for the field
+- `Synonyms`: Optional alternative names for the field, used by AI and BI tools
+- `Format`: Optional display format specification for the field's values; [see the `Format` API reference](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format)
 
-```csharp
+```csharp {run id=field-props setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
-foreach (var dim in view.Dimensions ?? [])
+foreach (var field in view.Fields)
 {
-    sb.AppendLine($"Dimension: {dim.Name}");
-    sb.AppendLine($"  Expression: {dim.Expr}");
+    sb.AppendLine($"Field: {field.Name}");
+    sb.AppendLine($"  Expression: {field.Expr}");
 }
 
 Output(sb.ToString());
 ```
 
-#### `Dimension` translation and validation
+**Output**
 
-Each `Dimension` becomes a column in the Tabular model.
-If the `Expr` is an unqualified field reference, it is added to the fact table.
-If the `Expr` is a qualified reference (e.g., `table.field`), then it is added to the table created for the `Join` with the same name as the table-part of the qualified reference; if the table-part is `source`, it is added to the fact table.
-In both the qualified and unqualified field reference cases, the field is added as a [`TOMWrapper.DataColumn`](xref:TabularEditor.TOMWrapper.DataColumn).
-If the `Expr` is a SQL expression, then it is added as [`TOMWrapper.CalculatedColumn`](xref:TabularEditor.TOMWrapper.CalculatedColumn).
-When the `Expr` is a SQL expression, we attempt to extract all field references; if all field references share the same table-part, then we add it to the table created for that `Join`, otherwise we add it to the fact table.
-We do not translate SQL expressions for `Dimension.Expr` properties; the SQL expression is included as a comment in the DAX expression for the `CalculatedColumn`.
-It is up to the user to translate these expressions.
-We attempt to identify all field references in the SQL expression and add those to the Tabular model as `DataColumn`s if they do not already exist as a Metric View `Dimension`.
-
-Some examples:
-
-| `Expr`                                                | Translated as type | Added to table  | Note                                                                         |
-|-------------------------------------------------------|--------------------|-----------------|------------------------------------------------------------------------------|
-| `field1`                                              | `DataColumn`       | `'Fact'`        | unqualified field references are equivalent to those qualified with `source` |
-| `source.field2`                                       | `DataColumn`       | `'Fact'`        | `source` is a reference to the `View.Source` property, aka the fact table    |
-| `dimCustomer.key`                                     | `DataColumn`       | `'dimCustomer'` | there must be a `Join` whose `Name` property is `dimCustomer`                |
-| `CONCAT(dimCustomer.FirstName, dimCustomer.LastName)` | `CalculatedColumn` | `'dimCustomer'` | all table-parts of the qualified name refer to the same name                 |
-| `CONCAT(dimGeo.Country, dimCustomer.Address)`         | `CalculatedColumn` | `'Fact'`        | there are multiple distinct table-parts                                      |
-
-`Dimension`s are validated in the order they appear in the Metric View definition.
+```
+Field: product_name
+  Expression: product.product_name
+Field: product_category
+  Expression: product.category
+Field: customer_segment
+  Expression: customer.segment
+Field: order_date
+  Expression: date.full_date
+Field: order_year
+  Expression: date.year
+Field: order_month
+  Expression: date.month_name
+```
 
 ### Measure
 
-A [`Measure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure) represents a named aggregation with business logic:
+[A `Measure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Measure) represents a named aggregation with business logic:
 
-- `Name`: The display name for the measure
+- `Name`: The name of the measure, referenced in Metric View expressions as `MEASURE(<name>)`
 - `Expr`: The SQL aggregate expression defining the measure
+- `Comment`: Optional description of the measure
+- `DisplayName`: Optional human-readable display name for the measure
+- `Synonyms`: Optional alternative names for the measure, used by AI and BI tools
+- `Format`: Optional display format specification for the measure's values; [see the `Format` API reference](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format)
+- `Window`: Optional list of window specifications for windowed or semi-additive aggregation; [see the `Window` API reference](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Window)
 
-```csharp
+```csharp {run id=measure-props setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
-foreach (var measure in view.Measures ?? [])
+foreach (var measure in view.Measures)
 {
     sb.AppendLine($"Measure: {measure.Name}");
     sb.AppendLine($"  Expression: {measure.Expr}");
@@ -207,28 +233,29 @@ foreach (var measure in view.Measures ?? [])
 Output(sb.ToString());
 ```
 
-#### `Measure` translation and validation
+**Output**
 
-All measures are added to the fact table.
-Simple aggregations are translated into DAX expressions.
-A simple aggregation is a single aggregation of a single field (e.g. `SUM(table.field)`).
-Supported aggregations are sum, count, distinct count, max, min, and average.
-Other expressions are passed through as a comment in the DAX expression of the Tabular measure.
-We attempt to identify all field references in the SQL expression and add those to the Tabular model as `DataColumn`s if they do not already exist as a Metric View `Dimension`.
-
-> [!WARNING]
-> SQL and DAX are different languages with different semantics.
-> It is possible that an automatically translated measure does not express the same computation in both Databricks Metric Views and Tabular models.
-> It is up to the user to verify all code works as expected.
-
-`Measure`s are validated in the order they appear in the Metric View definition.
+```
+Measure: total_revenue
+  Expression: SUM(revenue)
+Measure: gross_margin
+  Expression: SUM(revenue) - SUM(cost)
+Measure: order_count
+  Expression: COUNT(*)
+Measure: avg_order_value
+  Expression: AVG(revenue)
+Measure: revenue_to_budget
+  Expression: (SUM(revenue) - SUM(budget)) / SUM(budget)
+Measure: unique_customers
+  Expression: COUNT(DISTINCT customer_id)
+```
 
 ## Using directives
 
 When working with the Metric View object model in C# scripts, you may need to add a using directive to avoid naming conflicts with similarly-named types in the Tabular Object Model.
 We recommend aliasing the namespace:
 
-```csharp
+```csharp {compile}
 // Alias to avoid conflicts with TOM types like Measure
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
@@ -236,62 +263,75 @@ SemanticBridge.MetricView.Load("C:/path/to/metricview.yaml");
 var view = SemanticBridge.MetricView.Model;
 
 // Now you can reference types explicitly
-foreach (MetricView.Dimension dim in view.Dimensions ?? [])
+foreach (MetricView.Field field in view.Fields)
 {
     // ...
 }
 ```
 
-## Complete example
+## Interacting with the object model
 
-Here is a complete script that loads a Metric View and outputs a summary of its contents:
+This document describes the patterns of using the object model.
+See [the Semantic Bridge how-tos for detailed copy and paste-able examples](xref:semantic-bridge-how-tos).
 
-```csharp
-using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
+### `View` parent pointer
 
-// Load the Metric View
+All core Metric View objects described in this document inherit from [`MetricViewObjectBase`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.MetricViewObjectBase) for their core functionality.
+Among other things, this means that each holds a `View` pointer back up to the Metric View they are defined in.
+This allows you to inspect the whole Metric View when holding any of these objects.
+
+```csharp {compile}
 SemanticBridge.MetricView.Load("C:/path/to/metricview.yaml");
-var sb = new System.Text.StringBuilder();
-var view = SemanticBridge.MetricView.Model;
+var v = SemanticBridge.MetricView.Model; // alias the Metric View as v just for concision
+var f = v.Fields.FirstOrDefault(); // f is the first field defined in the Metric View
+Output(f.View == v); // the field, f, lets you navigate up to the containing view
+```
 
-// sb.AppendLine summary
-sb.AppendLine("=== Metric View Summary ===");
-sb.AppendLine($"Version: {view.Version}");
-sb.AppendLine($"Source: {view.Source}");
+### Adding objects
 
-if (view.Joins != null && view.Joins.Count > 0)
-{
-    sb.AppendLine($"\nJoins ({view.Joins.Count}):");
-    foreach (var join in view.Joins)
-    {
-        sb.AppendLine($"  - {join.Name} -> {join.Source}");
-    }
-}
+You never instantiate a `View`, `Join`, `Field`, or `Measure` directly.
+Instead, deserialize or load a base `View`, or use the various `Add` methods:
 
-if (view.Dimensions != null && view.Dimensions.Count > 0)
-{
-    sb.AppendLine($"\nDimensions ({view.Dimensions.Count}):");
-    foreach (var dim in view.Dimensions)
-    {
-        sb.AppendLine($"  - {dim.Name}: {dim.Expr}");
-    }
-}
+- New Metric View:
+  - [`Deserialize`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Deserialize%2A) YAML in a string
+  - [`Load`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Load%2A) a YAML file from disk
+- Add objects
+  - [`view.AddJoin`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddJoin%2A)
+  - [`view.AddField`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField%2A)
+  - [`view.AddMeasure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddMeasure%2A)
 
-if (view.Measures != null && view.Measures.Count > 0)
-{
-    sb.AppendLine($"\nMeasures ({view.Measures.Count}):");
-    foreach (var measure in view.Measures)
-    {
-        sb.AppendLine($"  - {measure.Name}: {measure.Expr}");
-    }
-}
+`Deserialize` and `Load` both set the global `SemanticBridge.MetricView.Model` so you can interact with it in scripts.
+The `Add` methods all return the new object just added so that you can interact with it and set additional properties;
+this mirrors the interaction with TOM objects you are already familiar with in C# scripts.
 
-Output(sb.ToString());
-```
+### Modify properties
+
+The Metric View object model is mutable throughout, so you can simply set properties directly.
+C# autocompletion in Tabular Editor 3 will help with finding the right properties and types to use.
+All properties and their types are in [the API documentation](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView).
+
+### Accessing objects by name
+
+The root `View` contains collections for `Joins`, `Fields`, and `Measures`.
+Each `Join` contains a child `Joins` collection.
+Each of these can be indexed by name;
+this looks up the child object by its `Name` property.
+This lookup is case insensitive, matching the default in Databricks SQL.
+
+### Metric View versions
+
+We track the [Metric View documentation](https://learn.microsoft.com/azure/databricks/business-semantics/) to stay up to date with the specification.
+All properties are annotated with the version that they were introduced.
+Thanks to this, the object model will raise exceptions and surface diagnostics if you attempt to set a property that is not allowed for a given version of the spec.
+We recommend always running [`SemanticBridge.MetricView.Validate();`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Validate) after modifying a Metric View in a C# script;
+this will check all default validation rules for correctness.
 
 ## References
 
 - [`MetricView` namespace API documentation](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView)
-- @semantic-bridge-how-tos
-- [Databricks Metric View documentation](https://learn.microsoft.com/en-us/azure/databricks/metric-views/)
-- [Databricks Metric View YAML specification](https://learn.microsoft.com/en-us/azure/databricks/metric-views/data-modeling/syntax)
+- @semantic-bridge-metric-view-fields-and-dimensions
+- @semantic-bridge-metric-view-validation
+- @semantic-bridge-metric-view-tabular-translation
+- [Semantic Bridge how-tos for detailed examples](xref:semantic-bridge-how-tos)
+- [Metric View documentation](https://learn.microsoft.com/azure/databricks/business-semantics/)
+- [Metric View YAML specification](https://learn.microsoft.com/azure/databricks/business-semantics/metric-views/yaml-reference)
diff --git a/content/features/semantic-bridge-metric-view-tabular-translation.md b/content/features/semantic-bridge-metric-view-tabular-translation.md
new file mode 100644
index 000000000..92ffa33e5
--- /dev/null
+++ b/content/features/semantic-bridge-metric-view-tabular-translation.md
@@ -0,0 +1,242 @@
+---
+uid: semantic-bridge-metric-view-tabular-translation
+title: Metric View to Tabular translation
+author: Greg Baldini
+updated: 2026-06-30
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      none: true
+    - product: Tabular Editor 3
+      since: 3.25.0
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          none: true
+        - edition: Enterprise
+          full: true
+---
+# Metric View to Tabular translation
+
+<!--
+SUMMARY: Describes the process and specifics of translating a Metric View to a TOM model.
+-->
+
+> [!NOTE]
+> The Semantic Bridge is in public preview.
+> The 3.25.0 release supports Metric View v0.1 metadata, and the 3.26.2 release supports Metric View v1.1 metadata.
+> Limitations are described below.
+
+This page describes how translation works when importing a Metric View definition into a Tabular model.
+
+## Translation process
+
+Translating a Metric View to a Tabular model happens in several steps:
+
+1. Read the YAML from disk
+2. Deserialize the YAML
+3. Validate that the deserialized YAML represents a valid Metric View
+4. If it is a valid Metric View, store it as the currently loaded Metric View, similar to how there is a loaded Tabular model that you interact with.
+   If it is not a valid Metric View, the process stops here and diagnostic messages are available.
+5. Analyze the Metric View and attempt to transform it to an intermediate representation
+6. Attempt to transform the intermediate representation to a Tabular model
+
+The import GUI handles all of this for you, but you can also use C# scripts to customize different steps of the process and operate on the Metric View programmatically, similarly to how you are used to doing with a Tabular model.
+Specifically, you can
+
+- load a Metric View from disk with [`SemanticBridge.MetricView.Load`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Load%2A): loading makes it available in C# scripts as [`SemanticBridge.MetricView.Model`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Model), but does not import the structure into the Tabular model
+- deserialize a Metric View from a string with [`SemanticBridge.MetricView.Deserialize`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Deserialize%2A): similar to loading, the model is available as [`SemanticBridge.MetricView.Model`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Model), but is not imported
+- save a Metric View to disk with [`SemanticBridge.MetricView.Save`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Save%2A)
+- serialize a Metric View to a string with [`SemanticBridge.MetricView.Serialize`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Serialize%2A).
+- validate a Metric View using a system that is similar to the [Best Practice Analyzer](xref:best-practice-analyzer) with [`SemanticBridge.MetricView.Validate`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Validate%2A)
+	- you can create your own custom validation rules with [`SemanticBridge.MetricView.MakeValidationRule`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule%2A) and its simpler versions
+- import a Metric View to Tabular with [`SemanticBridge.MetricView.ImportToTabularFromFile`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.ImportToTabularFromFile%2A), which does the exact same as the import GUI, or [`SemanticBridge.MetricView.ImportToTabular`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.ImportToTabular%2A), which is similar, but operates on the currently loaded Metric View, rather than reading one from disk.
+
+### Per object translation notes
+
+The four items below, `View`, `Join`, `Field`, and `Measure`, are the core objects of a Metric View definition that become TOM objects.
+Other metadata in the Metric View definition are either ignored or modify exactly how these objects are translated.
+
+> [!NOTE]
+> The translation is performed upon the Metric View object model, so we discuss everything in these terms.
+> See [the Metric View object model docs](xref:semantic-bridge-metric-view-object-model) for specifics of the object model and how it aligns to the YAML spec.
+
+#### `View` translation
+
+- translate
+	- `Source`: becomes the single fact table, named 'Fact' in the TOM model
+	- `Comment`: becomes TOM `Model.Description`
+	- `Joins`: see `Join`
+	- `Fields`: see `Field`
+	- `Measures`: see `Measure`
+- do not translate
+	- `Filter`
+	- `Materialization`
+
+If the `Source` is a 3-part table or view reference, it is translated to an M partition that accesses the SQL object by name.
+If the `Source` is not a 3-part table or view reference, it is translated to an M partition with an embedded SQL query, with the entirety of the `Source` string as the SQL query.
+
+The `Filter` property is ignored for purposes of translation;
+if you need the logic included in `Filter`, you will have to manually add this.
+The `Filter` expression applies to all queries against the Metric View, and so a full automated translation would require joining all tables named in `Joins` in generated M code in TOM.
+
+Any defined `Materialization` is ignored for the purposes of translation;
+these are query optimization metadata for executing queries on Databricks and not relevant to a TOM model.
+
+#### `Join` translation
+
+- translated
+  - `Name`: becomes TOM table name
+  - `Source`: becomes M partition on table
+  - `On`: becomes a TOM relationship
+  - `Joins`: become additional TOM tables
+  - `Cardinality`
+- untranslated
+  - `Using`
+  - `Rely`
+
+`Join`s each become a TOM table, with an M partition defined according to the same rules as for the `View.Source` property.
+
+`On` equijoins (e.g., `source.fk = dimTable.pk`) become TOM relationships.
+Any other predicate in an `On` property is not translated as a relationship.
+
+Trees of `Join`s in a Metric View are translated as TOM tables in a chain of N:1 relationships, where the cardinalities are supported (see note on cardinality below).
+This represents a snowflake model schema.
+
+`Cardinality` of `ManyToOne` is translated as a TOM N:1 relationship.
+An unpopulated `Cardinality` or a `Join` without this property set is treated as `ManyToOne` by default, in accordance with [Metric View docs](https://learn.microsoft.com/azure/databricks/business-semantics/metric-views/yaml-reference#joins).
+Other values for `Cardinality` are not yet supported for translation as a relationship.
+
+`Using` joins are not supported for translation; these do not yield a TOM relationship.
+
+`Rely` is not propagated into the TOM model in any way.
+
+In cases where a TOM relationship is not created, we still create a TOM table and translate all Metric View `Fields` to TOM columns as described elsewhere.
+
+> [!NOTE]
+> Databricks has recently introduced a new pattern using `OneToMany` cardinality against multiple `Join` sub-trees to implement a multi-fact model.
+> We do not yet translate this pattern fully: we bring over all tables, fields, and measures, but do not create all relationships.
+> A diagnostic warning is shown when importing a model following this pattern.
+
+#### `Field` translation
+
+- translated
+  - `Name`
+  - `DisplayName`
+  - `Expr`
+  - `Comment`: becomes TOM column's `Description` property
+  - `Format`: becomes TOM column's `FormatString` property; see section below on `Format` translation
+- untranslated
+  - `Synonyms`
+
+Each `Field` becomes a column in the Tabular model.
+
+The TOM column's `Name` is `Field.DisplayName` if it is populated,
+otherwise it is `Field.Name`.
+
+If the `Expr` is an unqualified field reference, it is added to the fact table.
+If the `Expr` is a qualified reference (e.g., `table.field`),
+then it is added to the table created for the `Join` with the same name as the table-part of the qualified reference;
+if the table-part is `source`, it is added to the fact table.
+In both the qualified and unqualified field reference cases,
+the field is added as a [`TOMWrapper.DataColumn`](xref:TabularEditor.TOMWrapper.DataColumn).
+If the `Expr` is a SQL expression,
+then it is added as [`TOMWrapper.CalculatedColumn`](xref:TabularEditor.TOMWrapper.CalculatedColumn).
+When the `Expr` is a SQL expression, we extract all field references;
+if all field references share the same table-part,
+then we add it to the table created for that `Join`,
+otherwise we add it to the fact table.
+We identify all field references in the SQL expression and add those to the Tabular model as `DataColumn`s if they do not already exist as a Metric View `Field`.
+We do not translate SQL expressions for `Field.Expr` properties;
+the SQL expression is included as a comment in the DAX expression for the `CalculatedColumn`.
+It is up to the user to translate these expressions.
+
+Some examples:
+
+| `Expr`                                                | Translated as type | Added to table  | Note                                                                         |
+|-------------------------------------------------------|--------------------|-----------------|------------------------------------------------------------------------------|
+| `field1`                                              | `DataColumn`       | `'Fact'`        | unqualified field references are equivalent to those qualified with `source` |
+| `source.field2`                                       | `DataColumn`       | `'Fact'`        | `source` is a reference to the `View.Source` property, aka the fact table    |
+| `dimCustomer.key`                                     | `DataColumn`       | `'dimCustomer'` | there must be a `Join` whose `Name` property is `dimCustomer`                |
+| `CONCAT(dimCustomer.FirstName, dimCustomer.LastName)` | `CalculatedColumn` | `'dimCustomer'` | all table-parts of the qualified name refer to the same name                 |
+| `CONCAT(dimGeo.Country, dimCustomer.Address)`         | `CalculatedColumn` | `'Fact'`        | there are multiple distinct table-parts                                      |
+
+
+#### `Measure` translation
+
+- translated
+  - `Name`
+  - `DisplayName`
+  - `Expr`: becomes TOM measure's `Expression` property; see section below on SQL -> DAX translation
+  - `Comment`: becomes TOM measure's `Description` property
+  - `Format`: becomes TOM measure's `FormatString` property; see section below on `Format` translation
+- untranslated
+  - `Synonyms`
+  - `Window`
+
+All measures are added to the fact table.
+
+The TOM measure's `Name` is the Metric View's `Measure.DisplayName` if it exists,
+otherwise it is the Metric View's `Measure.Name`.
+
+`Expr` is translated to DAX or passed through as a comment in cases where we cannot automatically translate the measure.
+We identify all field references in the SQL expression and add those to the Tabular model as `DataColumn`s if they do not already exist as a Metric View `Field`.
+
+Window specifications are not translated and cause fallback to a DAX comment, regardless of the SQL in `Expr`.
+
+### `Format` translation
+
+A Metric View `Format` is translated to a TOM `FormatString` on the object that carries it.
+The target is a VBA-style format string, as used in TOM models.
+The translation is best-effort:
+if we can create a format string that exactly matches the configuration of the `Format`, then we do so;
+if we cannot create an exact equivalent, then we fall back to an approximate equivalent and emit a warning you can review after import.
+
+Currency, percentage, and number formats translate cleanly:
+currency becomes a currency-symbol prefix on a grouped numeric format,
+percentage becomes a percent format that honors the declared decimal places,
+and number honors the declared decimal places and group separator, with the scientific abbreviation becoming an exponential format.
+
+Year-month-day dates translate cleanly to an ISO date format;
+locale long-month and locale numeric-month dates translate cleanly to the `Long Date` and `Short Date` named formats;
+and hour-minute and hour-minute-second times translate cleanly to the `Short Time` and `Long Time` named formats.
+
+The remaining formats cannot be precisely translated and emit a warning:
+the compact number abbreviation and the byte format fall back to a plain numeric format;
+the locale short-month date falls back to `Long Date`;
+the year-week date falls back to an ISO date;
+and a combined date-and-time format falls back to an ISO composite.
+
+### SQL -> DAX translation
+
+Metric Views provide a structured layer on top of SQL expressions, and so part of translating a Metric View is translating SQL to DAX and M in the Tabular model.
+Supported aggregations are sum, count, distinct count, max, min, and average.
+Basic arithmetic, common counting patterns, measure references, and parenthesis precedence are all supported for SQL->DAX translation.
+
+> [!WARNING]
+> Note that SQL and DAX are different languages with different semantics.
+> We can make no guarantee that a translated measure will behave identically between the Metric View SQL and the Tabular DAX we generate.
+> Basic aggregates defined on fact table fields should behave the same, whereas aggregates defined on fields in dimension tables are more likely to produce undesired results.
+
+## Common terms across Metric Views and Tabular models
+
+For those of our users who may be unfamiliar with either Metric Views or Tabular models, we provide an incomplete rosetta stone below.
+We refer to the names of Metric View objects based on their representation in YAML, and Tabular based on the name of the type of object in TMDL/TMSL.
+
+| General term         | Name in Tabular | Name in Metric View   | Description                                                                                          | Note                                                                                                                                                                                                                                       |
+|----------------------|-----------------|-----------------------|------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| fact                 | table           | source                | A table holding foreign keys to dimensions and quantitative values to be aggregated                  | a Metric View has a single fact which is unnamed and captured as the root-level `source` attribute in YAML. Tabular models do not differentiate between types of tables: whether a table is a fact can only be inferred                    |
+| dimension            | table           | join                  | A table holding descriptive attributes and one primary key to which the fact is related              | Tabular models do not differentiate, so the role of "dimension" is inferred only, as with a fact.                                                                                                                                          |
+| partition            | partition       | source (join only)    | An object for data management, holding a subset of data in a table                                   | Tabular model tables can have many partitions and must have at least one. The Metric View fact, as mentioned above is defined purely as a source, but Metric View joins also have a `source` property, which acts roughly like a partition |
+| field                | column          | field                 | A column in a table                                                                                  |                                                                                                                                                                                                                                            |
+| measure              | measure         | measure               | A quantitative value that is aggregated according to business logic in the model                     | Measures in a Tabular model are written in DAX, and in a Metric View in SQL                                                                                                                                                                |
+| join or relationship | relationship    | join.on or join.using | A correspondence between key fields in two tables, a foreign key in one and primary key in the other | Relationships are explicit objects in a Tabular model, and implicitly defined as a property of the `join` object in Metric View YAML                                                                                                       |
+
+## Additional references
+
+- @semantic-bridge
+- @semantic-bridge-metric-view-object-model
+- @semantic-bridge-metric-view-validation
+- @semantic-bridge-how-tos
+- [Metric View API docs](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView)
diff --git a/content/features/semantic-bridge-metric-view-validation.md b/content/features/semantic-bridge-metric-view-validation.md
index 8652e7328..459ae17be 100644
--- a/content/features/semantic-bridge-metric-view-validation.md
+++ b/content/features/semantic-bridge-metric-view-validation.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-metric-view-validation
 title: Semantic Bridge Metric View Validation
 author: Greg Baldini
-updated: 2026-04-17
+updated: 2026-07-01
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -24,7 +24,8 @@ SUMMARY: Describes the validation framework for Metric Views in the Semantic Bri
 -->
 
 There is a validation framework built into the Semantic Bridge to allow users to validate and define rules to check a Metric View before importing it to Tabular.
-This validation is shared at every stage of the translation pipeline, from first deserializing the Metric View, through to errors in translation to DAX and Tabular.
+This diagnostic reporting is shared at every stage of the translation pipeline,
+from first deserializing the Metric View, through to errors in translation to DAX and Tabular.
 
 > [!NOTE]
 > The Semantic Bridge is currently in public preview, so interfaces may change as the feature matures.
@@ -38,7 +39,8 @@ There are several phases of validation
 2. acting on the loaded Metric View
 3. upon translating the Metric View to Tabular
 
-The first and third are automatic and internal to the Semantic Bridge, but the second is where users can provide their own validation rules.
+The first and third are automatic and internal to the Semantic Bridge,
+but the second is where users can provide their own validation rules.
 
 Validation is a process of evaluating each of a set of validation rules against all objects in the Metric View.
 A validation rule is defined to apply to exactly one type of Metric View object, e.g. a `Join` or `Measure`.
@@ -46,14 +48,14 @@ After a validation is complete, all diagnostics from rule violations are returne
 
 ## Anatomy of a validation rule
 
-Validation rules are all instances of [`IMetricViewValidationRule`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule.html).
+Validation rules are all instances of [`IMetricViewValidationRule`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.Interfaces.IMetricViewValidationRule).
 Rather than dig into that interface, it is easier to understand and work with validation rules with the helper methods:
 
-- [`MakeValidationRuleForDimension`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_MakeValidationRuleForDimension_System_String_System_String_System_String_System_Func_TabularEditor_SemanticBridge_Platforms_Databricks_MetricView_Dimension_System_Boolean__)
-- [`MakeValidationRuleForJoin`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_MakeValidationRuleForJoin_System_String_System_String_System_String_System_Func_TabularEditor_SemanticBridge_Platforms_Databricks_MetricView_Join_System_Boolean__)
-- [`MakeValidationRuleForMeasure`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_MakeValidationRuleForMeasure_System_String_System_String_System_String_System_Func_TabularEditor_SemanticBridge_Platforms_Databricks_MetricView_Measure_System_Boolean__)
-- [`MakeValidationRuleForView`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_MakeValidationRuleForView_System_String_System_String_System_String_System_Func_TabularEditor_SemanticBridge_Platforms_Databricks_MetricView_View_System_Boolean__)
-- [`MakeValidationRule`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_MakeValidationRule__1_System_String_System_String_System_Func___0_TabularEditor_SemanticBridge_Platforms_Databricks_Validation_IReadOnlyValidationContext_System_Collections_Generic_IEnumerable_TabularEditor_SemanticBridge_Orchestration_DiagnosticMessage___)
+- [`MakeValidationRuleForField`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForField%2A)
+- [`MakeValidationRuleForJoin`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForJoin%2A)
+- [`MakeValidationRuleForMeasure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForMeasure%2A)
+- [`MakeValidationRuleForView`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRuleForView%2A)
+- [`MakeValidationRule`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.MakeValidationRule%2A)
 
 The first four are all special purpose to make a rule for the object type in their name.
 They offer a simplified interface where you provide:
@@ -65,32 +67,36 @@ They offer a simplified interface where you provide:
 
 The name and category are intended to make it easier to deal with collections of rules, as you will do in C# scripts that utilize custom rules.
 
+Each of these helpers also has an overload with a final `minVersion` argument.
+This argument would take a version string, such as "0.1" or "1.1".
+Rules with `minVersion` set are only evaluated for Metric Views at or above that version.
+
 This is easier to understand with an example:
 
-```csharp
-// create a rule to check for underscores in dimension names
-var myRule = SemanticBridge.MetricView.MakeValidationRuleForDimension(
+```csharp {compile}
+// create a rule to check for underscores in field names
+var myRule = SemanticBridge.MetricView.MakeValidationRuleForField(
 	"no_underscores",
 	"naming",
-	"Do not include underscores in dimension names. Use user-friendly names with spaces.",
-	(dimension) => dimension.Name.Contains('_')
+	"Do not include underscores in field names. Use user-friendly names with spaces.",
+	(field) => field.Name.Contains('_')
 	);
 ```
 
-This makes a rule that will apply to all [Metric View `Dimension`s](/api/TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Dimension.html).
+This makes a rule that will apply to all [Metric View `Field`s](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Field).
 The rule is named (ironically) "no_underscores".
 It has a category of "naming", to indicate that it has to do with how we name things.
-The message you will see when the rule is violated is, "Do not include underscores in dimension names. Use user-friendly names with spaces."
-The last argument defines a function that will be called for each Metric View dimension in the model; its body is a boolean expression that returns `true` for a Metric View dimension with an underscore in its `Name` property.
+The message you will see when the rule is violated is, "Do not include underscores in field names. Use user-friendly names with spaces."
+The last argument defines a function that will be called for each Metric View field in the model; its body is a boolean expression that returns `true` for a Metric View field with an underscore in its `Name` property.
 
 Here's a full script that defines a Metric View inline, and then deserializes and validates it, showing how this rule is used.
 
-```csharp
+```csharp {run id=simple setup=none after=none output=true}
 // create a new simple Metric View
 SemanticBridge.MetricView.Deserialize("""
-    version: 0.1
+    version: 1.1
     source: database.schema.table
-    dimensions:
+    fields:
       - name: first_field
         expr: source.first_field
       - name: another field with no underscores
@@ -98,22 +104,37 @@ SemanticBridge.MetricView.Deserialize("""
     """);
 
 // create a new validation rule
-var myRule = SemanticBridge.MetricView.MakeValidationRuleForDimension(
+var myRule = SemanticBridge.MetricView.MakeValidationRuleForField(
     "no_underscores",
     "naming",
-    "Do not include underscores in dimension names. Use user-friendly names with spaces.",
-    (dimension) => dimension.Name.Contains('_')
+    "Do not include underscores in field names. Use user-friendly names with spaces.",
+    (field) => field.Name.Contains('_')
     );
 
 // run validation with the rule defined above and output the diagnostic messages
-Output(SemanticBridge.MetricView.Validate([myRule]));
+var sb = new System.Text.StringBuilder();
+foreach (var d in SemanticBridge.MetricView.Validate([myRule]))
+{
+    sb.AppendLine($"[{d.Severity}] {d.Code} {d.Path}");
+    sb.AppendLine($"    {d.Context} {d.Message}");
+    sb.AppendLine();
+}
+Output(sb.ToString());
+```
+
+**Output**
+
+```
+[Error] no_underscores Model.Fields["first_field"]
+     Do not include underscores in field names. Use user-friendly names with spaces.
 ```
 
-You can see that one of the fields defined as a Metric View dimension has an underscore in its name.
+You can see that one of the Metric View fields has an underscore in its name.
 When you run the script, you can see one diagnostic message after validating with the rule we defined.
 You can see the details that are provided in the diagnostic message:
 
-- Code, Context: not used when you use one of these helper methods to make your rule
+- Code: the name you assign to your rule
+- Context: not set by these helpers
 - Message: the message you defined in the rule
 - Path: a representation of where you find that object in the Metric View
 - Severity: set to Error by default with these helpers
@@ -122,42 +143,65 @@ You can see the details that are provided in the diagnostic message:
 
 If you want more control over the diagnostic message and more flexibility in the function for your validation, you can use `MakeValidationRule` mentioned above to make a contextual validation rule.
 
-```csharp
+```csharp {run id=contextual setup=none after=none output=true}
 // necessary to use the Metric View object model
 // aliasing to avoid conflicts with same-named TOM objects
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
 // create a new simple Metric View
 SemanticBridge.MetricView.Deserialize("""
-    version: 0.1
+    version: 1.1
     source: database.schema.table
-    dimensions:
-      - name: same_field
-        expr: source.same_field
-      - name: same_field
-        expr: source.same_field
+    fields:
+      - name: customer
+        expr: source.customer_id
+      - name: repeat_customer
+        expr: source.customer_id
     """);
 
 // create a new validation rule
-var myRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Dimension>(
-    "no_duplicate_dimensions",
-    "naming",
-    (dimension, context) =>
-        context.DimensionNames.Contains(dimension.Name)
-            ? [context.MakeError($"{dimension.Name} appears more than once as a dimension")]
-            : []
-    );
+var myRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Field>(
+    "no_aliased_fields",
+    "modeling",
+    (field, context) =>
+    {
+        var original = context.FieldNames.FirstOrDefault(seen => field.View.Fields[seen].Expr == field.Expr);
+        return original == null
+            ? []
+            : [context.MakeError(
+                "field_alias",
+                $"Field '{field.Name}' reuses source expression '{field.Expr}', already used by field '{original}'.",
+                field)];
+    });
 
 // run validation with the rule defined above and output the diagnostic messages
-Output(SemanticBridge.MetricView.Validate([myRule]));
+var sb = new System.Text.StringBuilder();
+foreach (var d in SemanticBridge.MetricView.Validate([myRule]))
+{
+    sb.AppendLine($"[{d.Severity}] {d.Code} {d.Path}");
+    sb.AppendLine($"    {d.Context} {d.Message}");
+    sb.AppendLine();
+}
+Output(sb.ToString());
+```
+
+**Output**
+
+```
+[Error] field_alias Model.Fields["repeat_customer"]
+     Field 'repeat_customer' reuses source expression 'source.customer_id', already used by field 'customer'.
 ```
 
-This helper method requires you to pass the object type as a type parameter, and the validation function now is a two-parameter function, defined with the signature `(objectType, context)`.
+This helper method requires you to pass the object type as a type parameter, and the validation function now is a two-parameter function, defined with the signature `(metricViewObject, context)`.
 The first parameter is the Metric View object that the rule is evaluated for.
-The second parameter is an [`IReadOnlyValidationContext`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext.html).
-This context object holds collections with the names of already-checked objects; this makes it useful to check for duplicate names.
-The context object also has a helper method to make a new diagnostic message; the benefit here is that your message doesn't have to be a hard-coded string, but can include properties of the object you are checking.
-You can see in this example that we include the duplicated Metric View dimension name in the message.
+The second parameter is an [`IReadOnlyValidationContext`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.Validation.IReadOnlyValidationContext).
+This context object holds collections with the names of already-checked objects;
+this means we can use it to inspect only objects already validated.
+The context object also has helper methods to make a new diagnostic message;
+the benefit here is that your message doesn't have to be a hard-coded string,
+but can include properties of the object you are checking.
+We use `MakeError`, and the context object also includes a `MakeWarning`.
+You can see in this example that we include in the message both the offending field and the field it aliases.
 
 ![output from one field violating the more complex validation rule](~/content/assets/images/features/semantic-bridge/semantic-bridge-metric-view-validation2.png)
 
@@ -165,7 +209,7 @@ You can see in this example that we include the duplicated Metric View dimension
 
 It is a good idea to make many simple rules, rather than fewer, more complex rules.
 The validation process is very light-weight, so there are not performance concerns from a proliferation of rules.
-For example, if you want to make sure that Metric View dimension names are not `camelCased`, not `kebab-cased` and not `snake_cased`, it is better to make three separate rules, rather than trying to check for each of those conditions in a single rule.
+For example, if you want to make sure that Metric View field names are not `camelCased`, not `kebab-cased` and not `snake_cased`, it is better to make three separate rules, rather than trying to check for each of those conditions in a single rule.
 This allows each rule to be simple, and for the messages to be very specific, and therefore more easily actionable.
 
 In general, once you have a rule that catches a specific issue, it is better to leave that alone, rather than editing it.
@@ -173,7 +217,7 @@ If you find that the rule is missing some condition you'd like to catch, just ad
 
 You can save many different rules in a C# script for re-use with different Metric Views.
 Because [a loaded Metric View is accessible in multiple scripts](xref:semantic-bridge-metric-view-object-model#loading-and-accessing-the-metric-view) you can save C# scripts that only define rules and then call `SemanticBridge.MetricView.Validate`, and re-use those validation scripts easily.
-See the image below, where the script on the left, "load-mv.csx" has already been run, to load a Metric View to Tabular Editor.
+See the image below, where the script on the left, "deserialize-mv.csx" has already been run, to load a Metric View to Tabular Editor.
 Then, the second script, on the right, "run-rules.csx", is run second to validate.
 This second script could be one that you keep around for all of your Metric Views.
 
@@ -182,50 +226,74 @@ This second script could be one that you keep around for all of your Metric View
 
 The scripts are copied below for convenience, but are just rearrangements of scripts we saw above.
 
-**"load-mv.csx"**
+**"deserialize-mv.csx"**
 
-```csharp
+```csharp {run id=deserialize setup=none after=none output=false}
 // create a new simple Metric View
 SemanticBridge.MetricView.Deserialize("""
-    version: 0.1
+    version: 1.1
     source: database.schema.table
-    dimensions:
-      - name: same_field
-        expr: source.same_field
-      - name: same_field
-        expr: source.same_field
+    fields:
+      - name: customer
+        expr: source.customer_id
+      - name: repeat_customer
+        expr: source.customer_id
     """);
 ```
 
 **"run-rules.csx"**
 
-```csharp
+```csharp {run id=run-rules setup=none after=deserialize output=true}
 // necessary to use the Metric View object model
 // aliasing to avoid conflicts with same-named TOM objects
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
 //create a simple validation rule
-var simpleRule = SemanticBridge.MetricView.MakeValidationRuleForDimension(
+var simpleRule = SemanticBridge.MetricView.MakeValidationRuleForField(
     "no_underscores",
     "naming",
-    "Do not include underscores in dimension names. Use user-friendly names with spaces.",
-    (dimension) => dimension.Name.Contains('_')
+    "Do not include underscores in field names. Use user-friendly names with spaces.",
+    (field) => field.Name.Contains('_')
     );
 
 // create a contextual validation rule
-var contextualRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Dimension>(
-    "no_duplicate_dimensions",
-    "naming",
-    (dimension, context) =>
-        context.DimensionNames.Contains(dimension.Name)
-            ? [context.MakeError($"{dimension.Name} appears more than once as a dimension")]
-            : []
-    );
+var contextualRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Field>(
+    "no_aliased_fields",
+    "modeling",
+    (field, context) =>
+    {
+        var original = context.FieldNames.FirstOrDefault(seen => field.View.Fields[seen].Expr == field.Expr);
+        return original == null
+            ? []
+            : [context.MakeError(
+                "field_alias",
+                $"Field '{field.Name}' reuses source expression '{field.Expr}', already used by field '{original}'.",
+                field)];
+    });
 
 // run validation with the rules defined above and output the diagnostic messages
-Output(SemanticBridge.MetricView.Validate([simpleRule, contextualRule]));
+var sb = new System.Text.StringBuilder();
+foreach (var d in SemanticBridge.MetricView.Validate([simpleRule, contextualRule]))
+{
+    sb.AppendLine($"[{d.Severity}] {d.Code} {d.Path}");
+    sb.AppendLine($"    {d.Context} {d.Message}");
+    sb.AppendLine();
+}
+Output(sb.ToString());
+```
+
+**Output**
+
+```
+[Error] no_underscores Model.Fields["repeat_customer"]
+     Do not include underscores in field names. Use user-friendly names with spaces.
+
+[Error] field_alias Model.Fields["repeat_customer"]
+     Field 'repeat_customer' reuses source expression 'source.customer_id', already used by field 'customer'.
 ```
 
 ## References
 
+- @semantic-bridge-metric-view-object-model
+- @semantic-bridge-metric-view-fields-and-dimensions
 - @semantic-bridge-how-tos
diff --git a/content/features/semantic-bridge.md b/content/features/semantic-bridge.md
index 01cc47c1b..14794316b 100644
--- a/content/features/semantic-bridge.md
+++ b/content/features/semantic-bridge.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge
 title: Semantic Bridge
 author: Greg Baldini
-updated: 2026-04-17
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -24,7 +24,8 @@ SUMMARY: Overview of the Semantic Bridge feature - a multi-platform semantic mod
 -->
 
 > [!NOTE]
-> The Semantic Bridge as released in 3.25.0 is in public preview. It has limitations as documented below, and the API and feature surface area are subject to change.
+> The Semantic Bridge is in public preview.
+> It has limitations as documented below, and the API and feature surface area are subject to change.
 
 The Semantic Bridge is a semantic model compiler, with the capability to translate the structure and expressions of a semantic model from one platform to another.
 This allows you to reuse business logic on multiple data platforms, supporting end users and meeting them where they consume the data.
@@ -81,9 +82,16 @@ After either success type, you can use undo/redo functionality like normal in Ta
 If you click on **View Diagnostics**, you can see a list of messages describing the issues in translation.
 These diagnostics are available for review later by outputting them from a C# script:
 
-```csharp
+```csharp {compile}
 // Show all diagnostic messages from the last attempted import of a Metric View
-SemanticBridge.MetricView.ImportDiagnostics.Output();
+var sb = new System.Text.StringBuilder();
+foreach (var d in SemanticBridge.MetricView.ImportDiagnostics)
+{
+    sb.AppendLine($"[{d.Severity}] {d.Code} {d.Path}");
+    sb.AppendLine($"    {d.Context} {d.Message}");
+    sb.AppendLine();
+}
+Output(sb.ToString());
 ```
 
 ![Import diagnostics](~/content/assets/images/features/semantic-bridge/semantic-bridge-import-diagnostics.png)
@@ -94,86 +102,22 @@ SemanticBridge.MetricView.ImportDiagnostics.Output();
 
 Viewing diagnostics for a failure is the same as for success with issues.
 
-## Translation process
-
-Translating a Metric View to a Tabular model happens in several steps:
-
-1. Read the YAML from disk
-2. Deserialize the YAML
-3. Validate that the deserialized YAML represents a valid Metric View
-4. If it is a valid Metric View, store it as a the currently loaded Metric View, similar to how there is a loaded Tabular model that you interact with.
-   If it is not a valid Metric View, the process stops here and messages are available.
-4. Analyze the Metric View and attempt to transform it to an intermediate representation
-5. Attempt to transform the intermediate representation to a Tabular model
-
-The import GUI described above handles all of this for you, but you can also use C# scripts to customize different steps of the process and operate on the Metric View programatically, similarly to how you are used to doing with a Tabular model.
-Specifically, you can
-
-- load a Metric View from disk with [`SemanticBridge.MetricView.Load`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Load_System_String_): loading makes it available in C# scripts as [`SemanticBridge.MetricView.Model`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Model), but does not import the structure into the Tabular model
-- deserialize a Metric view from a string with [`SemanticBridge.MetricView.Deserialize`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Deserialize_System_String_): similar to loading, the model is available as [`SemanticBridge.MetricView.Model`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Model), but is not imported
-- save a Metric View to disk with [`SemanticBridge.MetricView.Save`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Save_System_String_)
-- serialize a Metric View to a string with [`SemanticBridge.MetricView.Serialize`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Serialize).
-- validate a Metric View using a system that is similar to the [Best Practice Analyzer](xref:best-practice-analyzer) with [`SemanticBridge.MetricView.Validate`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_Validate)
-	- you can create your own custom validation rules with [`SemanticBridge.MetricView.MakeValidationRule`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_MakeValidationRule__1_System_String_System_String_System_Func___0_TabularEditor_SemanticBridge_Platforms_Databricks_Validation_IReadOnlyValidationContext_System_Collections_Generic_IEnumerable_TabularEditor_SemanticBridge_Orchestration_DiagnosticMessage___) and its simpler versions
-- import a Metric View to Tabular with [`SemanticBridge.MetricView.ImportToTabularFromFile`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_ImportToTabularFromFile_System_String_TabularEditor_TOMWrapper_Model_System_String_System_String_System_Collections_Generic_List_TabularEditor_SemanticBridge_Orchestration_DiagnosticMessage___System_Boolean_), which does the exact same as the GUI shown above, or [`SemanticBridge.MetricView.ImportToTabular`](/api/TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.html#TabularEditor_SemanticBridge_Platforms_Databricks_DatabricksMetricViewService_ImportToTabular_TabularEditor_TOMWrapper_Model_System_String_System_String_System_Collections_Generic_List_TabularEditor_SemanticBridge_Orchestration_DiagnosticMessage___System_Boolean_), which is similar, but operates on the currently loaded Metric View, rather than reading one from disk.
-
-
-## Public Preview Limitations
+## Limitations
 
 ### Supported platforms
 
 In the public preview, we support translations from a Databricks Metric View to a Tabular model.
-Specifically we support the following surface area of a Databricks Metric View:
-
-- v0.1 Metric View properties:
-	- supported:
-		- `source`: the source of the fact table
-		- `joins`: collection of tables left-joined to the fact
-		- `dimensions`: flat collection of fields from any table, either the single fact or any of the many joins
-		- `measures`: flat collection of named aggregations representing business logic
-	- unsupported:
-		- `filter`: a SQL filter expression for the Metric View
-
-All v1.1 metadata is not supported in the public preview.
-Any v1.1 metadata is silently ignored upon deserialization of a Metric View, so it will not be visible in a C# script and it will not affect the translation to Tabular in any way.
-
-> [!WARNING]
-> Because the v1.1 metadata is silently ignored, a Metric View that you deserialize and then serialize will be missing this metadata.
-> Be careful not to overwrite a v1.1 source YAML file from a C# script, as that will remove all v1.1 metadata.
-
-### Limitations on translation from SQL
-
-Metric Views provide a structured layer on top of SQL expressions, and so part of translating a Metric View is translating SQL to DAX and M in the Tabular model.
-
-- Metric View `joins` with nested `joins` are not supported.
-  In other words, only strict star schemas are supported for translation; snowflake models are not supported
-- Metric View `joins` with `using` join criteria are not supported; only equijoins on a single key field using the `on` property are supported.
-- Metric View `dimensions` with SQL expressions are not translated to M or DAX; they are presented as Tabular model calculated columns with their SQL expression commented out
-- Metric View `measures` with non-basic aggregations are not translated to DAX; they are presented as a Tabular model measure with their SQL expression commented out
-	- The only aggregations supported are sum, max, min, average, count, and distinct count.
-	- SQL comments in a basic aggregation are not preserved in DAX
-
-> [!WARNING]
-> Note that SQL and DAX are different languages with different semantics.
-> We can make no guarantee that a translated measure will behave identically between the Metric View SQL and the Tabular DAX we generate.
-> Basic aggregates defined on fact table fields should behave the same, whereas aggregates defined on fields in dimension tables are more likely to produce undesired results.
 
 ### Connectivity
 
-The public preview does not connect to any platforms besides Tabular, but works entirely with local files.
-You must create your Metric View YAML on your own and then put it where Tabular Editor can see it.
-
-### C# API
-
-The C# interface has been built to optimize for the automatic translation workflow.
-As such, there are limited affordances for interacting with the currently loaded Metric View, and certain types of operations are clunky.
+The public preview does not connect to any platforms besides Fabric, Power BI, and Analysis Services.
+Working with models from other platforms, e.g., Databricks Metric Views, is based on local source files, such as a Metric View YAML definition.
 
 ## Appendix on nomenclature
 
 It can be confusing to discuss things when talking about the Semantic Bridge, as there are many words that have both generic and specific meanings, depending what level of abstraction we are talking about and which platform we are discussing.
 For example, the term "semantic model" is both generic, referring to the concept of a collection of data and business logic in some form suitable for supporting business reporting and analytical needs, and also the name Microsoft has adopted for referring to their specific implementation of this generic concept in Power BI and Fabric.
 Thus, a semantic model might generically refer to a Databricks Metric View, an OLAP / Multidimensional Cube, a Power BI semantic model, or a model hosted in another platform's semantic layer.
-Similarly, "dimension" refers to a concept in dimensional modeling, but it is also the name of a specific type of object in a Metric View.
 Because of this, we have adopted the following definitions and standards in our documentation to maintain clarity and sanity.
 
 > [!NOTE]
@@ -182,7 +126,7 @@ Because of this, we have adopted the following definitions and standards in our
 ### Definitions
 
 - *Semantic model*: when used on its own always refers to the generic concept of a collection of data, metadata, and business logic to support reporting and analytics.
-  If and only if it is immediately preceded by "Fabric" or "Power BI", then it is referring to that artifact type in that platform, specifically a Tabular model that is saved as TMDL or BIM and using M and DAX; we tend to prefer to use the term Tabular model to refer to the Power BI / Fabric semantic model to avoid this confusion where possible, because the Tabular model is shared across Power BI / Fabric as well as Analysis Serviced Tabular.
+  If and only if it is immediately preceded by "Fabric" or "Power BI", then it is referring to that artifact type in that platform, specifically a Tabular model that is saved as TMDL or BIM and using M and DAX; we tend to prefer to use the term Tabular model to refer to the Power BI / Fabric semantic model to avoid this confusion where possible, because the Tabular model is shared across Power BI / Fabric as well as Analysis Services Tabular.
 - *Platform*: a technology solution that has a semantic layer, on which a generic semantic model is hosted.
   Databricks Metric Views represent a platform; Fabric / Power BI represent a platform; Analysis Services Tabular is a platform; Analysis Services Multidimensional is a platform which we have no support for in the Semantic Bridge today.
 - *Serialization format*: a way to represent a semantic model on disk in a textual format.
@@ -197,25 +141,15 @@ There are many terms that exist generally in discussion of a dimensional model o
 For example, the term "measure" refers generically to a quantitative value that is aggregated in a dimensional model to represent a business metric of interest, but it also refers to a specific kind of object in both Databricks Metric Views and Tabular models; in a Metric View, a measure is a named SQL expression that defines an aggregation in the Metric View, and in a Tabular model a measure is a named DAX expression that defines an aggregation in the Tabular model.
 It is impossible to discuss the work of the Semantic Bridge without talking about multiple meanings of such words at once.
 For example, we talk about translating a Metric View measure to a Tabular measure.
-As such, **we always refer to an object in a specific platform's model by saying the platform and the object, e.g. "Metric View measure" or "Tabular measure"**.
+As such, **we always refer to an object in a specific platform's model by saying the platform and the object, e.g., "Metric View measure" or "Tabular measure"; "Metric View field" or "TOM column".**
 If the term is ever used without being accompanied by a platform's name, then we are discussing the idea generically.
 
-### Common terms across Metric Views and Tabular models
-
-For those of our users who may be unfamiliar with either Metric Views or Tabular models, we provide an incomplete rosetta stone below.
-We refer to the names of Metric View objects based on their representation in YAML, and Tabular based on the name of the type of object in TMDL/TMSL.
-
-| General term         | Name in Tabular | Name in Metric View   | Description                                                                                          | Note                                                                                                                                                                                                                                       |
-|----------------------|-----------------|-----------------------|------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
-| fact                 | table           | source                | A table holding foreign keys to dimensions and quantitative values to be aggregated                  | a Metric View has a single fact which is unnamed and captured as the root-level `source` attribute in YAML. Tabular models do not differentiate between types of tables: whether a table is a fact can only be inferred                    |
-| dimension            | table           | join                  | A table holding descriptive attributes and one primary key to which the fact is related              | Tabular models do not differentiate, so the role of "dimension" is inferred only, as with a fact.                                                                                                                                          |
-| partition            | partition       | source (join only)    | An object for data management, holding a subset of data in a table                                   | Tabular model tables can have many partitions and must have at least one. The Metric View fact, as mentioned above is defined purely as a source, but Metric View joins also have a `source` property, which acts roughly like a partition |
-| field                | column          | dimension             | A column in a table                                                                                  |                                                                                                                                                                                                                                            |
-| measure              | measure         | measure               | A quantitative value that is aggregated according to business logic in the model                     | Measures in a Tabular model are written in DAX, and in a Metric View in SQL                                                                                                                                                                |
-| join or relationship | relationship    | join.on or join.using | A correspondence between key fields in two tables, a foreign key in one and primary key in the other | Relationships are explicit objects in a Tabular model, and implicitly defined as a property of the `join` object in Metric View YAML                                                                                                       |
-
 ## Additional Resources
 
-- [Databricks Metric View documentation](https://learn.microsoft.com/en-us/azure/databricks/metric-views/)
-- [Databricks Metric View YAML reference](https://learn.microsoft.com/en-us/azure/databricks/metric-views/data-modeling/syntax)
+- [Metric View documentation](https://learn.microsoft.com/azure/databricks/business-semantics/)
+- [Metric View YAML reference](https://learn.microsoft.com/azure/databricks/business-semantics/metric-views/yaml-reference)
+- @semantic-bridge-metric-view-tabular-translation
+- @semantic-bridge-metric-view-object-model
+- @semantic-bridge-metric-view-validation
+- @semantic-bridge-metric-view-fields-and-dimensions
 - @semantic-bridge-how-tos
diff --git a/content/features/toc.md b/content/features/toc.md
index 8b46f7d82..1d6c6e7c9 100644
--- a/content/features/toc.md
+++ b/content/features/toc.md
@@ -76,7 +76,9 @@
 ### [Known Limitations](xref:te-cli-limitations)
 ## @command-line-options
 
-# Semantic Bridge for cross-platform translations
+# [Semantic Bridge for cross-platform translations](xref:semantic-bridge)
 ## @semantic-bridge
 ## @semantic-bridge-metric-view-object-model
+## @semantic-bridge-metric-view-tabular-translation
 ## @semantic-bridge-metric-view-validation
+## @semantic-bridge-metric-view-fields-and-dimensions
diff --git a/content/getting-started/github-flow.md b/content/getting-started/github-flow.md
new file mode 100644
index 000000000..a9389d762
--- /dev/null
+++ b/content/getting-started/github-flow.md
@@ -0,0 +1,310 @@
+---
+uid: github-flow
+title: GitHub Flow and the Octopus Merge pattern
+author: Just Blindbæk
+updated: 2026-07-03
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      full: true
+    - product: Tabular Editor 3
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          full: true
+        - edition: Enterprise
+          full: true
+---
+
+# GitHub Flow and the Octopus Merge pattern
+
+This article covers the day-to-day **GitHub Flow** workflow recommended in [Enabling parallel development using Git and Save to Folder](xref:parallel-development), and the **Octopus Merge** pattern that supports it: a way of keeping a shared test environment continuously up to date with everything currently in progress. The second half of the article walks through a complete reference pipeline that implements this — which, as you'll see, ends up covering considerably more than the merge step alone.
+
+## GitHub Flow in daily use
+
+GitHub Flow's rule is simple — `main` is always deployable, all work happens on short-lived branches off `main` — but a few details are worth making explicit for a semantic model team.
+
+**Creating a feature branch:**
+
+```cmd
+git checkout main
+git pull
+git checkout -b feature/add-tax-calculation
+```
+
+**Local development.** The developer works in Tabular Editor 3. Two things happen every time they hit **Ctrl+S**:
+
+- The model metadata is saved to disk in [Save to Folder (database.json) format](xref:parallel-development#what-is-save-to-folder), ready to be staged and committed to the feature branch in Git.
+- If [Workspace Mode](xref:workspace-mode) is enabled, the model is simultaneously synced to the developer's personal workspace database in a shared dev workspace — allowing live testing in Tabular Editor, and letting Power BI Desktop connect [directly to the workspace database](xref:workspace-mode#advantages-of-workspace-mode) for report-side validation.
+
+```cmd
+git add .
+git commit -m "Add tax calculation measure and supporting columns"
+git push
+```
+
+> [!WARNING]
+> Do not enable Fabric Git integration on the workspace hosting your workspace databases. Tabular Editor writes to workspace databases directly through the XMLA endpoint, and those writes have no relationship to your Git branches — enabling Git integration on the same workspace creates conflicting, out-of-band changes to the same database. This is also called out in the [Workspace Mode documentation](xref:workspace-mode).
+
+**Opening a pull request.** When the developer is ready for broader testing, they open a pull request targeting `main`. This is the point where GitHub Flow, on its own, leaves a question open for BI teams: with several developers each having an open PR at once, what should the shared test environment actually reflect? That's what Octopus Merge answers — see below.
+
+**Approval and merge.** Once technical and business reviewers have signed off using the shared test environment, the feature branch is merged into `main` and deleted.
+
+**Deploy to UAT / production.** Either every merge to `main` triggers deployment automatically, or merges accumulate and are deployed on a scheduled cadence (for example, weekly). Both are compatible with GitHub Flow — the branch structure is the same either way, only the release trigger differs.
+
+## Octopus Merge: keeping the test environment current
+
+##### Note — naming disambiguation
+
+"Octopus merge" is used in the Git ecosystem to mean three related but distinct things. It's worth being precise about which one we mean here:
+
+1. **Git's native octopus merge strategy** — the merge strategy Git automatically uses when you run `git merge branch-a branch-b branch-c`, combining more than two branch heads into a single merge commit *as long as there are no conflicts*. If any branch conflicts with the merge in progress, the whole command fails — Git makes no attempt to resolve or isolate conflicts across more than two branches. This is a low-level Git mechanism, not a workflow.
+2. **`lesfurets/git-octopus`** — a now-archived open-source command-line tool that wrapped this native strategy into a "continuous merge" workflow: resolve a set of branches by naming pattern, merge them, push the result to a disposable branch, and repeat on every push. It also included tooling to iterate through branches one-by-one to pinpoint which one caused a conflict. The tool itself is no longer maintained and isn't what we recommend implementing directly, but the workflow it pioneered is exactly the pattern described below.
+3. **The Octopus Merge pattern described in this article** — a custom CI/CD pipeline that discovers all currently open (non-draft) pull requests targeting `main`, merges their source branches together using Git's native octopus strategy from (1), pushes the result to a disposable branch, and deploys that branch to a shared test environment. The pattern is the same idea as (2), reimplemented as a pipeline script you own — for example a GitHub Actions workflow, or an Azure Pipelines script calling the Azure DevOps REST API — rather than a standalone third-party tool.
+
+When this article says "Octopus Merge," it means (3). Note that (3) *uses* the native strategy from (1) as its actual merge mechanism — the value it adds is the automation and branch lifecycle around that merge, not an alternative way of merging.
+
+The pattern, in short: **your test environment always reflects the combination of everything currently in progress** — not just one feature in isolation. Every time a developer pushes to any open, non-draft pull request, the pipeline rebuilds the combined branch from scratch and redeploys it.
+
+```mermaid
+flowchart LR
+    main(["main"]) -.->|"deleted + recreated"| temp
+    prA["feature/A<br/>(open PR)"] --> temp
+    prB["feature/B<br/>(open PR)"] --> temp
+    prC["feature/C<br/>(draft PR — excluded)"]:::draft
+    temp[["♻️ octopus/temp<br/>deleted + recreated from main<br/>on every run"]] --> test(["Test workspace"])
+
+    classDef draft stroke-dasharray: 5 5,opacity:0.55;
+```
+
+> [!NOTE]
+> Tabular Editor now has a cross-platform CLI (`te`) in Limited Public Preview, purpose-built for CI/CD use — non-interactive mode, native GitHub Actions/Azure DevOps annotations, VSTEST output, and a `te test run` command for running regression tests as part of a pipeline. It's a natural fit for the kind of pipeline described below, and worth watching. As of this writing, Tabular Editor's own documentation advises against using it in production pipelines during preview (the preview build is stated to expire 2026-09-30), so the reference implementation in this article uses the established `TabularEditor.exe` CLI instead. See [CI/CD Integration](xref:te-cli-cicd) for the new CLI's current capabilities and examples.
+
+<!-- FUTURE SPLIT POINT: everything from "Reference implementation" onward is a candidate to become its own page once it grows further (e.g. once release/production deployment past the test environment is added). -->
+
+## Reference implementation
+
+What follows is a complete, working pipeline that implements Octopus Merge — but it's worth being upfront that it does considerably more than the merge step alone. A full run also downloads Tabular Editor, and validates the merged model against your best-practice rules and live data source schema before deploying it to the shared test workspace. Octopus Merge is job 1 of 5; the rest is a general-purpose CI/CD pipeline for semantic models that happens to consume Octopus Merge's output. Deploying reports on top of that model — a separate concern with its own variability by organization — is addressed briefly at the end.
+
+The examples below show both **Azure Pipelines** (calling the Azure DevOps REST API) and **GitHub Actions** (calling the GitHub REST API) for the merge job, since the two platforms differ mainly in how they authenticate and query pull requests — the underlying Git operations and Tabular Editor CLI invocations are identical either way.
+
+### Overview of the pipeline
+
+A full run consists of several jobs, each with explicit dependencies on the ones before it:
+
+```mermaid
+flowchart TD
+    merge["Octopus merge"] --> dl["Download Tabular Editor"]
+    dl --> bpa["BPA verification"]
+    dl --> schema["Schema validation"]
+    bpa --> deploy["Model deployment"]
+    schema --> deploy
+```
+
+Running each stage as its own job — rather than one long script — gives you independent pass/fail signal for each concern (merge conflicts vs. BPA violations vs. schema drift vs. deployment failures), which makes it much faster to diagnose what actually went wrong when a run fails.
+
+##### Note — pipeline agent requirements
+
+Since `TabularEditor.exe` only runs on Windows, every job that invokes it needs a Windows-based agent/runner — this includes the BPA verification, schema validation, and model deployment jobs. A cloud-hosted Windows agent works fine as long as it can reach your test workspace and data source over the network; a self-hosted agent is only necessary if those endpoints aren't reachable from outside your network (an on-premises data source, for example). The Octopus merge job itself has no such constraint, since it only needs Git.
+
+### Triggering the pipeline
+
+The pipeline isn't triggered by a normal Git push trigger. Since it needs to merge *all* currently open pull requests — not just the one that changed — it's typically set up with no automatic branch trigger, and instead invoked in one of two ways:
+
+- **From a pull request pipeline or branch policy**, so it runs whenever a pull request targeting `main` is created, or whenever a new commit is pushed to any branch with an open pull request.
+- **On a schedule** (for example, every few minutes), as a simpler alternative if your CI/CD platform makes "run on any open PR's branch update" awkward to configure directly.
+
+Either approach achieves the same effect: any push to any open pull request causes the combined test environment to be rebuilt.
+
+### Job 1: Octopus merge
+
+This job is responsible for discovering all currently open pull requests, merging them together, and publishing the result to a disposable branch.
+
+**What it does, step by step:**
+
+1. **Authenticate and query pull requests.** The job calls the source-control platform's REST API for open pull requests targeting `main`, authenticated with a token that has permission to list pull requests (including drafts — the filtering happens next, not at the API level).
+2. **Filter to non-draft pull requests.** Draft pull requests are excluded — this gives developers a way to push work-in-progress commits without pulling them into the shared test build. Only when a PR is marked ready for review does it join the merge.
+3. **Clone the repository fresh.** Rather than reusing a previous checkout, the job clones the repository from scratch on every run, authenticating with the pipeline's own access token. This guarantees the merge always starts from a clean, known state.
+4. **Delete and recreate the disposable branch.** Both the remote and local copies of the disposable output branch (for example, `octopus/temp`) are force-deleted if they exist, then recreated fresh from `main`. The branch is never fast-forwarded or reused between runs — it's always rebuilt from scratch.
+5. **Merge all qualifying pull request branches in a single command.** Passing more than two branches to `git merge` invokes Git's native octopus merge strategy automatically — this is the point where the pattern uses the underlying Git mechanism described above.
+6. **Push the result**, if the merge succeeded.
+
+**Azure Pipelines**, calling the Azure DevOps REST API:
+
+```yaml
+- task: PowerShell@2
+  displayName: Git octopus merge
+  inputs:
+    targetType: 'inline'
+    script: |
+      $prs = Invoke-RestMethod -Uri "https://dev.azure.com/$(Org)/$(Project)/_apis/git/repositories/$(Repo)/pullrequests?api-version=7.0" `
+        -Headers @{ Authorization = "Bearer $(System.AccessToken)" }
+      $branches = $prs.value | Where-Object { $_.isDraft -eq $false -and $_.targetRefName -eq "refs/heads/main" } |
+        ForEach-Object { $_.sourceRefName -replace 'refs/heads', 'origin' }
+
+      git clone $(Build.Repository.Uri) repo --quiet
+      cd repo
+      git checkout main --quiet
+      git push origin --delete octopus/temp --quiet 2>$null
+      git checkout -b octopus/temp --quiet
+      if ($branches.Count -gt 0) {
+        git merge --quiet $branches
+      }
+      git push --set-upstream origin octopus/temp --quiet
+```
+
+**GitHub Actions**, calling the GitHub REST API via the `gh` CLI:
+
+```yaml
+- name: Git octopus merge
+  env:
+    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  run: |
+    branches=$(gh pr list --base main --state open --json isDraft,headRefName \
+      --jq '.[] | select(.isDraft == false) | .headRefName')
+
+    git clone "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY" repo --quiet
+    cd repo
+    git checkout main --quiet
+    git push origin --delete octopus/temp --quiet || true
+    git checkout -b octopus/temp --quiet
+    if [ -n "$branches" ]; then
+      git merge --quiet $(echo "$branches" | sed 's/^/origin\//')
+    fi
+    git push --set-upstream origin octopus/temp --quiet
+```
+
+Both versions do the same thing: list open, non-draft PRs targeting `main`, resolve them to branch references, and merge them into a freshly recreated `octopus/temp` branch.
+
+**Handling a failed merge:**
+
+If the merge fails — most likely due to a conflict between two or more of the open pull requests — don't just log an error and stop. A well-behaved implementation should reset the working directory and push an **empty placeholder commit** to the disposable branch before failing the pipeline run:
+
+```
+git reset --hard --quiet
+git checkout main --quiet
+git branch -D octopus/temp --quiet
+git checkout -b octopus/temp --quiet
+git config user.email "octopus-merge@users.noreply.github.com"
+git config user.name "Octopus Merge"
+git commit --allow-empty -m "init" --quiet
+git push origin octopus/temp --quiet
+```
+
+This matters because downstream jobs (BPA verification, schema validation, deployment) may depend on the disposable branch existing in *some* well-defined state. Without this step, a failed merge could leave the branch missing or half-merged, causing confusing secondary failures in later jobs rather than a single clear error at the merge step.
+
+##### Note — diagnosing which branch caused the conflict
+
+A straightforward implementation of this pattern does not automatically identify which pull request caused a merge conflict — it only reports that the merge failed. This is a real limitation compared to the archived `lesfurets/git-octopus` tool, which included tooling to iterate through branches one-by-one to isolate the culprit. In practice, most teams resolve this manually: temporarily unpublish (convert back to draft, or close) the pull requests you suspect, and re-run the pipeline until the merge succeeds again, to narrow down which branch was responsible. If this trial-and-error process becomes a bottleneck for your team, it's worth building an automated one-by-one bisection step into your own pipeline.
+
+### Job 2: Download Tabular Editor
+
+Since the jobs that follow need to invoke the Tabular Editor CLI, and build agents can't be assumed to have it pre-installed, a separate job downloads a portable copy of Tabular Editor at the start of every run:
+
+- Fetches the latest release directly (for example, from Tabular Editor's GitHub releases).
+- Unzips it and discards the downloaded archive.
+- Makes the extracted `TabularEditor.exe` available to subsequent jobs on the same agent/runner.
+
+Downloading the latest version fresh on every run keeps the pipeline current automatically, without needing to track and update a pinned version number — though if your team wants deterministic, reproducible builds, pinning to a specific release and updating it deliberately is worth considering as an alternative.
+
+### Job 3: BPA verification
+
+This job runs Tabular Editor's [Best Practices Analyzer](xref:best-practice-analyzer) against every semantic model produced by the merge, validating it against your team's central quality rules.
+
+If your repository contains more than one semantic model — common for BI teams serving multiple business areas — each model typically lives in its own subfolder, and the job loops over each one:
+
+```
+TabularEditor.exe "<path-to-model>" -A "<path-to-BPARules.json>" -V
+```
+
+- `-A` points Tabular Editor at the BPA rules file to check against.
+- `-V` verifies the model, reporting the result.
+
+> [!NOTE]
+> Decide up front whether a BPA violation should **fail** the pipeline or only **warn**. It's tempting to start with warnings while your rule set is still being tuned, but if that's left in place long-term, violations can silently accumulate without ever blocking a deployment. Treat a warn-only BPA step as a temporary state to graduate out of, not a permanent configuration.
+
+### Job 4: Schema validation
+
+This job compares each model's expected schema against its real, live data source — catching a renamed or missing column, for example, before it causes a broken refresh in the test environment.
+
+```
+TabularEditor.exe "<path-to-model>" -S "<path-to-connection-script>.cs" -SC -V -W
+```
+
+- `-S` runs a C# script that sets the model's data source connection string — typically reading it from a pipeline environment variable or secret, so the real connection details never need to be committed to source control.
+- `-SC` performs the schema check itself, comparing the model's metadata against the live source.
+- `-V -W` verify the result and control how warnings are handled.
+
+If your models depend on database objects that are themselves deployed as part of your pipeline — for example, SQL views published from source control — make sure that deployment step runs *before* schema validation, so the check runs against the exact objects the model will see once everything is deployed to the test environment. This ordering dependency is easy to miss if the two jobs are written independently of each other.
+
+> [!NOTE]
+> The specific mechanism for deploying upstream data objects (SQL views, other database artifacts) is going to be specific to your organization's data platform, and isn't part of the Octopus Merge pattern itself. What matters for this pattern is only that schema validation happens after your data source is in its expected state for the test environment — whatever populates that state is up to you.
+
+### Job 5: Model deployment
+
+Once BPA verification and schema validation have both succeeded, this job deploys the merged model to the shared test workspace, using Tabular Editor's Save to Folder (`database.json`) format deployed directly over the XMLA endpoint:
+
+```
+TabularEditor.exe "<path-to-model>\database.json" -D "Provider=MSOLAP;Data Source=<XMLA-endpoint>;User ID=app:<app-id>@<tenant-id>;Password=<app-secret>;LocaleIdentifier=1033" "<model-name>" -O -P -R -W -V -E
+```
+
+A few things worth calling out:
+
+- Authentication is via a **service principal** (an Azure AD app registration), not a user account — appropriate for an unattended pipeline, and avoiding the need to keep a real user's credentials in your pipeline secrets.
+- The model name passed to Tabular Editor typically matches the folder name, so that a repository containing multiple models deploys each one to a correspondingly named dataset.
+- The `-O -P -R -W -V -E` flags cover overwrite, processing, roles, warnings, verification, and error handling — see the [Tabular Editor CLI reference](xref:command-line-options) for the full flag list if you need to adjust any of these for your own setup.
+
+> [!NOTE]
+> Business reviewers signing off in the shared test environment are validating a report, not a raw XMLA connection — in practice, something still needs to deploy and bind Power BI reports to the freshly deployed test model (and, optionally, update any published Power BI Apps) before that sign-off can happen. Whether every report is redeployed on every run, or only the ones affected by the current changes, is the kind of decision that varies enough by organization to be out of scope here — see @powerbi-cicd for that part of the pipeline.
+
+### Full workflow diagram
+
+```mermaid
+flowchart TB
+    subgraph dev["Developer"]
+        direction LR
+        d1["Create feature branch"] --> d2["Local commits"] --> d3["Open PR<br/>(ready for review)"]
+    end
+
+    subgraph ci["CI Pipeline"]
+        direction LR
+        c1["Octopus merge"] -->|"success"| c2["Download Tabular Editor"]
+        c1 -.->|"conflict"| c1f["Empty placeholder commit"]
+        c2 --> c3["BPA verification"]
+        c2 --> c4["Schema validation"]
+        c3 --> c5["Model deployment"]
+        c4 --> c5
+    end
+
+    subgraph review["Review"]
+        direction LR
+        r1["Technical sign-off"] --> r2["Business sign-off"]
+    end
+
+    subgraph release["Release"]
+        direction LR
+        rel1["Merge to main"] --> rel2["Deploy to UAT / production"]
+    end
+
+    d3 --> c1
+    c5 --> r1
+    r2 --> rel1
+    c1f -.->|"developer resolves conflict, pushes fix"| d2
+    r1 -.->|"changes requested, developer pushes fix"| d2
+```
+
+## Key principles
+
+- `main` is always in a deployable state; feature branches are short-lived and independent.
+- The disposable branch is deleted and recreated from `main` on every run — never fast-forwarded or reused.
+- A failed merge should leave the disposable branch in a well-defined (even if empty) state, not a missing or half-merged one.
+- Each validation stage (BPA, schema) should be a distinct pipeline job with its own pass/fail signal, not folded into one script.
+- Organization-specific steps (like a SQL views deployment) should be clearly separated from the generic pattern, both in your pipeline code and in how you document it internally — so the pattern remains portable if you need to apply it to a different project.
+
+## Next steps
+
+- [Enabling parallel development using Git and Save to Folder](xref:parallel-development) — the branching strategy this pipeline supports.
+- [CI/CD Integration](xref:te-cli-cicd) — the new Tabular Editor CLI's CI/CD patterns, currently in Limited Public Preview.
+- @powerbi-cicd
+- @as-cicd
diff --git a/content/getting-started/parallel-development.md b/content/getting-started/parallel-development.md
index 452cc79df..77ad54016 100644
--- a/content/getting-started/parallel-development.md
+++ b/content/getting-started/parallel-development.md
@@ -2,7 +2,7 @@
 uid: parallel-development
 title: Enabling parallel development using Git and Save to Folder
 author: Daniel Otykier
-updated: 2026-06-11
+updated: 2026-07-03
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -125,66 +125,128 @@ What follows is a discussion of branching strategies to employ when developing t
 
 The branching strategy will dictate what the daily development workflow will be like, and in many cases, branches will tie directly into the project methods used by your team. For example, using the [agile process within Azure DevOps](https://docs.microsoft.com/en-us/azure/devops/boards/work-items/guidance/agile-process-workflow?view=azure-devops), your backlog would consist of **Epics**, **Features**, **User Stories**, **Tasks** and **Bugs**.
 
-In the agile terminology, a **User Story** is a deliverable, testable piece of work. The User Story may consist of several **Tasks**, that are smaller pieces of work that need to be performed, typically by a developer, before the User Story may be delivered. In the ideal world, all User Stories have been broken down into manageable tasks, each taking only a couple of hours to complete, adding up to no more than a handful of days for the entire User Story. This would make a User Story an ideal candidate for a so-called Topic Branch, where the developer could make one or more commits for each of the tasks within the User Story. Once all tasks are done, you want to deliver the User Story to the client, at which time the topic branch is merged into a delivery branch (for example, a "Test" branch), and the code deployed to a testing environment.
+In the agile terminology, a **User Story** is a deliverable, testable piece of work. The User Story may consist of several **Tasks** — smaller pieces of work performed by a developer before the User Story can be delivered. In an ideal world, all User Stories are broken down into manageable tasks, each taking only a couple of hours to complete, adding up to no more than a handful of days for the entire User Story. This makes a User Story an ideal candidate for a short-lived feature branch, where the developer makes one or more commits per task before the branch is merged and the code deployed for testing.
 
-Determining a suitable branching strategy depends on many different factors. In general, Microsoft recommends the [Trunk-based Development](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops) ([video](https://youtu.be/t_4lLR6F_yk?t=232)) strategy, for agile and continuous delivery of small increments. The main idea is to create branches off the "Main" branch for every new feature or bugfix (see image below). Code review processes are enforced through pull requests from feature branches into Main, and using the Branch Policy feature of Azure DevOps, we can set up rules that require code to build cleanly before a pull request can be completed.
+Determining a suitable branching strategy depends on many different factors: team size, release cadence, regulatory constraints, how many semantic models you maintain, and how mature your CI/CD setup already is. This article presents three strategies:
 
-![Trunk Based Development](~/content/assets/images/trunk-based-development.png)
+- **[GitHub Flow + Octopus Merge](#github-flow--octopus-merge)** — our recommended approach for most semantic model teams, and the primary focus of this article.
+- **[GitFlow](#gitflow-branching-and-deployment-environments)** — a valid alternative, particularly suited to teams with formal, infrequent release cycles or regulatory sign-off requirements.
+- **[Plain trunk-based development](#trunk-based-development)** — the simplest approach, worth understanding as a baseline even if most BI teams will want the additional structure GitHub Flow provides.
+
+> [!NOTE]
+> Tabular Editor is agnostic to branching strategy. Save to Folder and Workspace Mode work identically regardless of which of the strategies below you choose — the recommendation in this article is based on patterns we've seen succeed across enterprise engagements, not a constraint imposed by the tool.
+
+## GitHub Flow + Octopus Merge
+
+For teams building semantic models with Tabular Editor and Power BI, we recommend **[GitHub Flow](https://docs.github.com/en/get-started/using-github/github-flow)** combined with an **Octopus Merge** pattern for continuous integration testing.
+
+GitHub Flow is a lightweight branching model with a single hard rule: **`main` is always deployable.** All work happens on a short-lived feature branch created off `main`; nobody commits directly to `main`; branches are merged back via pull request after review and automated checks pass. Unlike GitFlow, there's no `develop` branch and no separate branch per environment — environment promotion (dev → test → UAT → production) is handled by the deployment pipeline, not by long-lived branches.
 
-### Trunk-based Development
+```mermaid
+gitGraph
+    commit id: "initial"
+    branch "feature/add-tax-calculation"
+    commit id: "add measure"
+    commit id: "add column"
+    checkout main
+    merge "feature/add-tax-calculation" id: "PR merged: tax calculation"
+    branch "feature/fix-rls"
+    commit id: "fix role"
+    checkout main
+    merge "feature/fix-rls" id: "PR merged: fix RLS"
+    branch "feature/new-report-page"
+    commit id: "wip"
+    checkout main
+    commit id: "hotfix"
+    merge "feature/new-report-page" id: "PR merged: new report page"
+```
 
-However, such a strategy might not be feasible in a Business Intelligence development teams, for a number of reasons:
+`main` stays on a single line and is always deployable; short feature branches fork off it and merge straight back via pull request. Contrast this with the GitFlow diagram further down the page, which has five parallel, long-lived lines.
 
-- New features often require prolonged testing and validation by business users, which may take several weeks to complete. As such, you will likely need a user-facing test environment.
-- BI solutions are multi-tiered, typically consisting of a Data Warehouse tier with ETL, a Master Data Management tier, a semantic layer and reports. Dependencies exist between these layers, that further complicate testing and deployment.
-- The BI team may be responsible for developing and maintaining several different semantic models, serving different areas of business (Sales, Inventory, Logistics, Finance, HR, etc.), at different maturity stages and at varying development pace.
-- The most important aspect of a BI solution is the data! As a BI developer, you do not have the luxury of simply checking out the code from source control, hitting F5 and having a full solution up and running in the few minutes it takes to compile the code. Your solution needs data, and that data has to be loaded, ETL'ed or processed across several layers to make it to the end user. Including data in your DevOps workflows could blow up build and deployment times from minutes to hours or even days. In some scenarios, it might not even be possible, due to resource or economy constraints.
+On its own, GitHub Flow doesn't answer a question specific to BI teams: what does your shared test environment reflect at any given moment, when several developers each have an open pull request? **Octopus Merge** answers this: a CI pipeline continuously merges every currently open pull request into a disposable branch and deploys the result to a shared test environment — so business users always validate the combination of everything in progress, not just one feature in isolation. See [GitHub Flow and the Octopus Merge pattern](xref:github-flow) for how the pattern works and how to build it.
 
-There is no doubt that a BI team would benefit from a branching strategy that supports parallel development on any of the layers in the full BI solution, in a way that lets them mix and match features that are ready for testing. But especially due to the last bullet point above, we need to think carefully about how we are going to handle the data. If we add a new attribute to a dimension, for example, do we want to automatically load the dimension as part of our build and deployment pipelines? If it only takes a few minutes to load such a dimension, that would probably be fine, but what if we are adding a new column to a multi-billion row fact table? And if developers are working on new features in parallel, should each developer have their own development database, or how do we otherwise prevent them from stepping on each others toes in a shared database?
+A few reasons this combination fits semantic model development particularly well:
 
-There is no easy answer to the questions above - especially when considering all the tiers of a BI solution, and the different constellations and preferred workflows of BI teams across the planet. Also, when we dive into actual build, deployment and test automation, we are going to focus mostly on Analysis Services. The ETL- and database tiers have their own challenges from a DevOps perspective, which are outside the scope of this article. But before we move on, let us take a look at another branching strategy, and how it could potentially be adopted to BI workflows.
+- **Simpler mental model.** Two branch concepts instead of GitFlow's five means less onboarding overhead, particularly on teams that include report authors and business analysts alongside model developers.
+- **`main` is always deployable.** If you need to ship an urgent fix — a broken measure, a security-related RLS change — you don't need to reason about which of several long-lived branches currently reflects production.
+- **Environment promotion lives in the pipeline, not the branch structure.** Adding a new environment is a pipeline change, not a new permanent branch every developer has to remember to merge into.
+- **Short-lived branches reduce merge conflicts** — important for Octopus Merge, since it merges every open branch together for integration testing. The shorter each branch lives, the smaller the surface area for conflicts.
+- **Better fit for continuous delivery of data products** than GitFlow's versioned release-train model, since semantic models tend to evolve incrementally rather than ship in discrete releases.
 
-### GitFlow branching and deployment environments
+None of this means GitFlow is wrong — see [GitFlow branching and deployment environments](#gitflow-branching-and-deployment-environments) below for when it's still a good fit.
+
+### Key principles
+
+- `main` is always in a deployable state.
+- Feature branches are short-lived and independent.
+- The test environment always reflects the combination of everything currently in progress — not just one feature in isolation. See [GitHub Flow and the Octopus Merge pattern](xref:github-flow) for how.
+- Fabric Git integration should **not** be enabled on any workspace used for Tabular Editor workspace databases — Tabular Editor writes to workspace databases directly through the XMLA endpoint, and those writes have no relationship to your Git branches. This is also called out in the [Workspace Mode documentation](xref:workspace-mode).
+
+## GitFlow branching and deployment environments
+
+GitFlow remains a solid choice for teams with a genuine need for the structure it provides — for example, formal versioned releases, regulatory sign-off gates tied to specific branches, or infrequent (e.g. monthly or quarterly) release cycles where a persistent `develop` branch and release branches map naturally onto your process. If that describes your team, the approach below is well worth using.
 
 The strategy described below is based on [GitFlow by Vincent Driessen](https://nvie.com/posts/a-successful-git-branching-model/).
 
 ![Gitflow](~/content/assets/images/gitflow.png)
 
-Implementing a branching strategy similar to this, can help solve some of the DevOps problems typically encountered by BI teams, provided you put some thought into how the branches correlate to your deployment environments. In an ideal world, you would need at least 4 different environments to fully support GitFlow:
+Implementing a branching strategy similar to this can help solve some of the DevOps problems typically encountered by BI teams, provided you put some thought into how the branches correlate to your deployment environments. In an ideal world, you would need at least 4 different environments to fully support GitFlow:
 
 - The **production** environment, which should always contain the code at the HEAD of the master branch.
 - A **canary** environment, which should always contain the code at the HEAD of the develop branch. This is where you typically schedule nightly deployments and run your integration testing, to make sure that the features going into the next release to production play nicely together.
 - One or more **UAT** environments where you and your business users test and validate new features. Deployment happens directly from the feature branch containing the code that needs to be tested. You will need multiple test environments if you want to test multiple new features in parallel. With some coordination effort, a single test environment is usually enough, as long as you carefully consider the dependencies between your BI tiers.
 - One or more **sandbox** environments where you and your team can develop new features, without impacting any of the environments above. As with the test environment, it is usually enough to have a single, shared, sandbox environment.
 
-We must emphasize that there is really no "one-size-fits-all" solution to these considerations. Maybe you are not building your solution in the Cloud, and therefore do not have the scalability or flexibility to spin up new resources in seconds or minutes. Or maybe your data volumes are very large, making it impractical to replicate environments due to resource/economy/time constraints. Before moving on, also make sure to ask yourself the question of whether you truly need to support parallel development and testing. This is rarely the case for small teams with only a few stakeholders, in which case you can still benefit from CI/CD, but where GitFlow branching might be overkill.
+We must emphasize that there is really no "one-size-fits-all" solution to these considerations. Maybe you are not building your solution in the Cloud, and therefore do not have the scalability or flexibility to spin up new resources in seconds or minutes. Or maybe your data volumes are very large, making it impractical to replicate environments due to resource/economy/time constraints.
+
+Even if you do need to support parallel development, you may find that multiple developers can easily share the same development or sandbox environment, without encountering too much trouble. Specifically for tabular models, though, we recommend that developers still use individual [workspace databases](xref:workspace-mode) to avoid "stepping over each others toes."
 
-Even if you do need to support parallel development, you may find that multiple developers can easily share the same development or sandbox environment, without encountering too much trouble. Specifically for tabular models, though, we recommend that developers still use individual [workspace databases](xref:workspace-mode) to avoid "stepping over each others toes".
+> [!NOTE]
+> If you're evaluating GitFlow primarily because you need a shared, always-current test environment reflecting in-progress work, consider whether [GitHub Flow + Octopus Merge](#github-flow--octopus-merge) might achieve the same outcome with less branch-management overhead. GitFlow's `develop`/canary branch and Octopus Merge's disposable test branch solve a similar problem in different ways.
+
+## Trunk-based development
+
+Trunk-based development is the simplest possible branching model: developers commit small, frequent changes either directly to `main`, or via very short-lived feature branches that are merged back within hours. Microsoft recommends [trunk-based development](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops) ([video](https://youtu.be/t_4lLR6F_yk?t=232)) generally for agile, continuous delivery of small increments.
+
+![Trunk Based Development](~/content/assets/images/trunk-based-development.png)
+
+In its purest form, trunk-based development can run into real friction for BI teams:
+
+- New features often require prolonged testing and validation by business users, which may take several weeks — so you need somewhere for in-progress work to be validated that isn't `main` itself.
+- BI solutions are multi-tiered (Data Warehouse/ETL, Master Data Management, semantic layer, reports), with dependencies between layers that complicate testing and deployment.
+- A BI team may maintain several semantic models at different maturity stages and paces.
+- Data — not just code — has to be loaded, ETL'd, and processed to make a change testable. Including full data refreshes in every build could blow up pipeline runtimes from minutes to hours, and isn't always feasible at all for very large fact tables.
+
+**GitHub Flow + Octopus Merge, described above, is best understood as a refinement of trunk-based development that directly addresses these concerns** — rather than a departure from it. It keeps trunk-based development's core simplicity (one long-lived branch, short-lived feature branches, no release trains) while adding exactly the missing piece BI teams need: a shared test environment, populated by the pipeline rather than by a long-lived branch, that always reflects the current combined state of in-progress work. If you're choosing between the three strategies on this page, GitHub Flow + Octopus Merge is generally where we'd point a team that likes the simplicity of trunk-based development but has run into the limitations above.
 
 ## Common workflow
 
-Assuming you already have a git repository set up and aligned to your branching strategy, adding your tabular model "source code" to the repository is simply a matter of using Tabular Editor to save the metadata to a new branch in a local repository. Then, you stage and commit the new files, push your branch to the remote repository and create a pull request to get your branch merged into the main branch.
+Assuming you already have a git repository set up and aligned to your branching strategy, adding your tabular model "source code" to the repository is simply a matter of using Tabular Editor to save the metadata to a new branch in a local repository. Then, you stage and commit the new files, push your branch to the remote repository, and create a pull request to get your branch merged into the main branch.
+
+The exact commands are the same regardless of which strategy above you choose — what differs is what happens *after* the pull request is opened (see [GitHub Flow and the Octopus Merge pattern](xref:github-flow) for the GitHub Flow case, or your release/canary process for GitFlow). In general, the workflow looks like this:
 
-The exact workflow depends on your branching strategy and how your git repositories have been set up. In general, the workflow would look something like this:
+1. Before starting work on a new feature, create a new feature branch in git:
 
-1. Before starting work on a new feature, create a new feature branch in git. In a trunk-based development scenario, you would need the following git commands to checkout the main branch, get the latest version of the code, and create the feature branch from there:
    ```cmd
    git checkout main
    git pull
-   git checkout -b "feature\AddTaxCalculation"
+   git checkout -b feature/add-tax-calculation
    ```
+
 2. Open your model metadata from the local git repository in Tabular Editor. Ideally, use a [workspace database](xref:workspace-mode), to make it easier to test and debug DAX code.
 3. Make the necessary changes to your model using Tabular Editor. Continuously save the changes (CTRL+S). Regularly commit code changes to git after you save, to avoid losing work and to keep a full history of all changes that were made:
+
    ```cmd
    git add .
    git commit -m "Description of what was changed and why since last commit"
    git push
    ```
+
 4. If you are not using a workspace database, use Tabular Editor's **Model > Deploy...** option to deploy to a sandbox/development environment, in order to test the changes made to the model metadata.
-6. When done, and all code has been committed and pushed to the remote repository, you submit a pull request in order to get your code integrated with the main branch. If a merge conflict is encountered, you will have to resolve it locally, using for example the Visual Studio Team Explorer or by simply opening the .json files in a text editor to resolve the conflicts (git inserts conflict markers to indicate which part of the code has conflicts).
-7. Once all conflicts are resolved, there may be a process of code review, automated build/test execution based on branch policies, etc. to get the pull request completed. This, however, depends on your branching strategy and overall setup.
+5. When done, and all code has been committed and pushed to the remote repository, you submit a pull request in order to get your code integrated with the main branch. If a merge conflict is encountered, you will have to resolve it locally, using for example the Visual Studio Team Explorer or by simply opening the .json files in a text editor to resolve the conflicts (git inserts conflict markers to indicate which part of the code has conflicts).
+6. Once all conflicts are resolved, there may be a process of code review and automated build/test execution — including, if you're using the GitHub Flow approach above, the Octopus Merge test deployment — before the pull request can be completed.
 
-We present more details about how to configure git branch policies, set up automated build and deployment pipelines, etc. using Azure DevOps in the following articles. Similar techniques can be used in other automated build and git hosting environments, such as TeamCity, GitHub, etc.
+We present more details about how to configure git branch policies, set up automated build and deployment pipelines, etc. using Azure DevOps and GitHub Actions in the following articles. Similar techniques can be used in other automated build and git hosting environments, such as TeamCity, GitLab, etc.
 
 ## Next steps
 
diff --git a/content/how-tos/includes/sample-metricview-deserialize.md b/content/how-tos/includes/sample-metricview-deserialize.md
deleted file mode 100644
index 2aeb794a6..000000000
--- a/content/how-tos/includes/sample-metricview-deserialize.md
+++ /dev/null
@@ -1,43 +0,0 @@
-## Deserialize Metric View for these code samples
-
-This how-to uses a sample e-commerce Metric View representing sales data with three dimension tables (product, customer, date) joined to a fact table (orders).
-Run the snippet below first, if you'd like to follow along with the code in the rest of this how-to
-
-```csharp
-SemanticBridge.MetricView.Deserialize("""
-    version: 0.1
-    source: sales.fact.orders
-    joins:
-      - name: product
-        source: sales.dim.product
-        on: source.product_id = product.product_id
-      - name: customer
-        source: sales.dim.customer
-        on: source.customer_id = customer.customer_id
-      - name: date
-        source: sales.dim.date
-        on: source.order_date = date.date_key
-    dimensions:
-      - name: product_name
-        expr: product.product_name
-      - name: product_category
-        expr: product.category
-      - name: customer_segment
-        expr: customer.segment
-      - name: order_date
-        expr: date.full_date
-      - name: order_year
-        expr: date.year
-      - name: order_month
-        expr: date.month_name
-    measures:
-      - name: total_revenue
-        expr: SUM(revenue)
-      - name: order_count
-        expr: COUNT(order_id)
-      - name: avg_order_value
-        expr: AVG(revenue)
-      - name: unique_customers
-        expr: COUNT(DISTINCT customer_id)
-    """);
-```
diff --git a/content/how-tos/includes/sample-metricview.md b/content/how-tos/includes/sample-metricview.md
index ae47b0125..883819be7 100644
--- a/content/how-tos/includes/sample-metricview.md
+++ b/content/how-tos/includes/sample-metricview.md
@@ -1,38 +1,41 @@
+## Load the sample Metric View for these code samples
+
+Before starting, make sure you have Tabular Editor 3 open and have a Tabular model opened, or create a new model.
+
 This how-to uses a sample e-commerce Metric View representing sales data with three dimension tables (product, customer, date) joined to a fact table (orders).
+Use either method below to load it (either "download and load" or "copy and deserialize"),
+then follow along with the rest of this how-to.
+You can run either command in the same C# script as the rest of this example,
+or you can run it first, in its own C# script, and the rest of the example in its own C# script.
+
+<noscript>
+<style>
+  /* JS-off fallback: reveal every tab panel stacked so all content stays reachable when the
+     tab script does not run. With scripting on, this block is ignored and the tabs work normally. */
+  .tabGroup section[role="tabpanel"][hidden] { display: block !important; }
+</style>
+</noscript>
+
+# [Download and load](#tab/load)
+
+[Download `sample-metricview.yaml`](https://raw.githubusercontent.com/TabularEditor/TabularEditorDocs/main/content/how-tos/includes/sample-metricview.yaml)
+and load it by path:
+
+```csharp
+SemanticBridge.MetricView.Load("C:/path/to/sample-metricview.yaml");
+```
+
+# [Copy and deserialize](#tab/deserialize)
+
+Copy the definition below and pass it to `Deserialize` as a string:
 
-```yaml
-version: 0.1
-source: sales.fact.orders
-joins:
-  - name: product
-    source: sales.dim.product
-    on: source.product_id = product.product_id
-  - name: customer
-    source: sales.dim.customer
-    on: source.customer_id = customer.customer_id
-  - name: date
-    source: sales.dim.date
-    on: source.order_date = date.date_key
-dimensions:
-  - name: product_name
-    expr: product.product_name
-  - name: product_category
-    expr: product.category
-  - name: customer_segment
-    expr: customer.segment
-  - name: order_date
-    expr: date.full_date
-  - name: order_year
-    expr: date.year
-  - name: order_month
-    expr: date.month_name
-measures:
-  - name: total_revenue
-    expr: SUM(revenue)
-  - name: order_count
-    expr: COUNT(order_id)
-  - name: avg_order_value
-    expr: AVG(revenue)
-  - name: unique_customers
-    expr: COUNT(DISTINCT customer_id)
+```csharp
+SemanticBridge.MetricView.Deserialize("""
+    <PLACEHOLDER: copy and paste the YAML shown below, indented within the triple quotes here>
+    """);
 ```
+
+[!code-yaml[Sample Metric View](sample-metricview.yaml)]
+
+
+***
diff --git a/content/how-tos/includes/sample-metricview.yaml b/content/how-tos/includes/sample-metricview.yaml
index df457333b..628d2489e 100644
--- a/content/how-tos/includes/sample-metricview.yaml
+++ b/content/how-tos/includes/sample-metricview.yaml
@@ -1,20 +1,24 @@
-version: 0.1
+version: 1.1
 source: sales.fact.orders
 joins:
   - name: product
     source: sales.dim.product
     on: source.product_id = product.product_id
+    cardinality: many_to_one
   - name: customer
     source: sales.dim.customer
     on: source.customer_id = customer.customer_id
+    cardinality: many_to_one
   - name: date
     source: sales.dim.date
     on: source.order_date = date.date_key
-dimensions:
+    cardinality: many_to_one
+fields:
   - name: product_name
     expr: product.product_name
   - name: product_category
     expr: product.category
+    display_name: 'Product Category'
   - name: customer_segment
     expr: customer.segment
   - name: order_date
@@ -26,9 +30,26 @@ dimensions:
 measures:
   - name: total_revenue
     expr: SUM(revenue)
+    display_name: 'Total Revenue'
+    format:
+      type: currency
+      currency_code: USD
+      decimal_places:
+        type: exact
+        places: 2
+  - name: gross_margin
+    expr: SUM(revenue) - SUM(cost)
   - name: order_count
-    expr: COUNT(order_id)
+    expr: COUNT(*)
   - name: avg_order_value
     expr: AVG(revenue)
+  - name: revenue_to_budget
+    expr: (SUM(revenue) - SUM(budget)) / SUM(budget)
+    display_name: 'Revenue vs Budget'
+    format:
+      type: percentage
+      decimal_places:
+        type: max
+        places: 1
   - name: unique_customers
     expr: COUNT(DISTINCT customer_id)
diff --git a/content/how-tos/semantic-bridge-add-object.md b/content/how-tos/semantic-bridge-add-object.md
index 918d69d55..585328979 100644
--- a/content/how-tos/semantic-bridge-add-object.md
+++ b/content/how-tos/semantic-bridge-add-object.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-add-object
 title: Add an Object to a Metric View
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -19,56 +19,93 @@ applies_to:
 ---
 # Add an object to a Metric View
 
-This how-to demonstrates how to add a new Metric View dimension (field) to a loaded Metric View.
+This how-to demonstrates adding new objects to a loaded Metric View and setting their properties.
 Similar patterns apply to all Metric View collections.
 
-[!INCLUDE [deserialize](includes/sample-metricview-deserialize.md)]
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
 
-## Create a new Metric View Dimension object
+[!INCLUDE [sample](includes/sample-metricview.md)]
 
-Use the Metric View `Dimension` constructor to create a new Metric View dimension:
+## Add a field
 
-```csharp
+Use [`AddField`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField%2A) to create and return a new `Field` you can manipulate.
+
+```csharp {run id=addfield setup=mv-sample after=none output=true}
+var sb = new System.Text.StringBuilder();
+var view = SemanticBridge.MetricView.Model;
+
+sb.AppendLine($"Fields before adding: {view.Fields.Count}");
+
+var field = view.AddField("customer_city", "customer.city");
+
+sb.AppendLine($"Fields after adding: {view.Fields.Count}");
+Output(sb.ToString());
+```
+
+**Output**
+
+```
+Fields before adding: 6
+Fields after adding: 7
+```
+
+## Add and configure a `Join`
+
+[`AddJoin`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddJoin%2A)
+works similarly to `AddField`: it constructs the object, adds it to the Metric View, and returns it so you can set further properties.
+Set the cardinality with the [`JoinCardinality`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.JoinCardinality) enum.
+
+```csharp {run id=addjoin setup=mv-sample after=none output=false}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
-var newDimension = new MetricView.Dimension
-{
-    Name = "customer_city",
-    Expr = "customer.city"
-};
+var view = SemanticBridge.MetricView.Model;
+
+// add a join, then set its remaining properties
+var supplier = view.AddJoin("supplier", "sales.dim.supplier");
+supplier.On = "source.supplier_id = supplier.supplier_id";
+supplier.Cardinality = MetricView.JoinCardinality.ManyToOne;
 ```
 
-## Add to the Metric View
+`AddJoin` is also a method on any existing `Join`.
+You would use this to create nested joins, for example, `supplier.AddJoin("region", "sales.dim.region")`,
+which models a snowflake dimension.
 
-The Metric View `Dimensions` property is an `IList<Dimension>`, so you can use `Add()`:
+## Add and configure a `Measure`
 
-```csharp
+[`AddMeasure`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddMeasure%2A) works similarly to the other `Add` methods.
+
+Some properties, such as a field or measure `Format`, have their own types you need to construct to set the property.
+Create the [`Format`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.Format) variant you want, such as `Format.Currency` or `Format.Percentage`, and assign it.
+
+```csharp {run id=addmeasure setup=mv-sample after=none output=true}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
 var sb = new System.Text.StringBuilder();
-sb.AppendLine($"Dimensions before adding: {SemanticBridge.MetricView.Model.Dimensions.Count}");
-
-var newDimension = new MetricView.Dimension
-{
-    Name = "customer_city",
-    Expr = "customer.city"
-};
+var view = SemanticBridge.MetricView.Model;
 
-SemanticBridge.MetricView.Model.Dimensions.Add(newDimension);
+// add a new measure, then give it a currency format
+var totalCost = view.AddMeasure("total_cost", "SUM(cost)");
+totalCost.Format = new MetricView.Format.Currency { CurrencyCode = "USD" };
 
-sb.AppendLine($"Dimensions after adding: {SemanticBridge.MetricView.Model.Dimensions.Count}");
+// read the format back off the measure
+sb.AppendLine($"{totalCost.Name} format: {totalCost.Format}");
 Output(sb.ToString());
 ```
 
 **Output**
 
 ```
-Dimensions before adding: 8
-Dimensions after adding: 9
+total_cost format: Currency { Type = Currency, DecimalPlaces = , HideGroupSeparator = , Abbreviation = , CurrencyCode = USD }
 ```
 
+## Next steps
+
+- [Remove objects from a Metric View](xref:semantic-bridge-remove-object)
+- [Rename a field](xref:semantic-bridge-rename-objects)
+- [Serialize a Metric View to YAML](xref:semantic-bridge-serialize)
+
 ## See also
 
-- @semantic-bridge-remove-object
-- @semantic-bridge-rename-objects
-- @semantic-bridge-serialize
+- [Metric View Object Model](xref:semantic-bridge-metric-view-object-model)
diff --git a/content/how-tos/semantic-bridge-how-tos.md b/content/how-tos/semantic-bridge-how-tos.md
index d6e0288e0..dddea8d2f 100644
--- a/content/how-tos/semantic-bridge-how-tos.md
+++ b/content/how-tos/semantic-bridge-how-tos.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-how-tos
 title: Semantic Bridge How-Tos
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -23,21 +23,26 @@ These how-tos are focused on interacting with the [Databricks Metric View object
 
 ## Getting Started
 
-- @semantic-bridge-load-inspect - Load a Metric View and explore its structure
-- @semantic-bridge-import - Import a Metric View to Tabular and view diagnostics
+- @semantic-bridge-load-inspect: Load a Metric View and explore its structure
+- @semantic-bridge-metric-view-import-from-file: Import a Metric View directly from a YAML file
+- @semantic-bridge-import: Import a loaded Metric View to Tabular and view diagnostics
 
 ## Validation
 
-- @semantic-bridge-validate-default - Validate with built-in rules
-- @semantic-bridge-validate-simple-rules - Create predicate-based validation rules for naming conventions
-- @semantic-bridge-validate-contextual-rules - Create rules with cross-object checks like duplicate detection
+- @semantic-bridge-validate-default: Validate with built-in rules
+- @semantic-bridge-validate-simple-rules: Create predicate-based validation rules for naming conventions
+- @semantic-bridge-validate-contextual-rules: Create rules with cross-object checks, such as names reused across object types
 
 ## Manipulating the Object Model
 
-- @semantic-bridge-add-object - Add a new object to a Metric View
-- @semantic-bridge-remove-object - Remove objects from a Metric View
-- @semantic-bridge-rename-objects - Rename objects using copy-modify pattern
+- @semantic-bridge-add-object: Add objects to a Metric View and set their properties
+- @semantic-bridge-remove-object: Remove objects from a Metric View
+- @semantic-bridge-rename-objects: Rename a field in a Metric View
 
 ## Serialization
 
-- @semantic-bridge-serialize - Serialize a Metric View back to YAML
+- @semantic-bridge-serialize: Serialize a Metric View back to YAML
+
+## Troubleshooting
+
+- @semantic-bridge-metric-view-handle-failures: Handle invalid input, missing files, and imports that don't complete
diff --git a/content/how-tos/semantic-bridge-import.md b/content/how-tos/semantic-bridge-import.md
index 098f00110..89dd79ecc 100644
--- a/content/how-tos/semantic-bridge-import.md
+++ b/content/how-tos/semantic-bridge-import.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-import
 title: Import a Metric View and View Diagnostics
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -17,39 +17,29 @@ applies_to:
         - edition: Enterprise
           full: true
 ---
-# Import a Metric View and View Diagnostics
+# Import a Metric View and view diagnostics
 
-This how-to demonstrates how to import a Metric View into a Tabular model using C# scripts, and how to view diagnostic messages from the import process.
+This how-to demonstrates importing a loaded Metric View into a Tabular model with a C# script, and reviewing the diagnostic messages the import produces.
 
-## Prerequisites
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
 
-You must have a Tabular model open in Tabular Editor before importing. This can be:
+[!INCLUDE [sample](includes/sample-metricview.md)]
 
-- A new, empty model
-- An existing model you want to enhance with objects from the Metric View
+> [!NOTE]
+> Each example below imports into the open Tabular model.
+> To run more than one, we recommend that you undo the import after each example (Edit>Undo in the menu, or CTRL-z in the TOM Explorer).
+> If you run each import one after the other, you will get multiple translated copies of the Metric View.
 
-## Import methods
+## Import the loaded Metric View
 
-There are two import methods:
+`ImportToTabular` translates the currently loaded Metric View into the open Tabular model.
+The Databricks hostname and HTTP path are used when we build the M partition expressions;
+for a quick test you can pass placeholder values and fix them before refreshing data.
 
-| Method                    | Description                                    |
-|---------------------------|------------------------------------------------|
-| `ImportToTabularFromFile` | Loads from a file path and imports in one step |
-| `ImportToTabular`         | Imports the currently loaded Metric View       |
-
-Both methods require:
-
-- The target Tabular `Model`
-- Databricks hostname (for M partition expressions)
-- Databricks HTTP path (for M partition expressions)
-
-## Import from file
-
-Use `ImportToTabularFromFile` to load and import in one operation:
-
-```csharp
-var success = SemanticBridge.MetricView.ImportToTabularFromFile(
-    "C:/MetricViews/sales-metrics.yaml",
+```csharp {run id=import setup=mv-sample after=none output=true}
+var success = SemanticBridge.MetricView.ImportToTabular(
     Model,
     "your-workspace.azuredatabricks.net",
     "/sql/1.0/warehouses/abc123def456",
@@ -57,159 +47,115 @@ var success = SemanticBridge.MetricView.ImportToTabularFromFile(
 );
 
 var sb = new System.Text.StringBuilder();
-if (success)
-{
-    sb.AppendLine("Import successful!");
-    sb.AppendLine($"Diagnostics: {diagnostics.Count}");
-}
-else
+sb.AppendLine($"Imported {Model.AllColumns.Count()} fields and {Model.AllMeasures.Count()} measures.");
+sb.AppendLine(success ? "Import successful." : "Import failed.");
+sb.AppendLine($"Diagnostics: {diagnostics.Count}");
+foreach (var diag in diagnostics)
 {
-    sb.AppendLine("Import failed.");
-    sb.AppendLine($"Errors: {diagnostics.Count}");
+    sb.AppendLine($"  [{diag.Severity}] {diag.Code}: {diag.Message}");
 }
-
 Output(sb.ToString());
 ```
 
-## Import a loaded Metric View
-
-If you've already loaded a Metric View (for inspection or modification), use `ImportToTabular`:
-
-```csharp
-// Load the Metric View first
-SemanticBridge.MetricView.Load("C:/MetricViews/sales-metrics.yaml");
-
-// Optionally inspect or modify it
-var view = SemanticBridge.MetricView.Model;
-
-var sb = new System.Text.StringBuilder();
-sb.AppendLine($"Importing Metric View with {view.Dimensions.Count} dimensions and {view.Measures.Count} measures");
-
-// Import to Tabular
-var success = SemanticBridge.MetricView.ImportToTabular(
-    Model,
-    "your-workspace.azuredatabricks.net",
-    "/sql/1.0/warehouses/abc123def456",
-    out var diagnostics
-);
+**Output:**
 
-if (success)
-{
-    sb.AppendLine("Import successful!");
-}
-else
-{
-    sb.AppendLine("Import failed.");
-}
-
-Output(sb.ToString());
 ```
-
-## Using placeholder connection values
-
-If you're testing the translation without a real Databricks connection, you can use placeholder values:
-
-```csharp
-var success = SemanticBridge.MetricView.ImportToTabularFromFile(
-    "C:/MetricViews/sales-metrics.yaml",
-    Model,
-    "placeholder-host",
-    "placeholder-path",
-    out var diagnostics
-);
-
-var sb = new System.Text.StringBuilder();
-sb.AppendLine("Import complete (with placeholder connection values)");
-sb.AppendLine("Note: Update the M partition expressions before refreshing data.");
-Output(sb.ToString());
+Imported 15 fields and 6 measures.
+Import successful.
+Diagnostics: 0
 ```
 
-## View diagnostics after import
+Note that the number of fields imported includes join keys and implicit column references from the Metric View definition,
+so it is larger than the number of explicit `Fields` in the Metric View definition.
 
-You can access diagnostics from the last import at any time using `ImportDiagnostics`.
-This example assumes that you have previously run an import, either via GUI or C# script.
+## Review the last import's diagnostics
 
-```csharp
-var diagnostics = SemanticBridge.MetricView.ImportDiagnostics;
+The diagnostics from the most recent import are available at any time through `ImportDiagnostics`, including after an import done through the GUI.
 
-var sb = new System.Text.StringBuilder();
-sb.AppendLine("LAST IMPORT DIAGNOSTICS");
-sb.AppendLine("-----------------------");
-sb.AppendLine("");
-sb.AppendLine($"Total issues: {diagnostics.Count}");
-sb.AppendLine("");
-
-foreach (var diag in diagnostics)
-{
-    sb.AppendLine($"[{diag.Severity}] {diag.Message}");
-}
-
-Output(sb.ToString());
+```csharp {compile}
+foreach (var d in SemanticBridge.MetricView.ImportDiagnostics)
+    Output($"[{d.Severity}] {d.Code}: {d.Message}");
 ```
 
-## Output diagnostics directly
-
-For quick inspection, you can output the diagnostics collection directly:
-
-```csharp
-// Output all diagnostics from the last import
-SemanticBridge.MetricView.ImportDiagnostics.Output();
-```
+## See a translation diagnostic
 
-## Complete workflow example
+Some Metric View constructs cannot be translated to Tabular.
+A window measure, for example, is not translated to DAX:
+the import creates a placeholder TOM measure with the original Metric View definition in a comment
+and reports a diagnostic warning to you.
 
-Load, validate, and import with full diagnostic reporting:
+Add a window spec to a measure, then import to see the diagnostic:
 
-```csharp
-var sb = new System.Text.StringBuilder();
+```csharp {run id=window-diagnostic setup=mv-sample after=none output=true}
+using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
-// Load the Metric View
-SemanticBridge.MetricView.Load("C:/MetricViews/sales-metrics.yaml");
 var view = SemanticBridge.MetricView.Model;
 
-sb.AppendLine("METRIC VIEW SUMMARY");
-sb.AppendLine("-------------------");
-sb.AppendLine($"Source: {view.Source}");
-sb.AppendLine($"Joins: {view.Joins?.Count ?? 0}");
-sb.AppendLine($"Dimensions: {view.Dimensions.Count}");
-sb.AppendLine($"Measures: {view.Measures.Count}");
-sb.AppendLine("");
-
-// Validate first
-var validationDiags = SemanticBridge.MetricView.Validate().ToList();
-sb.AppendLine("VALIDATION");
-sb.AppendLine("----------");
-sb.AppendLine($"Issues: {validationDiags.Count}");
-sb.AppendLine("");
-
-// Import
+// add a window spec
+view.Measures["total_revenue"].Window =
+[
+    new MetricView.Window
+    {
+        Order = "order_date",
+        Range = "trailing 3 month",
+        Semiadditive = MetricView.Window.SemiadditiveType.Last
+    }
+];
+
 var success = SemanticBridge.MetricView.ImportToTabular(
     Model,
     "your-workspace.azuredatabricks.net",
     "/sql/1.0/warehouses/abc123def456",
-    out var importDiags
+    out var diagnostics
 );
 
-sb.AppendLine("IMPORT RESULT");
-sb.AppendLine("-------------");
-sb.AppendLine($"Success: {success}");
-sb.AppendLine($"Diagnostics: {importDiags.Count}");
-sb.AppendLine("");
-
-if (importDiags.Count > 0)
+var sb = new System.Text.StringBuilder();
+sb.AppendLine(success ? "Import succeeded with issues." : "Import failed.");
+foreach (var diag in diagnostics)
 {
-    sb.AppendLine("Import issues:");
-    foreach (var diag in importDiags)
-    {
-        sb.AppendLine($"  [{diag.Severity}] {diag.Message}");
-    }
+    sb.AppendLine($"  [{diag.Severity}] {diag.Code}: {diag.Message}");
 }
-
+// note that we search for the DisplayName, as that is what is translated to TOM
+sb.AppendLine($"TOM measure expression: {Model.AllMeasures.First(m => m.Name == "Total Revenue").Expression}");
 Output(sb.ToString());
 ```
 
+**Output:**
+
+```
+Import succeeded with issues.
+  [Warning] MEASURE_WINDOW_UNSUPPORTED: Measure 'Total Revenue' uses a window specification that is not currently supported; it has been left inert with the original definition preserved as a comment.
+TOM measure expression: // This measure uses a window specification (windowed / cumulative / semiadditive),
+// which is not currently supported when importing Databricks Metric Views.
+// The measure has been left blank - review the details below and author the DAX
+// manually. The translated DAX does NOT account for the window spec; you will most
+// likely need to wrap it in CALCULATE (or similar) to apply the windowing.
+//
+// Original source expression (Databricks SQL):
+/*
+SUM(revenue)
+*/
+//
+// Suggested DAX translation (window spec NOT applied):
+/*
+SUM('Fact'[revenue])
+*/
+//
+// Window specification:
+/*
+- order: order_date
+  range: trailing 3 month
+  semiadditive: last
+
+*/
+```
+
+## Next steps
+
+- [Import a Metric View from a file](xref:semantic-bridge-metric-view-import-from-file)
+- [Load and inspect a Metric View](xref:semantic-bridge-load-inspect)
+- [Validate a Metric View](xref:semantic-bridge-validate-default)
+
 ## See also
 
 - [Semantic Bridge Overview](xref:semantic-bridge)
-- [Validate a Metric View](xref:semantic-bridge-validate-default)
-- [Load and Inspect a Metric View](xref:semantic-bridge-load-inspect)
diff --git a/content/how-tos/semantic-bridge-load-inspect.md b/content/how-tos/semantic-bridge-load-inspect.md
index a29eeb573..3be7731ce 100644
--- a/content/how-tos/semantic-bridge-load-inspect.md
+++ b/content/how-tos/semantic-bridge-load-inspect.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-load-inspect
 title: Load and Inspect a Metric View
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -22,30 +22,18 @@ applies_to:
 This how-to demonstrates how to load a Databricks Metric View into Tabular Editor and explore its structure using C# scripts.
 This is the foundational skill for all other Metric View operations.
 
-## Sample Metric View
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
 
 [!INCLUDE [Sample Metric View](includes/sample-metricview.md)]
 
-## Load a Metric View from a file
-
-Use `SemanticBridge.MetricView.Load` to load a Metric View from a YAML file on disk.
-
-```csharp
-// Load from a file path
-SemanticBridge.MetricView.Load("C:/MetricViews/sales-metrics.yaml");
-
-// Confirm it loaded
-Output($"Loaded Metric View version: {SemanticBridge.MetricView.Model.Version}");
-```
-
-[!INCLUDE [deserialize](includes/sample-metricview-deserialize.md)]
-
 ## Access the loaded Metric View
 
 After loading, the Metric View is available in any script as `SemanticBridge.MetricView.Model`.
 This returns a Metric View [`View`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View) object, the root of the [Metric View object graph](xref:semantic-bridge-metric-view-object-model).
 
-```csharp
+```csharp {run id=basic setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
@@ -54,22 +42,30 @@ sb.AppendLine($"Source (fact table): {view.Source}");
 Output(sb.ToString());
 ```
 
+**Output**
+
+```
+Version: 1.1
+Source (fact table): sales.fact.orders
+```
+
 ## Inspect Metric View joins (dimension tables)
 
 The Metric View `Joins` property contains the dimension tables joined to the fact.
 
-```csharp
+```csharp {run id=joins setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
-sb.AppendLine($"Number of joins: {view.Joins?.Count ?? 0}");
+sb.AppendLine($"Number of joins: {view.Joins.Count}");
 sb.AppendLine("");
 
-foreach (var join in view.Joins ?? [])
+foreach (var join in view.Joins)
 {
     sb.AppendLine($"Join: {join.Name}");
     sb.AppendLine($"  Source: {join.Source}");
     sb.AppendLine($"  On: {join.On}");
+    sb.AppendLine($"  Cardinality: {join.Cardinality?.ToString() ?? "ManyToOne (default)"}");
     sb.AppendLine("");
 }
 
@@ -83,31 +79,34 @@ Number of joins: 3
 
 Join: product
   Source: sales.dim.product
-  On: product_id = product.product_id
+  On: source.product_id = product.product_id
+  Cardinality: ManyToOne
 
 Join: customer
   Source: sales.dim.customer
-  On: customer_id = customer.customer_id
+  On: source.customer_id = customer.customer_id
+  Cardinality: ManyToOne
 
 Join: date
   Source: sales.dim.date
-  On: order_date = date.date_key
+  On: source.order_date = date.date_key
+  Cardinality: ManyToOne
 ```
 
-## Inspect Metric View dimensions (fields)
+## Inspect Metric View fields
 
-The Metric View `Dimensions` property contains all field definitions.
+The Metric View `Fields` property contains all field definitions.
 
-```csharp
+```csharp {run id=fields setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
-sb.AppendLine($"Number of dimensions: {view.Dimensions?.Count ?? 0}");
+sb.AppendLine($"Number of fields: {view.Fields.Count}");
 sb.AppendLine("");
 
-foreach (var dim in view.Dimensions ?? [])
+foreach (var field in view.Fields)
 {
-    sb.AppendLine($"{dim.Name,-20} <- {dim.Expr}");
+    sb.AppendLine($"{field.Name,-20} <- {field.Expr}");
 }
 
 Output(sb.ToString());
@@ -116,7 +115,7 @@ Output(sb.ToString());
 **Output:**
 
 ```
-Number of dimensions: 6
+Number of fields: 6
 
 product_name         <- product.product_name
 product_category     <- product.category
@@ -130,14 +129,14 @@ order_month          <- date.month_name
 
 The Metric View `Measures` property contains all Metric View measure definitions with their aggregation expressions.
 
-```csharp
+```csharp {run id=measures setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
-sb.AppendLine($"Number of measures: {view.Measures?.Count ?? 0}");
+sb.AppendLine($"Number of measures: {view.Measures.Count}");
 sb.AppendLine("");
 
-foreach (var measure in view.Measures ?? [])
+foreach (var measure in view.Measures)
 {
     sb.AppendLine($"{measure.Name,-20} = {measure.Expr}");
 }
@@ -148,11 +147,13 @@ Output(sb.ToString());
 **Output:**
 
 ```
-Number of measures: 4
+Number of measures: 6
 
 total_revenue        = SUM(revenue)
-order_count          = COUNT(order_id)
+gross_margin         = SUM(revenue) - SUM(cost)
+order_count          = COUNT(*)
 avg_order_value      = AVG(revenue)
+revenue_to_budget    = (SUM(revenue) - SUM(budget)) / SUM(budget)
 unique_customers     = COUNT(DISTINCT customer_id)
 ```
 
@@ -160,7 +161,7 @@ unique_customers     = COUNT(DISTINCT customer_id)
 
 Here is a complete script that outputs a formatted summary of the entire Metric View.
 
-```csharp
+```csharp {run id=summary setup=mv-sample after=none output=true}
 var sb = new System.Text.StringBuilder();
 var view = SemanticBridge.MetricView.Model;
 
@@ -172,27 +173,27 @@ sb.AppendLine($"Fact Source: {view.Source}");
 sb.AppendLine("");
 
 // Joins
-sb.AppendLine($"JOINS ({view.Joins?.Count ?? 0})");
+sb.AppendLine($"JOINS ({view.Joins.Count})");
 sb.AppendLine("---------");
-foreach (var join in view.Joins ?? [])
+foreach (var join in view.Joins)
 {
     sb.AppendLine($"  {join.Name,-15} -> {join.Source}");
 }
 sb.AppendLine("");
 
-// Dimensions
-sb.AppendLine($"DIMENSIONS ({view.Dimensions?.Count ?? 0})");
+// Fields
+sb.AppendLine($"FIELDS ({view.Fields.Count})");
 sb.AppendLine("--------------");
-foreach (var dim in view.Dimensions ?? [])
+foreach (var field in view.Fields)
 {
-    sb.AppendLine($"  {dim.Name,-20} <- {dim.Expr}");
+    sb.AppendLine($"  {field.Name,-20} <- {field.Expr}");
 }
 sb.AppendLine("");
 
 // Measures
-sb.AppendLine($"MEASURES ({view.Measures?.Count ?? 0})");
+sb.AppendLine($"MEASURES ({view.Measures.Count})");
 sb.AppendLine("------------");
-foreach (var measure in view.Measures ?? [])
+foreach (var measure in view.Measures)
 {
     sb.AppendLine($"  {measure.Name,-20} = {measure.Expr}");
 }
@@ -200,12 +201,49 @@ foreach (var measure in view.Measures ?? [])
 Output(sb.ToString());
 ```
 
+**Output**
+
+```
+METRIC VIEW SUMMARY
+===================
+
+Version: 1.1
+Fact Source: sales.fact.orders
+
+JOINS (3)
+---------
+  product         -> sales.dim.product
+  customer        -> sales.dim.customer
+  date            -> sales.dim.date
+
+FIELDS (6)
+--------------
+  product_name         <- product.product_name
+  product_category     <- product.category
+  customer_segment     <- customer.segment
+  order_date           <- date.full_date
+  order_year           <- date.year
+  order_month          <- date.month_name
+
+MEASURES (6)
+------------
+  total_revenue        = SUM(revenue)
+  gross_margin         = SUM(revenue) - SUM(cost)
+  order_count          = COUNT(*)
+  avg_order_value      = AVG(revenue)
+  revenue_to_budget    = (SUM(revenue) - SUM(budget)) / SUM(budget)
+  unique_customers     = COUNT(DISTINCT customer_id)
+```
+
 ## Next steps
 
 Now that you can load and inspect a Metric View, you can:
 
-- [Validate the Metric View](xref:semantic-bridge-metric-view-validation) to check for issues
-- [Import the Metric View to Tabular](xref:semantic-bridge) to create tables, columns, and measures
+- [Add objects to a Metric View](xref:semantic-bridge-add-object)
+- [Remove objects from a Metric View](xref:semantic-bridge-remove-object)
+- [Rename a field](xref:semantic-bridge-rename-objects)
+- [Validate the Metric View](xref:semantic-bridge-validate-default)
+- [Import the Metric View to Tabular](xref:semantic-bridge-import)
 
 ## See also
 
diff --git a/content/how-tos/semantic-bridge-metric-view-handle-failures.md b/content/how-tos/semantic-bridge-metric-view-handle-failures.md
new file mode 100644
index 000000000..b2b09c891
--- /dev/null
+++ b/content/how-tos/semantic-bridge-metric-view-handle-failures.md
@@ -0,0 +1,167 @@
+---
+uid: semantic-bridge-metric-view-handle-failures
+title: Handle Common Failures
+author: Greg Baldini
+updated: 2026-07-02
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      none: true
+    - product: Tabular Editor 3
+      since: 3.25.0
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          none: true
+        - edition: Enterprise
+          full: true
+---
+# Handle common failures
+
+This how-to shows how to handle several common failure modes when working with Metric Views in C# scripts:
+invalid YAML, missing files, operations with no loaded metric view, and an import that does not complete.
+
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
+
+## A failed load or deserialize
+
+`Load` and `Deserialize` throw `System.IO.InvalidDataException` when the input does not represent valid Metric View YAML.
+The exception itself only signals that loading failed;
+the specific reasons are captured in `ImportDiagnostics`.
+On failure, the current Metric View (`SemanticBridge.MetricView.Model`) is set to `null`.
+
+```csharp {run id=failed-deserialize setup=none after=none output=true}
+try
+{
+    // This Metric View is missing the required `source`, so it fails to deserialize.
+    SemanticBridge.MetricView.Deserialize("""
+        version: 1.1
+        fields:
+          - name: revenue
+            expr: source.revenue
+        """);
+}
+catch (System.IO.InvalidDataException)
+{
+    var sb = new System.Text.StringBuilder();
+    sb.AppendLine("Could not load the Metric View:");
+    foreach (var diag in SemanticBridge.MetricView.ImportDiagnostics)
+    {
+        sb.AppendLine($"  [{diag.Severity}] {diag.Code}: {diag.Message}");
+    }
+    Output(sb.ToString());
+}
+```
+
+**Output**
+
+```
+Could not load the Metric View:
+  [Error] VIEW_SOURCE_REQUIRED: View source cannot be empty
+```
+
+> [!NOTE]
+> `Load` reads from a file path, so a path that does not exist throws `System.IO.FileNotFoundException` instead of `InvalidDataException`.
+> Catch that (or a broader `System.Exception`) when loading by path.
+
+## Guard against no loaded Metric View
+
+`Validate`, `Serialize`, `Save`, and `ImportToTabular` throw `System.InvalidOperationException` if no Metric View is loaded.
+`Model` is `null` when nothing is loaded, so guard against it.
+
+Run this script in a fresh Tabular Editor 3 instance to ensure you have no loaded Metric View:
+
+```csharp {run id=guard-no-model setup=none after=none output=true}
+if (SemanticBridge.MetricView.Model == null)
+{
+    Output("No Metric View is loaded. Load or deserialize one first.");
+}
+else
+{
+    var diagnostics = SemanticBridge.MetricView.Validate();
+    Output($"Found {diagnostics.Count()} issue(s).");
+}
+```
+
+**Output**
+
+```
+No Metric View is loaded. Load or deserialize one first.
+```
+
+Without the guard, calling `SemanticBridge.MetricView.Validate()` with nothing loaded throws `InvalidOperationException`.
+
+## An import that does not complete
+
+`ImportToTabular` and `ImportToTabularFromFile` return `false` when the import cannot complete, rather than throwing an exception.
+Check the return value and read the `out` diagnostics to see why.
+
+The example below deserializes a valid Metric View,
+then edits a field's expression to be blank, which yields a validation error.
+Because `failOnValidationErrors` defaults to `true`,
+the import stops before translating and returns `false`,
+with the reasons in the `out` diagnostics.
+A Tabular model must be open.
+
+```csharp {run id=import-incomplete setup=none after=none output=true}
+// Load a valid Metric View, then make it invalid
+SemanticBridge.MetricView.Deserialize("""
+    version: 1.1
+    source: sales.fact.orders
+    fields:
+      - name: order_year
+        expr: source.order_year
+    measures:
+      - name: total_revenue
+        expr: SUM(source.revenue)
+    """);
+
+var view = SemanticBridge.MetricView.Model;
+view.Fields["order_year"].Expr = ""; // an empty expression is invalid
+
+var success = SemanticBridge.MetricView.ImportToTabular(
+    Model,
+    "your-workspace.azuredatabricks.net",
+    "/sql/1.0/warehouses/abc123def456",
+    out var diagnostics
+);
+
+var sb = new System.Text.StringBuilder();
+if (success)
+{
+    sb.AppendLine("Import complete.");
+}
+else
+{
+    sb.AppendLine("Import did not complete:");
+    foreach (var diag in diagnostics)
+    {
+        sb.AppendLine($"  [{diag.Severity}] {diag.Code}: {diag.Message}");
+    }
+}
+Output(sb.ToString());
+```
+
+**Output**
+
+```
+Import did not complete:
+  [Error] FIELD_EXPR_REQUIRED: Field 'order_year' expr cannot be empty
+```
+
+Pass `failOnValidationErrors: false` at your own risk if you'd like to import despite validation issues.
+If no Metric View is loaded when you call this,
+it throws `InvalidOperationException` as described above.
+
+## Next steps
+
+- [Load and inspect a Metric View](xref:semantic-bridge-load-inspect)
+- [Validate a Metric View](xref:semantic-bridge-validate-default)
+- [Import a Metric View and view diagnostics](xref:semantic-bridge-import)
+
+## See also
+
+- [Semantic Bridge Overview](xref:semantic-bridge)
diff --git a/content/how-tos/semantic-bridge-metric-view-import-from-file.md b/content/how-tos/semantic-bridge-metric-view-import-from-file.md
new file mode 100644
index 000000000..959f065d2
--- /dev/null
+++ b/content/how-tos/semantic-bridge-metric-view-import-from-file.md
@@ -0,0 +1,64 @@
+---
+uid: semantic-bridge-metric-view-import-from-file
+title: Import a Metric View from a File
+author: Greg Baldini
+updated: 2026-07-02
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      none: true
+    - product: Tabular Editor 3
+      since: 3.25.0
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          none: true
+        - edition: Enterprise
+          full: true
+---
+# Import a Metric View from a file
+
+This how-to demonstrates importing a Metric View into a Tabular model directly from a YAML file.
+
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
+
+## Get the sample Metric View
+
+Save the sample Metric View (below) to a local file.
+You will need to replace the placeholder in the example below with this path.
+For this how-to, specifically, you only need to save the file; you do not need to run `Load` or `Deserialize`.
+
+[!INCLUDE [sample](includes/sample-metricview.md)]
+
+## Import from file
+
+`ImportToTabularFromFile` loads the YAML from disk and imports it into the open model in one step.
+Update the placeholder in the script below (`<PLACEHOLDER>`) with the path where you saved the YAML.
+The Databricks hostname and HTTP path are used to build the M partition expressions; for a quick test you can pass placeholder values and fix them before refreshing data.
+
+```csharp {compile}
+var success = SemanticBridge.MetricView.ImportToTabularFromFile(
+    "<PLACEHOLDER>",
+    Model,
+    "your-workspace.azuredatabricks.net",
+    "/sql/1.0/warehouses/abc123def456",
+    out var diagnostics
+);
+
+var sb = new System.Text.StringBuilder();
+sb.AppendLine(success ? "Import successful!" : "Import failed.");
+sb.AppendLine($"Diagnostics: {diagnostics.Count}");
+Output(sb.ToString());
+```
+
+## Next steps
+
+- [Load and inspect a Metric View](xref:semantic-bridge-load-inspect)
+- [Import a Metric View and view diagnostics](xref:semantic-bridge-import)
+
+## See also
+
+- [Semantic Bridge Overview](xref:semantic-bridge)
diff --git a/content/how-tos/semantic-bridge-remove-object.md b/content/how-tos/semantic-bridge-remove-object.md
index e61177d53..1b936b008 100644
--- a/content/how-tos/semantic-bridge-remove-object.md
+++ b/content/how-tos/semantic-bridge-remove-object.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-remove-object
 title: Remove an Object from a Metric View
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -19,10 +19,14 @@ applies_to:
 ---
 # Remove an object from a Metric View
 
-This how-to demonstrates how to remove Metric View dimensions from a loaded Metric View.
+This how-to demonstrates removing Metric View fields and measures.
 Similar approaches apply to all collections in a Metric View.
 
-[!INCLUDE [deserialize](includes/sample-metricview-deserialize.md)]
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
+
+[!INCLUDE [sample](includes/sample-metricview.md)]
 
 > [!NOTE]
 > Each removal script here affects the currently loaded Metric View.
@@ -30,68 +34,88 @@ Similar approaches apply to all collections in a Metric View.
 
 ## Remove by name
 
-Find the Metric View dimension and remove it from the collection:
+Get the Metric View field and delete it.
+After you delete an object, you should not attempt to modify it.
+You can still read properties off of the deleted object.
+It is safe to call `Delete()` on an object multiple times; after the first, these are no-ops.
 
-```csharp
+```csharp {run id=removefield setup=mv-sample after=none output=true}
 var view = SemanticBridge.MetricView.Model;
 
 var sb = new System.Text.StringBuilder();
-sb.AppendLine($"Dimensions before: {view.Dimensions.Count}");
+sb.AppendLine($"Fields before: {view.Fields.Count}");
 
-var dimToRemove = view.Dimensions.FirstOrDefault(d => d.Name == "order_month");
-if (dimToRemove != null)
-{
-    view.Dimensions.Remove(dimToRemove);
-    sb.AppendLine($"Removed: {dimToRemove.Name}");
-}
+var fieldToRemove = view.Fields["order_month"];
+fieldToRemove.Delete();
+fieldToRemove.Delete(); // note we can call Delete twice safely
+sb.AppendLine($"Removed: {fieldToRemove.Name}");
 
-sb.AppendLine($"Dimensions after: {view.Dimensions.Count}");
+sb.AppendLine($"Fields after: {view.Fields.Count}");
 Output(sb.ToString());
 ```
 
 **Output:**
 
 ```
-Dimensions before: 6
+Fields before: 6
 Removed: order_month
-Dimensions after: 5
+Fields after: 5
+```
+
+Observe that there are multiple calls to `Delete()` but only one removal.
+
+## Remove a measure
+
+Measures are removed the same way: get a reference to the measure and delete it.
+
+```csharp {run id=removemeasure setup=mv-sample after=none output=true}
+var view = SemanticBridge.MetricView.Model;
+
+var sb = new System.Text.StringBuilder();
+sb.AppendLine($"Measures before: {view.Measures.Count}");
+
+var measureToRemove = view.Measures["gross_margin"];
+measureToRemove.Delete();
+sb.AppendLine($"Removed: {measureToRemove.Name}");
+
+sb.AppendLine($"Measures after: {view.Measures.Count}");
+Output(sb.ToString());
 ```
 
-Observe that if you run the script above twice in a row, there is no additional removal; the before and after counts are both 5.
+**Output:**
 
-## Remove multiple Metric View dimensions
+```
+Measures before: 6
+Removed: gross_margin
+Measures after: 5
+```
 
-Use LINQ to filter and rebuild the collection:
+## Remove multiple Metric View fields
 
-```csharp
-using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
+Filter to the fields you want to remove, snapshot them with `ToList`, then delete each one.
+Snapshotting first avoids modifying the collection while iterating it.
 
+```csharp {run id=removemultiple setup=mv-sample after=none output=true}
 var view = SemanticBridge.MetricView.Model;
 
 var sb = new System.Text.StringBuilder();
-sb.AppendLine($"Dimensions before: {view.Dimensions.Count}");
+sb.AppendLine($"Fields before: {view.Fields.Count}");
 
-// Remove all date-related dimensions
+// Remove all date-related fields
 string[] toRemove = ["order_date", "order_year", "order_month"];
 
-var toKeep = view.Dimensions
-    .Where(d => !toRemove.Contains(d.Name))
-    .ToList();
-
-// Clear and repopulate
-view.Dimensions.Clear();
-foreach (var dim in toKeep)
+foreach (var field in view.Fields.Where(f => toRemove.Contains(f.Name)).ToList())
 {
-    view.Dimensions.Add(dim);
+    field.Delete();
 }
 
-sb.AppendLine($"Dimensions after: {view.Dimensions.Count}");
+sb.AppendLine($"Fields after: {view.Fields.Count}");
 sb.AppendLine();
-sb.AppendLine("Remaining dimensions:");
-sb.AppendLine("---------------------");
-foreach (var dim in view.Dimensions)
+sb.AppendLine("Remaining fields:");
+sb.AppendLine("-----------------");
+foreach (var field in view.Fields)
 {
-    sb.AppendLine($"  {dim.Name}");
+    sb.AppendLine($"  {field.Name}");
 }
 
 Output(sb.ToString());
@@ -100,57 +124,57 @@ Output(sb.ToString());
 **Output:**
 
 ```
-Dimensions before: 6
-Dimensions after: 3
+Fields before: 6
+Fields after: 3
 
-Remaining dimensions:
----------------------
+Remaining fields:
+-----------------
   product_name
   product_category
   customer_segment
 ```
 
-## Remove Metric View dimensions from a specific table
+## Remove Metric View fields from a specific table
 
-Remove all Metric View dimensions that reference the date table.
+Remove all Metric View fields that reference the date table.
 
 > [!WARNING]
-> This example is not guaranteed to remove all and exclusively Metric View dimensions which reference a given Metric View Join.
-> Metric View Dimensions may include near-arbitrary SQL expressions, and may also reference previously defined Metric View Dimensions.
+> This example is not guaranteed to remove all and exclusively Metric View fields which reference a given Metric View Join.
+> Metric View fields may include near-arbitrary SQL expressions, and may also reference previously defined Metric View fields.
 > This example is for illustrative purposes only.
 
-```csharp
+```csharp {run id=remove-by-table setup=mv-sample after=none output=true}
 var view = SemanticBridge.MetricView.Model;
 
 var sb = new System.Text.StringBuilder();
-sb.AppendLine($"Dimensions before: {view.Dimensions.Count}");
-
-var toRemove = view.Dimensions
-    .Where(d => d.Expr.StartsWith("date."))
-    .ToList();
+sb.AppendLine($"Fields before: {view.Fields.Count}");
 
-foreach (var dim in toRemove)
+foreach (var field in view.Fields.Where(f => f.Expr.StartsWith("date.")).ToList())
 {
-    view.Dimensions.Remove(dim);
-    sb.AppendLine($"Removed: {dim.Name} ({dim.Expr})");
+    field.Delete();
+    sb.AppendLine($"Removed: {field.Name} ({field.Expr})");
 }
 
-sb.AppendLine($"Dimensions after: {view.Dimensions.Count}");
+sb.AppendLine($"Fields after: {view.Fields.Count}");
 Output(sb.ToString());
 ```
 
 **Output:**
 
 ```
-Dimensions before: 6
+Fields before: 6
 Removed: order_date (date.full_date)
 Removed: order_year (date.year)
 Removed: order_month (date.month_name)
-Dimensions after: 3
+Fields after: 3
 ```
 
+## Next steps
+
+- [Add objects to a Metric View](xref:semantic-bridge-add-object)
+- [Rename a field](xref:semantic-bridge-rename-objects)
+- [Serialize a Metric View to YAML](xref:semantic-bridge-serialize)
+
 ## See also
 
-- @semantic-bridge-add-object
-- @semantic-bridge-rename-objects
-- @semantic-bridge-serialize
+- [Metric View Object Model](xref:semantic-bridge-metric-view-object-model)
diff --git a/content/how-tos/semantic-bridge-rename-objects.md b/content/how-tos/semantic-bridge-rename-objects.md
index c7ef337ee..8d0a17833 100644
--- a/content/how-tos/semantic-bridge-rename-objects.md
+++ b/content/how-tos/semantic-bridge-rename-objects.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-rename-objects
 title: Rename Objects in a Metric View
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -19,151 +19,62 @@ applies_to:
 ---
 # Rename objects in a Metric View
 
-This how-to demonstrates how to rename Metric View dimensions using a copy-modify pattern for bulk transformations.
+This how-to demonstrates renaming a Metric View field.
 The same patterns apply to all collections in a Metric View.
 
-[!INCLUDE [deserialize](includes/sample-metricview-deserialize.md)]
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
 
-## The copy-modify pattern
+[!INCLUDE [sample](includes/sample-metricview.md)]
 
-Since Metric View dimension names are properties on objects in a collection, the cleanest approach is to:
+## Rename a field
 
-1. Create new Metric View `Dimension` objects with the modified names
-2. Clear the original collection
-3. Add the new objects
-
-This avoids issues with modifying objects while iterating.
-
-## Convert snake_case to Title Case
-
-Transform Metric View dimension names from `product_name` to `Product Name`:
-
-```csharp
-using System.Globalization;
-using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
+Rename a field by adding a new field under the new name, copying its other properties across, then removing the original.
+[`AddField`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.MetricView.View.AddField%2A) sets only the name and expression, so copy the remaining properties (`Comment`, `DisplayName`, `Synonyms`, `Format`) yourself.
 
+```csharp {run id=rename setup=mv-sample after=none output=true}
 var view = SemanticBridge.MetricView.Model;
-var textInfo = CultureInfo.CurrentCulture.TextInfo;
 
-var sb = new System.Text.StringBuilder();
-sb.AppendLine("BEFORE");
-sb.AppendLine("------");
-foreach (var dim in view.Dimensions)
-{
-    sb.AppendLine($"  {dim.Name}");
-}
+var old = view.Fields["order_month"];
 
-// Create renamed dimensions
-var renamed = view.Dimensions.Select(dim => new MetricView.Dimension
-{
-    Name = textInfo.ToTitleCase(dim.Name.Replace('_', ' ')),
-    Expr = dim.Expr
-}).ToList();
+// add the replacement, copy the remaining properties, then remove the original
+var renamed = view.AddField("Order Month", old.Expr);
+renamed.Comment = old.Comment;
+renamed.DisplayName = old.DisplayName;
+renamed.Synonyms = old.Synonyms;
+renamed.Format = old.Format;
+old.Delete();
 
-// Replace the collection
-view.Dimensions.Clear();
-foreach (var dim in renamed)
-{
-    view.Dimensions.Add(dim);
-}
-
-sb.AppendLine();
-sb.AppendLine("AFTER");
-sb.AppendLine("-----");
-foreach (var dim in view.Dimensions)
+var sb = new System.Text.StringBuilder();
+sb.AppendLine("Fields:");
+foreach (var field in view.Fields)
 {
-    sb.AppendLine($"  {dim.Name}");
+    sb.AppendLine($"  {field.Name}");
 }
-
 Output(sb.ToString());
 ```
 
 **Output:**
 
 ```
-BEFORE
-------
+Fields:
   product_name
   product_category
   customer_segment
   order_date
   order_year
-  order_month
-
-AFTER
------
-  Product Name
-  Product Category
-  Customer Segment
-  Order Date
-  Order Year
   Order Month
 ```
 
-## Rename using a mapping dictionary
+The re-added field moves to the end of the collection.
 
-Apply specific renames using a lookup:
+## Next steps
 
-```csharp
-using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
-
-var view = SemanticBridge.MetricView.Model;
-
-// Define rename mappings
-var renames = new Dictionary<string, string>
-{
-    { "product_name", "Product" },
-    { "product_category", "Category" },
-    { "customer_segment", "Segment" },
-    { "order_date", "Date" },
-    { "order_year", "Year" },
-    { "order_month", "Month" }
-};
-
-var sb = new System.Text.StringBuilder();
-
-// Create renamed dimensions
-var renamed = view.Dimensions
-    .Select(
-        dim => new MetricView.Dimension
-        {
-            Name = renames.TryGetValue(dim.Name, out var newName) ? newName : dim.Name,
-            Expr = dim.Expr
-        })
-    .ToList();
-
-// Replace the collection
-view.Dimensions.Clear();
-foreach (var dim in renamed)
-{
-    view.Dimensions.Add(dim);
-}
-
-sb.AppendLine("Renamed dimensions:");
-sb.AppendLine("-------------------");
-foreach (var dim in view.Dimensions)
-{
-    sb.AppendLine($"  {dim.Name,-20} <- {dim.Expr}");
-}
-
-Output(sb.ToString());
-```
-
-**Output:**
-
-```
-Renamed dimensions:
--------------------
-  Product              <- product.product_name
-  Category             <- product.category
-  Segment              <- customer.segment
-  Date                 <- date.full_date
-  Year                 <- date.year
-  Month                <- date.month_name
-```
+- [Add objects to a Metric View](xref:semantic-bridge-add-object)
+- [Remove objects from a Metric View](xref:semantic-bridge-remove-object)
+- [Serialize a Metric View to YAML](xref:semantic-bridge-serialize)
 
 ## See also
 
-- @semantic-bridge-add-object
-- @semantic-bridge-remove-object
-- @semantic-bridge-serialize
+- [Metric View Object Model](xref:semantic-bridge-metric-view-object-model)
diff --git a/content/how-tos/semantic-bridge-serialize.md b/content/how-tos/semantic-bridge-serialize.md
index fad851dc7..ac7f75806 100644
--- a/content/how-tos/semantic-bridge-serialize.md
+++ b/content/how-tos/semantic-bridge-serialize.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-serialize
 title: Serialize a Metric View to YAML
 author: Greg Baldini
-updated: 2026-04-17
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -21,18 +21,18 @@ applies_to:
 
 This how-to demonstrates how to serialize a Metric View back to YAML format, either as a string or saved to a file.
 
-> [!WARNING]
-> The public preview only supports v0.1 Metric View properties. Any v1.1 metadata present in a loaded Metric View is silently ignored and will be lost when you serialize.
-> Do not overwrite a source YAML file that contains v1.1 metadata.
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
 
-
-[!INCLUDE [deserialize](includes/sample-metricview-deserialize.md)]
+[!INCLUDE [sample](includes/sample-metricview.md)]
 
 ## Serialize to a string
 
-Use `Serialize()` to get the YAML representation:
+Use `Serialize()` to get the YAML representation.
+This simply re-serializes the YAML you loaded above.
 
-```csharp
+```csharp {run id=serialize setup=mv-sample after=none output=true}
 var yaml = SemanticBridge.MetricView.Serialize();
 
 var sb = new System.Text.StringBuilder();
@@ -42,11 +42,74 @@ sb.AppendLine(yaml);
 Output(sb.ToString());
 ```
 
+**Output**
+
+```
+YAML output:
+------------
+version: 1.1
+source: sales.fact.orders
+joins:
+- name: product
+  source: sales.dim.product
+  on: source.product_id = product.product_id
+  cardinality: many_to_one
+- name: customer
+  source: sales.dim.customer
+  on: source.customer_id = customer.customer_id
+  cardinality: many_to_one
+- name: date
+  source: sales.dim.date
+  on: source.order_date = date.date_key
+  cardinality: many_to_one
+fields:
+- name: product_name
+  expr: product.product_name
+- name: product_category
+  expr: product.category
+  display_name: Product Category
+- name: customer_segment
+  expr: customer.segment
+- name: order_date
+  expr: date.full_date
+- name: order_year
+  expr: date.year
+- name: order_month
+  expr: date.month_name
+measures:
+- name: total_revenue
+  expr: SUM(revenue)
+  display_name: Total Revenue
+  format:
+    type: currency
+    decimal_places:
+      type: exact
+      places: 2
+    currency_code: USD
+- name: gross_margin
+  expr: SUM(revenue) - SUM(cost)
+- name: order_count
+  expr: COUNT(*)
+- name: avg_order_value
+  expr: AVG(revenue)
+- name: revenue_to_budget
+  expr: (SUM(revenue) - SUM(budget)) / SUM(budget)
+  display_name: Revenue vs Budget
+  format:
+    type: percentage
+    decimal_places:
+      type: max
+      places: 1
+- name: unique_customers
+  expr: COUNT(DISTINCT customer_id)
+```
+
 ## Save to a file
 
-Use `Save(path)` to write the YAML directly to disk:
+Use `Save(path)` to write the YAML directly to disk.
+This will write the Metric View you loaded above to disk.
 
-```csharp
+```csharp {compile}
 var path = "C:/MetricViews/updated-sales-metrics.yaml";
 
 SemanticBridge.MetricView.Save(path);
@@ -58,29 +121,12 @@ Output($"Metric View saved to: {path}");
 
 A common workflow is to load, modify, and save a Metric View:
 
-```csharp
-using System.Globalization;
-using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
+```csharp {run id=roundtrip setup=mv-sample after=none output=true}
+var view = SemanticBridge.MetricView.Model;
 
-// The Metric View is already loaded from the include above
+// set a display name on a field, then serialize to confirm it round-trips
+view.Fields["order_month"].DisplayName = "Order Month";
 
-var view = SemanticBridge.MetricView.Model;
-var textInfo = CultureInfo.CurrentCulture.TextInfo;
-
-// Modify: rename dimensions from snake_case to Title Case
-var renamed = view.Dimensions.Select(dim => new MetricView.Dimension
-{
-    Name = textInfo.ToTitleCase(dim.Name.Replace('_', ' ')),
-    Expr = dim.Expr
-}).ToList();
-
-view.Dimensions.Clear();
-foreach (var dim in renamed)
-{
-    view.Dimensions.Add(dim);
-}
-
-// Serialize to see the result
 var yaml = SemanticBridge.MetricView.Serialize();
 
 var sb = new System.Text.StringBuilder();
@@ -95,44 +141,69 @@ Output(sb.ToString());
 ```
 Modified YAML:
 --------------
-version: 0.1
+version: 1.1
 source: sales.fact.orders
 joins:
 - name: product
   source: sales.dim.product
   on: source.product_id = product.product_id
+  cardinality: many_to_one
 - name: customer
   source: sales.dim.customer
   on: source.customer_id = customer.customer_id
+  cardinality: many_to_one
 - name: date
   source: sales.dim.date
   on: source.order_date = date.date_key
-dimensions:
-- name: Product Name
+  cardinality: many_to_one
+fields:
+- name: product_name
   expr: product.product_name
-- name: Product Category
+- name: product_category
   expr: product.category
-- name: Customer Segment
+  display_name: Product Category
+- name: customer_segment
   expr: customer.segment
-- name: Order Date
+- name: order_date
   expr: date.full_date
-- name: Order Year
+- name: order_year
   expr: date.year
-- name: Order Month
+- name: order_month
   expr: date.month_name
+  display_name: Order Month
 measures:
 - name: total_revenue
   expr: SUM(revenue)
+  display_name: Total Revenue
+  format:
+    type: currency
+    decimal_places:
+      type: exact
+      places: 2
+    currency_code: USD
+- name: gross_margin
+  expr: SUM(revenue) - SUM(cost)
 - name: order_count
-  expr: COUNT(order_id)
+  expr: COUNT(*)
 - name: avg_order_value
   expr: AVG(revenue)
+- name: revenue_to_budget
+  expr: (SUM(revenue) - SUM(budget)) / SUM(budget)
+  display_name: Revenue vs Budget
+  format:
+    type: percentage
+    decimal_places:
+      type: max
+      places: 1
 - name: unique_customers
   expr: COUNT(DISTINCT customer_id)
 ```
 
+## Next steps
+
+- [Load and inspect a Metric View](xref:semantic-bridge-load-inspect)
+- [Import a Metric View to Tabular](xref:semantic-bridge-import)
+
 ## See also
 
-- @semantic-bridge-load-inspect
-- @semantic-bridge-import
-- @semantic-bridge
+- [Semantic Bridge Overview](xref:semantic-bridge)
diff --git a/content/how-tos/semantic-bridge-validate-contextual-rules.md b/content/how-tos/semantic-bridge-validate-contextual-rules.md
index 5a6725d1d..300d149c8 100644
--- a/content/how-tos/semantic-bridge-validate-contextual-rules.md
+++ b/content/how-tos/semantic-bridge-validate-contextual-rules.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-validate-contextual-rules
 title: Create Contextual Validation Rules
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -22,39 +22,44 @@ applies_to:
 This how-to demonstrates how to create validation rules that check conditions across multiple objects using the validation context.
 These rules are for illustrative purposes only and do not necessarily reflect hard technical requirements of either Metric Views or the Semantic Bridge.
 
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
+
 ## When to use contextual rules
 
 Use contextual rules when you need to:
 
-- Detect duplicate names across objects
-- Check that names don't conflict between different object types
+- Check that a name is not reused across different object types
 - Access information about previously validated objects
 
 > [!NOTE]
-> The validation process validates each Metric View object in order, so the context consists only of those items already visited in the validation.
+> The validation process validates each Metric View object in order (joins, then fields, then measures), so the context consists only of those items already visited in the validation.
 
 ## The MakeValidationRule method
 
 The generic `MakeValidationRule<T>` method provides access to the validation context:
 
-```csharp
-SemanticBridge.MetricView.MakeValidationRule<IMetricViewObjectType>(
+```csharp {compile}
+using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
+
+SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(  // or Field, Join, View
     "rule_name",
     "category",
-    (obj, context) => {
-        // Return IEnumerable<DiagnosticMessage>
-        // Empty collection means validation passed
-    }
+
+    // return an IEnumerable<DiagnosticMessage>;
+    // an empty collection means the object passed
+    (obj, context) => []
 );
 ```
 
 The `context` parameter provides:
 
-- `context.DimensionNames` - names of dimensions already validated
+- `context.FieldNames` - names of fields already validated
 - `context.MeasureNames` - names of measures already validated
 - `context.JoinNames` - names of joins already validated
-- `context.MakeError(message)` - create an error diagnostic
-- `context.MakeError(message, property)` - create an error diagnostic, calling out the specific property with an error
+- `context.MakeError(code, message, object)` - create an error diagnostic for the given object
+- `context.MakeWarning(code, message, object)` - create a warning diagnostic for the given object
 
 Because you create the diagnostic message in the body of the validation function, you can put details about the current object being validated into the message.
 
@@ -62,36 +67,46 @@ Because you create the diagnostic message in the body of the validation function
 
 Add this using directive to reference Metric View types:
 
-```csharp
+```csharp {compile}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 ```
 
-## Rule: Metric View Measure name must not duplicate a Metric View dimension name
+## Rule: a Metric View Measure name must not duplicate a Metric View Field name
+
+Fields are validated before measures, so when a measure is checked, `context.FieldNames` already holds every field name.
 
-```csharp
+```csharp {compile}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
-var measureNotDimensionRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
-    "measure_not_dimension_name",
+var measureNameRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
+    "measure_not_field_name",
     "naming",
     (measure, context) =>
-        context.DimensionNames.Contains(measure.Name)
-            ? [context.MakeError($"Measure '{measure.Name}' has the same name as a dimension")]
+        context.FieldNames.Contains(measure.Name)
+            ? [context.MakeError(
+                "measure_field_name_collision",
+                $"Measure '{measure.Name}' has the same name as a field",
+                measure)]
             : []
 );
 ```
 
-## Rule: Metric View Measure name must not duplicate another Metric View measure
+## Rule: a Metric View Measure name must not duplicate a Metric View Join name
 
-```csharp
+Joins are validated first, so `context.JoinNames` holds every join name by the time measures are checked.
+
+```csharp {compile}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
-var noDuplicateMeasureRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
-    "no_duplicate_measures",
+var measureNotJoinRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
+    "measure_not_join_name",
     "naming",
     (measure, context) =>
-        context.MeasureNames.Contains(measure.Name)
-            ? [context.MakeError($"Measure '{measure.Name}' is defined more than once")]
+        context.JoinNames.Contains(measure.Name)
+            ? [context.MakeError(
+                "measure_join_name_collision",
+                $"Measure '{measure.Name}' has the same name as a join",
+                measure)]
             : []
 );
 ```
@@ -109,58 +124,64 @@ Notice that we created two separate rules instead of one combined rule. This is
 
 This Metric View has naming conflicts that will trigger both contextual rules:
 
-```csharp
+```csharp {run id=complete setup=mv-sample after=none output=true}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
-// Create a Metric View with naming conflicts
+// Create a Metric View with names reused across object types
 SemanticBridge.MetricView.Deserialize("""
-    version: 0.1
+    version: 1.1
     source: sales.fact.orders
-    dimensions:
-      # 'revenue' is used as both a dimension and measure name
+    joins:
+      - name: customer
+        source: sales.dim.customer
+        on: source.customer_id = customer.customer_id
+        cardinality: many_to_one
+    fields:
+      # 'revenue' is also used as a measure name below
       - name: revenue
         expr: source.revenue
       - name: quantity
         expr: source.quantity
-      - name: order_date
-        expr: source.order_date
     measures:
-      # measureNotDimensionRule violation - same name as dimension
+      # measureNameRule violation - same name as the 'revenue' field
       - name: revenue
         expr: SUM(source.revenue)
-      # noDuplicateMeasureRule violation - 'total_quantity' appears twice
-      - name: total_quantity
-        expr: SUM(source.quantity)
-      - name: total_quantity
-        expr: COUNT(source.order_id)
-      # This one is fine
+      # measureNotJoinRule violation - same name as the 'customer' join
+      - name: customer
+        expr: COUNT(DISTINCT source.customer_id)
+      # this measure is fine
       - name: order_count
         expr: COUNT(source.order_id)
     """);
 
-// Define contextual rules
-var measureNotDimensionRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
-    "measure_not_dimension_name",
+var measureNameRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
+    "measure_not_field_name",
     "naming",
     (measure, context) =>
-        context.DimensionNames.Contains(measure.Name)
-            ? [context.MakeError($"Measure '{measure.Name}' has the same name as a dimension")]
+        context.FieldNames.Contains(measure.Name)
+            ? [context.MakeError(
+                "measure_field_name_collision",
+                $"Measure '{measure.Name}' has the same name as a field",
+                measure)]
             : []
 );
 
-var noDuplicateMeasureRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
-    "no_duplicate_measures",
+var measureNotJoinRule = SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
+    "measure_not_join_name",
     "naming",
     (measure, context) =>
-        context.MeasureNames.Contains(measure.Name)
-            ? [context.MakeError($"Measure '{measure.Name}' is defined more than once")]
+        context.JoinNames.Contains(measure.Name)
+            ? [context.MakeError(
+                "measure_join_name_collision",
+                $"Measure '{measure.Name}' has the same name as a join",
+                measure)]
             : []
 );
 
-// Run validation
+// Run validation with both rules
 var diagnostics = SemanticBridge.MetricView.Validate([
-    measureNotDimensionRule,
-    noDuplicateMeasureRule
+    measureNameRule,
+    measureNotJoinRule
 ]).ToList();
 
 // Output results
@@ -187,26 +208,38 @@ CONTEXTUAL VALIDATION RESULTS
 
 Found 2 issue(s):
 
-[Error] Measure 'revenue' has the same name as a dimension
-[Error] Measure 'total_quantity' is defined more than once
+[Error] Measure 'revenue' has the same name as a field
+[Error] Measure 'customer' has the same name as a join
 ```
 
 ## Combining with default rules
 
-You can run contextual rules alongside the default validation rules:
+You can run contextual rules alongside the default validation rules by calling `Validate` twice:
 
-```csharp
+```csharp {run id=combined setup=mv-sample after=complete output=true}
 using MetricView = TabularEditor.SemanticBridge.Platforms.Databricks.MetricView;
 
 var customRules = new[] {
     SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
-        "measure_not_dimension_name",
+        "measure_not_field_name",
         "naming",
         (measure, context) =>
-            context.DimensionNames.Contains(measure.Name)
-                ? [context.MakeError($"Measure '{measure.Name}' has the same name as a dimension")]
-                : []
-    )
+            context.FieldNames.Contains(measure.Name)
+                ? [context.MakeError(
+                    "measure_field_name_collision",
+                    $"Measure '{measure.Name}' has the same name as a field",
+                    measure)]
+                : []),
+    SemanticBridge.MetricView.MakeValidationRule<MetricView.Measure>(
+        "measure_not_join_name",
+        "naming",
+        (measure, context) =>
+            context.JoinNames.Contains(measure.Name)
+                ? [context.MakeError(
+                    "measure_join_name_collision",
+                    $"Measure '{measure.Name}' has the same name as a join",
+                    measure)]
+                : [])
 };
 
 // Run default rules first
@@ -221,8 +254,13 @@ sb.AppendLine($"Custom rule issues: {customDiagnostics.Count}");
 Output(sb.ToString());
 ```
 
+**Output**
+
+```
+Default rule issues: 0
+Custom rule issues: 2
+```
+
 ## See also
 
 - [Semantic Bridge Validation](xref:semantic-bridge-metric-view-validation)
-- [Create Simple Validation Rules](xref:semantic-bridge-validate-simple-rules)
-- [Validate with Default Rules](xref:semantic-bridge-validate-default)
diff --git a/content/how-tos/semantic-bridge-validate-default.md b/content/how-tos/semantic-bridge-validate-default.md
index 6d73e7dbf..7739e9d55 100644
--- a/content/how-tos/semantic-bridge-validate-default.md
+++ b/content/how-tos/semantic-bridge-validate-default.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-validate-default
 title: Validate a Metric View with Default Rules
 author: Greg Baldini
-updated: 2026-04-17
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -19,38 +19,39 @@ applies_to:
 ---
 # Validate a Metric View with Default Rules
 
-This how-to demonstrates how to validate a loaded Metric View using the built-in validation rules and interpret the diagnostic messages.
+This how-to demonstrates validating a loaded Metric View using the built-in validation rules and interpreting the diagnostic messages.
+
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
+
+[!INCLUDE [sample](includes/sample-metricview.md)]
 
 ## Default validation rules
 
-The Semantic Bridge includes these built-in validation rules:
-
-| Rule                     | Description                                                                   |
-|--------------------------|-------------------------------------------------------------------------------|
-| JoinNameRequired         | Metric View Join must have a name                                             |
-| UniqueJoinName           | Metric View Join names must be unique                                         |
-| JoinSourceRequired       | Metric View Join must have a source                                           |
-| JoinOnOrUsingRequired    | Metric View Join must specify either `on` or `using`                          |
-| JoinOnOrUsingExclusivity | Metric View Join cannot specify both `on` and `using`                         |
-| JoinOnFormat             | Metric View Join `on` clause must be a valid equijoin expression              |
-| JoinUsingColumnCount     | Metric View Join `using` clause must have exactly one column (public preview limitation) |
-| DimensionNameRequired    | Metric View Dimension must have a name                                        |
-| UniqueDimensionName      | Metric View Dimension names must be unique                                    |
-| DimensionExprRequired    | Metric View Dimension must have an expression                                 |
-| MeasureNameRequired      | Metric View Measure must have a name                                          |
-| UniqueMeasureName        | Metric View Measure names must be unique                                      |
-| MeasureExprRequired      | Metric View Measure must have an expression                                   |
+The Semantic Bridge includes built-in rules that validate a Metric View definition against rules defined in [the Metric View documentation](https://learn.microsoft.com/azure/databricks/business-semantics/).
+These rules are automatically run upon deserialization, whether via `Deserialize` directly or any method that reads a Metric View, such as `Load` or `ImportToTabularFromFile`.
+Diagnostics from those automatic runs remain available afterward through `SemanticBridge.MetricView.ImportDiagnostics`.
+You can also run these rules on demand against the loaded Metric View, which this document covers.
 
 ## Run validation with default rules
 
-Call `Validate()` with no arguments to use the built-in validation rules.
+Run [`SemanticBridge.MetricView.Validate();`](xref:TabularEditor.SemanticBridge.Platforms.Databricks.DatabricksMetricViewService.Validate) with no arguments to run the built-in rules against the loaded Metric View.
 
-```csharp
+```csharp {run id=validate-count setup=mv-sample after=none output=true}
 var diagnostics = SemanticBridge.MetricView.Validate().ToList();
 
 Output($"Validation complete: {diagnostics.Count} issue(s) found");
 ```
 
+**Output**
+
+```
+Validation complete: 0 issue(s) found
+```
+
+The sample Metric View is valid, so this reports no issues.
+
 ## Interpret diagnostic messages
 
 Each diagnostic message contains:
@@ -59,7 +60,7 @@ Each diagnostic message contains:
 - **Message**: Description of the issue
 - **Path**: Location of the object in the Metric View hierarchy
 
-```csharp
+```csharp {run id=interpret setup=mv-sample after=none output=true}
 var diagnostics = SemanticBridge.MetricView.Validate().ToList();
 
 var sb = new System.Text.StringBuilder();
@@ -84,55 +85,43 @@ else
 Output(sb.ToString());
 ```
 
-## Example with validation errors
-
-Some rules (required fields) are enforced during deserialization.
-The remaining rules check for duplicates and structural issues after deserialization.
-
-This Metric View demonstrates violations that are caught by `Validate()`:
-
-```csharp
-SemanticBridge.MetricView.Deserialize("""
-    version: 0.1
-    source: sales.fact.orders
-    joins:
-      # UniqueJoinName - duplicate name 'customer'
-      - name: customer
-        source: sales.dim.customer
-        on: customer_id = customer.customer_id
-      - name: customer
-        source: sales.dim.customer_backup
-        on: customer_id = customer_backup.customer_id
-      # JoinOnOrUsingRequired - neither on nor using
-      - name: date
-        source: sales.dim.date
-    dimensions:
-      # UniqueDimensionName - duplicate name 'category'
-      - name: category
-        expr: product.category
-      - name: category
-        expr: product.subcategory
-      - name: product_name
-        expr: product.product_name
-    measures:
-      # UniqueMeasureName - duplicate name 'total'
-      - name: total
-        expr: SUM(revenue)
-      - name: total
-        expr: SUM(quantity)
-      - name: order_count
-        expr: COUNT(order_id)
-    """);
+**Output**
+
+```
+VALIDATION RESULTS
+------------------
+
+No issues found.
+```
+
+## Example with a validation error
+
+Validation always runs against the currently loaded Metric View, so you can introduce a violation in a script and see it caught.
+Here we clear a field's expression to trigger `FieldExprRequired`:
+
+```csharp {run id=error-example setup=mv-sample after=none output=true}
+var view = SemanticBridge.MetricView.Model;
+view.Fields["order_year"].Expr = "";
 
 var diagnostics = SemanticBridge.MetricView.Validate().ToList();
 
 var sb = new System.Text.StringBuilder();
-sb.AppendLine($"Found {diagnostics.Count} issue(s):");
+sb.AppendLine("VALIDATION RESULTS");
+sb.AppendLine("------------------");
 sb.AppendLine("");
 
-foreach (var diag in diagnostics)
+if (diagnostics.Count == 0)
+{
+    sb.AppendLine("No issues found.");
+}
+else
 {
-    sb.AppendLine($"[{diag.Severity}] {diag.Message}");
+    foreach (var diag in diagnostics)
+    {
+        sb.AppendLine($"[{diag.Severity}] {diag.Message}");
+        sb.AppendLine($"  Path: {diag.Path}");
+        sb.AppendLine("");
+    }
 }
 
 Output(sb.ToString());
@@ -141,21 +130,18 @@ Output(sb.ToString());
 **Output:**
 
 ```
-Found 6 issue(s):
-
-[Error] Join 'customer' must use a simple equality condition with table prefixes (e.g. 'source.column = dimension.column')
-[Error] Duplicate join name: 'customer'
-[Error] Join 'customer' must use a simple equality condition with table prefixes (e.g. 'source.column = dimension.column')
-[Error] Join 'date' must specify either 'on' or 'using' clause
-[Error] Duplicate dimension name: 'category'
-[Error] Duplicate measure name: 'total'
+VALIDATION RESULTS
+------------------
+
+[Error] Field 'order_year' expr cannot be empty
+  Path: Model.Fields["order_year"].Expr
 ```
 
 ## Filter diagnostics by severity
 
 You can filter diagnostics to focus on errors only:
 
-```csharp
+```csharp {run id=filter-severity setup=mv-sample after=none output=true}
 using System.Linq;
 using TabularEditor.SemanticBridge.Orchestration;
 
@@ -168,10 +154,17 @@ sb.AppendLine($"Total issues: {diagnostics.Count}");
 Output(sb.ToString());
 ```
 
+**Output**
+
+```
+Errors: 0
+Total issues: 0
+```
+
 ## Next steps
 
-- [Create simple validation rules](xref:semantic-bridge-validate-simple-rules) to enforce your own conventions
-- [Create contextual validation rules](xref:semantic-bridge-validate-contextual-rules) for cross-object checks
+- [Create simple validation rules](xref:semantic-bridge-validate-simple-rules)
+- [Create contextual validation rules](xref:semantic-bridge-validate-contextual-rules)
 
 ## See also
 
diff --git a/content/how-tos/semantic-bridge-validate-simple-rules.md b/content/how-tos/semantic-bridge-validate-simple-rules.md
index 14e89b29d..18d275d46 100644
--- a/content/how-tos/semantic-bridge-validate-simple-rules.md
+++ b/content/how-tos/semantic-bridge-validate-simple-rules.md
@@ -2,7 +2,7 @@
 uid: semantic-bridge-validate-simple-rules
 title: Create Simple Validation Rules
 author: Greg Baldini
-updated: 2025-01-27
+updated: 2026-07-02
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -22,13 +22,17 @@ applies_to:
 This how-to demonstrates how to create simple predicate-based validation rules to enforce naming conventions and structural requirements.
 These rules are for illustrative purposes only and do not necessarily reflect hard technical requirements of either Metric Views or the Semantic Bridge.
 
+> [!NOTE]
+> These how-tos target Tabular Editor 3.26.2 and later.
+> Earlier versions do not support the v1.1 Metric View features shown here.
+
 ## The four rule helpers
 
 There is a helper method for each type of Metric View object:
 
 - `MakeValidationRuleForView` - rules for the root View object
 - `MakeValidationRuleForJoin` - rules for Join objects
-- `MakeValidationRuleForDimension` - rules for Dimension objects
+- `MakeValidationRuleForField` - rules for Field objects
 - `MakeValidationRuleForMeasure` - rules for Measure objects
 
 Each helper takes four parameters:
@@ -42,7 +46,7 @@ Each helper takes four parameters:
 
 Check that the Metric View version is the expected value:
 
-```csharp
+```csharp {compile}
 var versionRule = SemanticBridge.MetricView.MakeValidationRuleForView(
     "version_check",
     "structure",
@@ -55,7 +59,7 @@ var versionRule = SemanticBridge.MetricView.MakeValidationRuleForView(
 
 Check that Metric View join sources use fully qualified table names (contain a dot):
 
-```csharp
+```csharp {compile}
 var joinSourceRule = SemanticBridge.MetricView.MakeValidationRuleForJoin(
     "qualified_source",
     "structure",
@@ -64,16 +68,16 @@ var joinSourceRule = SemanticBridge.MetricView.MakeValidationRuleForJoin(
 );
 ```
 
-## Rule for Metric View Dimension
+## Rule for Metric View Field
 
-Check that Metric View dimension names do not contain underscores:
+Check that Metric View field names do not contain underscores:
 
-```csharp
-var dimensionNameRule = SemanticBridge.MetricView.MakeValidationRuleForDimension(
+```csharp {compile}
+var fieldNameRule = SemanticBridge.MetricView.MakeValidationRuleForField(
     "no_underscores",
     "naming",
-    "Dimension names should use spaces, not underscores",
-    (dim) => dim.Name.Contains('_')
+    "Field names should use spaces, not underscores",
+    (field) => field.Name.Contains('_')
 );
 ```
 
@@ -81,7 +85,7 @@ var dimensionNameRule = SemanticBridge.MetricView.MakeValidationRuleForDimension
 
 Check that Metric View measure expressions do not contain SELECT (to avoid accidental subqueries):
 
-```csharp
+```csharp {compile}
 var measureExprRule = SemanticBridge.MetricView.MakeValidationRuleForMeasure(
     "no_select_subquery",
     "structure",
@@ -90,11 +94,28 @@ var measureExprRule = SemanticBridge.MetricView.MakeValidationRuleForMeasure(
 );
 ```
 
+## Rules for specific Metric View versions
+
+Each helper has an overload that takes a final `minVersion` argument, a string such as "0.1" or "1.1".
+Rules defined with a `minVersion` only run against Metric Views at or above that version.
+This is useful for a rule that checks a property introduced in a later version,
+such as `display_name` (added in v1.1):
+
+```csharp {compile}
+var displayNameRule = SemanticBridge.MetricView.MakeValidationRuleForField(
+    "field_display_name_required",
+    "naming",
+    "Fields should have a display name set",
+    (field) => string.IsNullOrEmpty(field.DisplayName),
+    "1.1"
+);
+```
+
 ## Complete example
 
 This Metric View has violations for each of the rules defined above:
 
-```csharp
+```csharp {run id=complete setup=mv-sample after=none output=true}
 // Create a Metric View with violations for each rule
 SemanticBridge.MetricView.Deserialize("""
     version: 0.2
@@ -104,8 +125,8 @@ SemanticBridge.MetricView.Deserialize("""
       - name: customer
         source: customer_table
         on: source.customer_id = customer.customer_id
-    dimensions:
-      # dimensionNameRule violations - contains underscores
+    fields:
+      # fieldNameRule violations - contains underscores
       - name: product_name
         expr: source.product_name
       - name: order_date
@@ -136,11 +157,11 @@ var joinSourceRule = SemanticBridge.MetricView.MakeValidationRuleForJoin(
     (join) => !join.Source.Contains('.')
 );
 
-var dimensionNameRule = SemanticBridge.MetricView.MakeValidationRuleForDimension(
+var fieldNameRule = SemanticBridge.MetricView.MakeValidationRuleForField(
     "no_underscores",
     "naming",
-    "Dimension names should use spaces, not underscores",
-    (dim) => dim.Name.Contains('_')
+    "Field names should use spaces, not underscores",
+    (field) => field.Name.Contains('_')
 );
 
 var measureExprRule = SemanticBridge.MetricView.MakeValidationRuleForMeasure(
@@ -154,7 +175,7 @@ var measureExprRule = SemanticBridge.MetricView.MakeValidationRuleForMeasure(
 var diagnostics = SemanticBridge.MetricView.Validate([
     versionRule,
     joinSourceRule,
-    dimensionNameRule,
+    fieldNameRule,
     measureExprRule
 ]).ToList();
 
@@ -182,18 +203,17 @@ CUSTOM VALIDATION RESULTS
 
 Found 5 issue(s):
 
-[Error] MetricView: Metric View version must be 0.1 or 1.1
-[Error] MetricView.Joins['customer']: Join source must be a fully qualified table name (e.g., `catalog.schema.table`)
-[Error] MetricView.Dimensions['product_name']: Dimension names should use spaces, not underscores
-[Error] MetricView.Dimensions['order_date']: Dimension names should use spaces, not underscores
-[Error] MetricView.Measures['complex_calc']: Measure expressions should not contain SELECT subqueries
+[Error] Model: Metric View version must be 0.1 or 1.1
+[Error] Model.Joins["customer"]: Join source must be a fully qualified table name (e.g., `catalog.schema.table`)
+[Error] Model.Fields["product_name"]: Field names should use spaces, not underscores
+[Error] Model.Fields["order_date"]: Field names should use spaces, not underscores
+[Error] Model.Measures["complex_calc"]: Measure expressions should not contain SELECT subqueries
 ```
 
 ## Next steps
 
-- [Create contextual validation rules](xref:semantic-bridge-validate-contextual-rules) for cross-object checks like duplicate detection
+- [Create contextual validation rules](xref:semantic-bridge-validate-contextual-rules)
 
 ## See also
 
 - [Semantic Bridge Validation](xref:semantic-bridge-metric-view-validation)
-- [Validate with Default Rules](xref:semantic-bridge-validate-default)
diff --git a/content/how-tos/toc.md b/content/how-tos/toc.md
index 0c1f275ac..4b1c1ecd3 100644
--- a/content/how-tos/toc.md
+++ b/content/how-tos/toc.md
@@ -55,6 +55,7 @@
 
 # [Semantic Bridge](semantic-bridge-how-tos.md)
 ## @semantic-bridge-load-inspect
+## @semantic-bridge-metric-view-import-from-file
 ## @semantic-bridge-import
 ## @semantic-bridge-validate-default
 ## @semantic-bridge-validate-simple-rules
@@ -63,3 +64,4 @@
 ## @semantic-bridge-remove-object
 ## @semantic-bridge-rename-objects
 ## @semantic-bridge-serialize
+## @semantic-bridge-metric-view-handle-failures
diff --git a/content/references/downloads.md b/content/references/downloads.md
index 320d6cb78..494bdfe71 100644
--- a/content/references/downloads.md
+++ b/content/references/downloads.md
@@ -2,7 +2,7 @@
 uid: downloads
 title: All downloads
 author: Daniel Otykier
-updated: 2026-06-25
+updated: 2026-07-10
 ---
 # Tabular Editor 3 Downloads
 
@@ -10,14 +10,14 @@ This page provides download and installation instructions for Tabular Editor 3.
 
 ## Latest version
 
-Tabular Editor 3.26.2 **.NET 8** downloads:
+Tabular Editor 3.26.3 **.NET 8** downloads:
 
-- Download [Tabular Editor 3.26.2 (64 bit)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe) *(recommended)*
-- Download [Tabular Editor 3.26.2 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
-- Portable versions: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
-- MSI version: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
+- Download [Tabular Editor 3.26.3 (64 bit)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) *(recommended)*
+- Download [Tabular Editor 3.26.3 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+- Portable versions: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+- MSI version: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
 
-Read the [latest release notes](release-notes/3_26_2.md).
+Read the [latest release notes](release-notes/3_26_3.md).
 
 ## Installation Instructions
 
@@ -29,6 +29,10 @@ It is not necessary to remove previous installations when upgrading to a newer v
 
 ## History
 
+- 2026-07-10 **Tabular Editor 3.26.3** (*[Release notes](release-notes/3_26_3.md)*)
+  - .NET 8 installer (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+  - .NET 8 portable (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+  - .NET 8 installer (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
 - 2026-06-25 **Tabular Editor 3.26.2** (*[Release notes](release-notes/3_26_2.md)*)
   - .NET 8 installer (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
   - .NET 8 portable (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
diff --git a/content/references/release-history.md b/content/references/release-history.md
index b241f9fdd..f8a7b5b17 100644
--- a/content/references/release-history.md
+++ b/content/references/release-history.md
@@ -4,6 +4,10 @@ title: Full release history
 ---
 # Full release history
 
+- 2026-07-10 **Tabular Editor 3.26.3** (*[Release notes](release-notes/3_26_3.md)*)
+  - .NET 8 installer (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+  - .NET 8 portable (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+  - .NET 8 installer (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
 - 2026-06-25 **Tabular Editor 3.26.2** (*[Release notes](release-notes/3_26_2.md)*)
   - .NET 8 installer (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
   - .NET 8 portable (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
diff --git a/content/references/release-notes/3_26_3.md b/content/references/release-notes/3_26_3.md
new file mode 100644
index 000000000..dbb47faa3
--- /dev/null
+++ b/content/references/release-notes/3_26_3.md
@@ -0,0 +1,62 @@
+---
+uid: release-3-26-3
+---
+# Tabular Editor 3.26.3
+
+# [**Downloads**](#tab/downloads)
+
+Tabular Editor 3.26.3 downloads:
+
+- Download [Tabular Editor 3.26.3 (x64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) *(recommended)*
+- Download [Tabular Editor 3.26.3 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+- Portable versions: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+- MSI version: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+
+*If you haven't used Tabular Editor 3 before, you are eligible to a 30 day trial, which can be activated after installation. You can also [purchase a license](https://tabulareditor.com/licensing).*
+
+# [**SHA-256 checksums**](#tab/checksums)
+
+| File | .NET runtime | Platform | SHA-256 |
+| -- | -- | -- | -- |
+| [TabularEditor.3.26.3.Installer.x64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) | .NET 8 | x64 | `2413B042E935F010EA03E1EE7D01B6F0CDD076B10F29F1CD5651BECE1F4ADEEC` |
+| [TabularEditor.3.26.3.x64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi)                     | .NET 8 | x64 | `AE7DBAE6A0432EFDB75765F6C1B3CE91495018F058A24BE67EB2BC7DF39BD915` |
+| [TabularEditor.3.26.3.x64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip)                     | .NET 8 | x64 | `AAEB730DADA50A424F55D0AC41961E23D09F3913A72DB240319D78271BF7DAE2` |
+| [TabularEditor.3.26.3.Installer.ARM64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe) | .NET 8 | ARM64 | `8563D579F32F776A8BF4BA75D17C11B1094E1550B24DD448A2404D63860E8F78` |
+| [TabularEditor.3.26.3.ARM64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)                     | .NET 8 | ARM64 | `FC9F0B2D7B8F75BFDCBFB534CF8450E44014E706D1FB125544317A0C4683D4F2` |
+| [TabularEditor.3.26.3.ARM64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)                     | .NET 8 | ARM64 | `37312FB9D663FA59AB07D3AA45F88B21B8FF812B8F185AF8DCFCB4D9A8583AA7` |
+
+***
+
+## Bugfixes in 3.26.3
+
+- Fixed an issue where a failed File > Revert (for example, when the on-disk TMDL contains an unresolvable reference) could permanently disable unsaved-changes tracking for the rest of the session. Previously, subsequent edits would no longer show the dirty asterisk, and Revert or Close could silently discard unsaved changes without warning. Change tracking now remains active after a failed revert.
+- On folder-serialized (TMDL) models, File > Revert no longer leaves the model showing as having unsaved changes after a successful revert. Previously the title-bar asterisk and the "Refresh metadata from source?" confirmation would persist on every subsequent revert until the model was saved.
+- Fixed DAX auto-complete suggesting user-defined functions (UDFs) that are not valid in the current argument context, and omitting valid ones. UDFs are now filtered by their inferred return type: where a scalar is expected, only UDFs returning a scalar, a single-column table, or an untyped input parameter are shown; where a table is expected, only table-returning (or passthrough) UDFs are shown; and filter arguments (such as those of CALCULATE / CALCULATETABLE) now suggest UDFs, which were previously omitted entirely. UDFs whose definition contains a semantic error (for example, one that requires row context or misuses MATCHBY) are no longer offered as suggestions, as they cannot be validly invoked.
+- The DAX formatter no longer replaces the `=` of a DAX function's default parameter value with a `:`. Previously, formatting a function such as `(p = [m]) => 1` produced the invalid `(p: [m]) => 1`, because the formatter assumed any tokens after a parameter name were a `: type` annotation. Type annotations, default values, and the combination of both (`p: INT64 = 1`) are now formatted correctly.
+- Fixed an issue where marking a DAX Optimizer issue as ignored had no effect after uploading a new version of an obfuscated model: the ignored issue would reappear as open. Ignored issues are now retained across versions of obfuscated models.
+- Fixed an intermittent crash ("Collection was modified") that could occur in the DAX Optimizer view right after uploading a model or a new version. The view is now refreshed while the progress spinner is still shown, instead of refreshing in the background as the window was being redrawn.
+
+---
+## Coming from Tabular Editor 2.x?
+
+Watch [this video](https://youtu.be/O4ATwdzCvWc) to get a quick tour of the main features in Tabular Editor 3. Also, make sure to check our [onboarding guide](https://docs.tabulareditor.com/onboarding/index.html).
+
+**Tabular Editor 3 major features overview:**
+- Fully customizable IDE, with multi-monitor, Hi-DPI support and themes
+- New powerful DAX code editor with auto-complete, syntax checking, code folding and much, much more
+- *Workspace mode, allowing you to save your changes to disk and synchronise model metadata to Analysis Services simultaneously
+- *Preview table data with infinite scrolling, create PivotGrids or write DAX queries to browse the model or test calculation logic
+- *Schedule data refreshes
+- Update Table Schemas on both Provider and Structured Data Sources (yes, even for M queries!)
+- Create data model diagrams
+- Create DAX scripts that allow you to edit multiple measures or other calculated objects in a single document
+- Record C# scripts and save as macros (formerly known as "Custom Actions")
+- VertiPaq Analyzer integration
+- DAX debugger
+- DAX Optimizer integration
+- Code Actions to easily refactor you DAX.
+
+*=Only while connected to an instance of Analysis Services or Power BI
+
+---
+
diff --git a/content/references/roadmap.md b/content/references/roadmap.md
index 6cb9e6576..30feed902 100644
--- a/content/references/roadmap.md
+++ b/content/references/roadmap.md
@@ -18,7 +18,7 @@ Below is an overview of major new features to be shipped with Tabular Editor 3 u
 
 ## In Development
 
-- **Semantic Bridge enhancements**: Support for v1.1 properties and enhanced import UI
+- **Semantic Bridge enhancements**: Enhanced import UI, support for multi-fact pattern
 - **Localization improvements**: Expanding language support and refining existing translations
 - **Power Query (M) Auto-Formatting**: Advanced formatting capabilities for M expressions
 - **Graphical Model Comparison**: See the changes that are applied to 
@@ -51,7 +51,7 @@ For detailed information about each release, see the [full release history](xref
 
 ✅ [**Built-in Best Practice Analyzer rules**](xref:built-in-bpa-rules) - Comprehensive set of BPA rules covering formatting, metadata, model layout, DAX expressions, and translations (v3.25.0)
 
-✅ **Semantic Bridge** - Create semantic models from Databricks Metric Views (Enterprise Edition, v3.25.0)
+✅ **Semantic Bridge** - Create semantic models from Databricks Metric Views (Enterprise Edition, v3.25.0); support for Metric View v1.1 spec
 
 ✅ [**Save with supporting files for Fabric**](xref:save-with-supporting-files) - Support for .platform and definition.pbism files to match Fabric repository structure (v3.25.0)
 
diff --git a/localizedContent/es/content/features/ai-assistant.md b/localizedContent/es/content/features/ai-assistant.md
index 30f01f3ff..61b6b309e 100644
--- a/localizedContent/es/content/features/ai-assistant.md
+++ b/localizedContent/es/content/features/ai-assistant.md
@@ -2,7 +2,7 @@
 uid: ai-assistant
 title: Asistente de IA
 author: Morten Lønskov
-updated: 2026-04-17
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -44,11 +44,11 @@ El Asistente de IA utiliza un modelo BYOK de clave aportada por el usuario. Tú
 
 ## Proveedores compatibles
 
-Configura tu proveedor de IA en **Herramientas > Preferencias > Asistente de IA > Proveedor de IA**. Selecciona un proveedor en la lista desplegable — el valor predeterminado es **Ninguno (IA deshabilitada)** hasta que configures uno — introduce tu clave de API y, si lo deseas, reemplaza el modelo predeterminado. Para OpenAI y Anthropic, el campo **Nombre del modelo** es un cuadro combinado rellenado previamente con modelos conocidos; también puedes escribir un nombre de modelo personalizado.
+Configura tu proveedor de IA en **Herramientas > Preferencias > Asistente de IA > Proveedor de IA**. Selecciona un proveedor en la lista desplegable — el valor predeterminado es **Ninguno (IA deshabilitada)** hasta que configures uno — introduce tu clave de API y, si lo deseas, reemplaza el modelo predeterminado. Para OpenAI y Anthropic, el campo **Nombre del modelo** es un cuadro combinado que viene relleno con los modelos actuales —incluidos `claude-fable-5` y `claude-opus-4-8` de Anthropic, y `gpt-5.5` y `gpt-5.5-pro` de OpenAI—, de modo que puedes elegir un modelo reciente sin tener que escribir un ID personalizado. También puedes escribir un nombre de modelo personalizado.
 
 | Proveedor                                                | Modelo predeterminado            | Configuración necesaria                                                                |
 | -------------------------------------------------------- | -------------------------------- | -------------------------------------------------------------------------------------- |
-| OpenAI                                                   | gpt-4o                           | Clave de API. URL base, ID de organización e ID de proyecto opcionales |
+| OpenAI                                                   | gpt-5.5          | Clave de API. URL base, ID de organización e ID de proyecto opcionales |
 | Anthropic                                                | claude-sonnet-4-6                | Clave de API. URL base opcional                                        |
 | Azure OpenAI                                             | Dependiente de la implementación | Clave de API, URL del punto de conexión y nombre de la implementación                  |
 | Personalizado (compatible con OpenAI) | Especificado por el usuario      | Clave de API y URL personalizada del punto de conexión                                 |
@@ -57,7 +57,7 @@ Configura tu proveedor de IA en **Herramientas > Preferencias > Asistente de IA
 
 ### OpenAI
 
-Selecciona **OpenAI** como proveedor e introduce tu clave de API. Opcionalmente, puedes especificar un ID de organización y un ID de proyecto si tu cuenta de OpenAI los usa. El modelo predeterminado es **gpt-4o**, pero puedes cambiarlo por cualquier modelo disponible en tu cuenta.
+Selecciona **OpenAI** como proveedor e introduce tu clave de API. Opcionalmente, puedes especificar un ID de organización y un ID de proyecto si tu cuenta de OpenAI los usa. El modelo predeterminado es **gpt-5.5**, pero puedes cambiarlo por cualquier modelo disponible en tu cuenta.
 
 ![Configuración de OpenAI en el Asistente de IA](~/content/assets/images/ai-assistant/ai-assistant-openai-config.png)
 
diff --git a/localizedContent/es/content/features/table-groups.md b/localizedContent/es/content/features/table-groups.md
index 4ebda5070..19350208d 100644
--- a/localizedContent/es/content/features/table-groups.md
+++ b/localizedContent/es/content/features/table-groups.md
@@ -2,7 +2,7 @@
 uid: table-groups
 title: Grupos de tablas
 author: Daniel Otykier
-updated: 2023-03-08
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -25,6 +25,8 @@ Los grupos de tablas son una nueva funcionalidad disponible en Tabular Editor 3
 
 Puedes configurar los grupos de tablas haciendo clic con el botón derecho en una tabla y eligiendo la opción de menú **Crear > Grupo de tablas**, o bien especificando un nombre para el grupo de tablas en la **vista de propiedades** mientras seleccionas una o varias tablas.
 
+También puedes usar el submenú contextual **Mover al grupo** al hacer clic con el botón derecho en una o varias tablas seleccionadas. El submenú muestra los grupos de tablas existentes, una opción **(Nuevo...)** que crea un nuevo grupo a partir de las tablas seleccionadas y abre el editor para asignarle un nombre, y una opción **(Ninguno)** que elimina la asignación del grupo de tablas.
+
 Las tablas se pueden mover entre grupos de tablas arrastrando y soltando en el Explorador TOM. Ten en cuenta que, a diferencia de las carpetas de visualización para medidas, columnas y jerarquías, los grupos de tablas no se pueden anidar.
 
 Al hacer clic con el botón derecho en un grupo de tablas en el Explorador TOM, obtienes las mismas opciones del menú contextual que si hubieras seleccionado la tabla o las tablas dentro de ese grupo de tablas.
diff --git a/localizedContent/es/content/features/te-cli/includes/te-cli-preview-notice.md b/localizedContent/es/content/features/te-cli/includes/te-cli-preview-notice.md
index 7914d6072..e92f53863 100644
--- a/localizedContent/es/content/features/te-cli/includes/te-cli-preview-notice.md
+++ b/localizedContent/es/content/features/te-cli/includes/te-cli-preview-notice.md
@@ -1,2 +1,2 @@
 > [!IMPORTANT]
-> La CLI de Tabular Editor se encuentra en **vista previa pública limitada**. Se ofrece para su evaluación con una cuenta de Tabular Editor; no se requiere ninguna licencia durante la vista previa. Los comandos, las opciones y las salidas pueden cambiar antes de la disponibilidad general. **La versión preliminar deja de funcionar después de 2026-09-30.** No recomendamos usar la CLI en pipelines de CI/CD de producción durante la vista previa. Consulta nuestro acuerdo de licencia.
+> La CLI de Tabular Editor se encuentra en **vista previa pública limitada**. Se ofrece para su evaluación con una cuenta de Tabular Editor; no se requiere ninguna licencia durante la vista previa. Los comandos, las opciones y las salidas pueden cambiar antes de la disponibilidad general. **La versión preliminar deja de funcionar después de 2026-09-30.** No recomendamos usar la CLI en pipelines de CI/CD de producción durante la vista previa.
diff --git a/localizedContent/es/content/features/te-cli/te-cli-automation.md b/localizedContent/es/content/features/te-cli/te-cli-automation.md
index 35f9f7774..061c5f724 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-automation.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-automation.md
@@ -28,11 +28,11 @@ Use `--output-format` para alternar cualquier comando entre el formato de texto
 | `text` (predeterminado) | Para uso humano                                                                                                                                                                      | Texto sin formato en stdout, independientemente de si el flujo es un TTY o se canaliza.                                                     |
 | `json`                                     | Para uso por máquina                                                                                                                                                                 | Siempre devuelve JSON válido en stdout. Use `--error-format json` si también quiere errores legibles por máquina en stderr. |
 | `csv`                                      | Resultados tabulares (`query`, `bpa run`, `bpa rules`, `vertipaq`, `validate`, `test`, `refresh`, `profile list`, `session list`, `find`, `replace`, `get`, `ls`) | Escapado según RFC 4180.                                                                                                                    |
-| `tmsl` (alias `bim`)    | Serialización TMSL/BIM del objeto completo                                                                                                                                           | Aceptado por `te get` y `te ls`.                                                                                                            |
+| `tmsl` (alias `bim`)    | Serialización TMSL/BIM del objeto completo                                                                                                                                           | Admitido por `te get` y `te list`.                                                                                                          |
 | `tmdl`                                     | Serialización TMDL del objeto completo                                                                                                                                               | Aceptado solo por `te get` (un solo objeto).                                                                             |
 
 ```bash
-te ls --output-format json
+te list --output-format json
 te query -q "EVALUATE VALUES('Date'[Year])" --output-format csv
 te bpa run --output-format json
 ```
@@ -52,11 +52,11 @@ te deploy ./model --non-interactive --force --ci github
 
 Todos los comandos de `te` finalizan con un código de estado predecible, para que quien los invoque pueda tomar decisiones según el éxito o el error sin tener que analizar stdout.
 
-| Código de salida | Significado                                                                                                                                                                                                                                                                                                                      |
-| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `0`              | Éxito.                                                                                                                                                                                                                                                                                                           |
-| `1`              | Error genérico: argumentos inválidos, fallo del comando, errores de validación, error de autenticación, fallo en la comprobación de BPA con severidad ≥ error. En `te diff`: se encontraron diferencias (como en la convención `diff`/`cmp`). |
-| `2`              | Solo en `te diff`: se produjo un error durante la comparación, por lo que se desconoce el estado de las diferencias.                                                                                                                                                                             |
+| Código de salida | Significado                                                                                                                                                                                                                                                                                                                        |
+| ---------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `0`              | Éxito.                                                                                                                                                                                                                                                                                                             |
+| `1`              | Fallo genérico: argumentos no válidos, fallo del comando, errores de validación, fallo de autenticación, fallo en la comprobación de BPA con severidad >= error. En `te diff`: se encontraron diferencias (como en la convención `diff`/`cmp`). |
+| `2`              | Solo en `te diff`: se produjo un error durante la comparación, por lo que se desconoce el estado de las diferencias.                                                                                                                                                                               |
 
 Combina los códigos de salida con las anotaciones `--ci <vsts\|github>` y `--trx <file>` para mostrar información detallada sobre los errores en CI; consulta @te-cli-cicd.
 
@@ -65,7 +65,7 @@ Combina los códigos de salida con las anotaciones `--ci <vsts\|github>` y `--tr
 Los errores, las advertencias y el banner de versión preliminar se escriben en **stderr**; los datos estructurados se escriben en **stdout**. Esto significa que puedes canalizar JSON de forma segura sin que se contamine con indicadores de progreso ni mensajes de diagnóstico:
 
 ```bash
-te ls --output-format json | jq '.[] | .name'
+te list --output-format json | jq '.[] | .name'
 te vertipaq --output-format json > stats.json
 ```
 
@@ -152,7 +152,7 @@ Compón comandos con pipes y `jq`. La salida de texto de la CLI está coloreada
 
 ```bash
 # Count measures per table
-te ls --type measure --output-format json \
+te list --type measure --output-format json \
   | jq -r '.[] | .table' \
   | sort | uniq -c | sort -rn
 ```
@@ -179,10 +179,10 @@ El TMSL resultante puede revisarse en un pull request, confirmarse mediante un c
 
 Algunos patrones pequeños que aparecen a menudo al componer comandos de `te` en scripts o pipelines:
 
-- **Creaciones y eliminaciones idempotentes de medidas.** `te add Sales/Marker -t Measure -i "0" --if-not-exists --save` y `te rm Sales/OldMeasure --if-exists --save` salen con código `0` exista o no el objeto; es seguro volver a ejecutarlos en CI.
+- **Creaciones y eliminaciones idempotentes de medidas.** `te add Sales/Marker -t Measure -i "0" --if-not-exists --save` y `te remove Sales/OldMeasure --if-exists --save` terminan con código de salida `0` exista o no el objeto; es seguro volver a ejecutarlos en CI.
 - **Diferencias en modo de prueba.** `te replace` funciona en modo de prueba de forma predeterminada; añade `--save` solo cuando estés conforme con la vista previa.
 - **Genera TMSL para revisión.** `te deploy ./model --xmla deploy.tmsl` produce el script de implementación sin tocar el servidor; útil para que lo revise un DBA o para aplicarlo manualmente.
-- **Salida solo con rutas.** `te ls --paths-only` y `te find --paths-only` emiten una ruta de objeto por línea, ideal para canalizarlo a `xargs`, `te get` o `te set`. Los contenedores a nivel de modelo para medidas (`te ls Measures`, `te ls Columns`) se combinan bien con esto para recorridos completos del modelo.
+- **Salida solo con rutas.** `te list --paths-only` y `te find --paths-only` emiten una ruta de objeto por línea, ideal para canalizar la salida a `xargs`, `te get` o `te set`. Los contenedores a nivel de modelo para medidas (`te list Measures`, `te list Columns`) se combinan bien con esto para realizar barridos de todo el modelo.
 - **Pruebas de rendimiento de consultas.** `te query --trace --cold --runs 5` ejecuta una consulta DAX con caché en frío, cinco iteraciones y captura eventos de traza de FE/SE.
 - **Tiempos por paso en los logs de CI.** Los comandos de larga duración (`te deploy`, `te refresh`, `te script`, `te validate`) incluyen un campo `durationMs` en la salida JSON; útil para mostrar los tiempos de cada paso en los resúmenes del pipeline.
 
diff --git a/localizedContent/es/content/features/te-cli/te-cli-cicd.md b/localizedContent/es/content/features/te-cli/te-cli-cicd.md
index f54a82dee..b5d8b9689 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-cicd.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-cicd.md
@@ -167,7 +167,7 @@ steps:
 
 `te deploy` y `te save` ejecutan el Best Practice Analyzer como compuerta de verificación previa de forma predeterminada. Hay tres comportamientos que conviene definir de antemano:
 
-- **Aplicar**: el valor predeterminado. El pipeline falla si el BPA encuentra infracciones con severidad ≥ error. Combínalo con `--fail-on warning` en un paso independiente de `te bpa run` si quieres que las advertencias también hagan fallar el pipeline.
+- **Aplicar**: el valor predeterminado. El pipeline falla si BPA detecta infracciones con severidad >= error. Combínalo con `--fail-on warning` en un paso independiente de `te bpa run` si quieres que las advertencias también hagan fallar el pipeline.
 - **Corrección automática**: `--fix-bpa` aplica las `fixExpression`s en memoria al artefacto desplegado. Los archivos de origen no se modifican. Es útil cuando la fuente de verdad está en el modelo y quieres que los despliegues normalicen el estilo sin intervención del desarrollador.
 - **Omitir**: `--skip-bpa` desactiva el control para un solo comando. Útil para correcciones urgentes de emergencia; no se recomienda como valor predeterminado.
 
diff --git a/localizedContent/es/content/features/te-cli/te-cli-commands.md b/localizedContent/es/content/features/te-cli/te-cli-commands.md
index 92303da9b..bdcc6e92a 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-commands.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-commands.md
@@ -31,8 +31,8 @@ te bpa run --help           # Help for a command with subcommands
 
 El direccionamiento de objetos en la CLI usa una única gramática compartida por todos los comandos. En la referencia siguiente aparecen dos tipos de ruta:
 
-- **`<path>`**: identifica **exactamente un** objeto o contenedor. Lo usan los comandos que operan sobre un único destino: `te get`, `te set`, `te add`, `te rm`, `te mv`, `te format -p`, `te deps`, `te macro run --on`.
-- **`<path-filter>`**: identifica **cero o más** objetos y admite comodines. Lo usan los comandos que operan sobre un conjunto: `te ls`, `te bpa run --path` y otros comandos de tipo inspección.
+- **`<path>`**: identifica **exactamente un** objeto o contenedor. Los utilizan los comandos que operan sobre un único destino: `te get`, `te set`, `te add`, `te remove`, `te move`, `te format -p`, `te deps`, `te macro run --on`.
+- **`<path-filter>`**: identifica **cero o más** objetos y admite comodines. Los utilizan los comandos que operan sobre un conjunto: `te list`, `te bpa run --path` y otros comandos de inspección.
 
 Ambas formas de ruta comparten las mismas reglas de sintaxis; solo se diferencian en dos puntos:
 
@@ -101,39 +101,59 @@ Pon un segmento entre comillas para forzar la coincidencia literal del nombre cu
 
 ### Comodines en rutas de filtro
 
-Las rutas de filtro añaden un único carácter comodín - `*` - que coincide con cualquier secuencia de caracteres dentro de un solo segmento (codicioso, de un solo segmento). Los comodines permiten que `te ls` y comandos similares acoten los resultados.
+Las rutas de filtro añaden un único carácter comodín - `*` - que coincide con cualquier secuencia de caracteres dentro de un solo segmento (codicioso, de un solo segmento). Los comodines son la forma en que `te list` y comandos similares acotan los resultados.
 
 ```bash
-te ls 'Sa*'                          # Tables whose name starts with Sa
-te ls 'Sales/*Amount'                # Children of Sales whose name ends with Amount
-te ls '*/Amount'                     # An Amount column/measure across every table
-te ls 'Roles/Re*/Members'            # Members of every role matching Re*
+te list 'Sa*'                          # Tables whose name starts with Sa
+te list 'Sales/*Amount'                # Children of Sales whose name ends with Amount
+te list '*/Amount'                     # An Amount column/measure across every table
+te list 'Roles/Re*/Members'            # Members of every role matching Re*
 ```
 
-Una ruta de filtro con **N segmentos** produce resultados con **N niveles de profundidad**; los comodines nunca amplían automáticamente un nivel más allá de lo que hayas escrito. El atajo de un solo segmento `te ls Sales` es la excepción: un nombre de tabla sin calificar y sin comodines se expande a los elementos secundarios directos de la tabla para ajustarse a la intención de "muéstrame qué hay en Sales". En cambio, `te ls Sa*` devuelve solo las tablas coincidentes, sin expansión.
+Una ruta de filtro con **N segmentos** produce resultados con **N niveles de profundidad**; los comodines nunca amplían automáticamente un nivel más allá de lo que hayas escrito. El atajo de un solo segmento `te list Sales` es la excepción: un nombre de tabla sin calificar y sin comodines se expande a los elementos secundarios directos de la tabla para reflejar la intención de "muéstrame qué hay en Sales". En cambio, `te list Sa*` devuelve solo las tablas coincidentes, sin expansión.
 
 El sufijo entre corchetes de DAX se rechaza en las rutas de filtro; pon entre comillas los nombres que contengan `[` y `]` si necesitas que coincidan literalmente.
 
 ### Errores y sugerencias
 
-Los segmentos mal escritos generan un error contextual con una sugerencia de "quizás quisiste decir" cuando la CLI puede deducir lo que querías decir. Las rutas a las que les falta el elemento padre fallan antes de la comprobación del elemento hoja, así que los mensajes señalan el segmento que realmente está mal. Los contenedores vacíos (por ejemplo, `te ls Hierarchies` en un modelo sin jerarquías) muestran un simple mensaje de "no hay nada aquí" en lugar de un error.
+Los segmentos mal escritos generan un error contextual con una sugerencia de "quizás quisiste decir" cuando la CLI puede deducir lo que querías decir. Las rutas a las que les falta el elemento padre fallan antes de la comprobación del elemento hoja, así que los mensajes señalan el segmento que realmente está mal. Los contenedores vacíos (por ejemplo, `te list Hierarchies` en un modelo sin jerarquías) devuelven una sencilla indicación de "no hay nada aquí" en lugar de un error.
+
+## Alias de comandos
+
+La mayoría de los verbos en formato largo también aceptan un alias corto. Cada fila muestra el comando canónico y el comando equivalente en formato corto que admite como alias.
+
+| Canónico                        | Forma(s) con alias |
+| ------------------------------- | ------------------------------------- |
+| `te list`                       | `te ls`                               |
+| `te remove`                     | `te rm`                               |
+| `te move`                       | `te mv`, `te rename`                  |
+| `te bpa rules list`             | `te bpa rules ls`                     |
+| `te bpa rules remove`           | `te bpa rules rm`                     |
+| `te config list`                | `te config ls`                        |
+| `te macro list`                 | `te macro ls`                         |
+| `te macro remove`               | `te macro rm`                         |
+| `te incremental-refresh remove` | `te incremental-refresh rm`           |
+| `te profile list`               | `te profile ls`                       |
+| `te profile remove`             | `te profile rm`                       |
+| `te session list`               | `te session ls`                       |
+| `te test list`                  | `te test ls`                          |
 
 ## Opciones globales
 
 Estas opciones están disponibles en todos los comandos y se pueden usar antes o después del nombre del subcomando.
 
-| Opción                     | Descripción                                                                                                                                                                                                                                                                                                                                                                                                    |
-| -------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `-m, --model <path>`       | Ruta al modelo semántico (carpeta TMDL, archivo `.bim` o carpeta de TE).                                                                                                                                                                                                                                                                                                    |
-| `-s, --server <endpoint>`  | Nombre del Workspace o punto de conexión (p. ej., `MyWorkspace`, `powerbi://...`, `asazure://...`, `localhost`).                                                                                                                                                                                                                            |
-| `-d, --database <name>`    | Nombre del modelo semántico en el Workspace.                                                                                                                                                                                                                                                                                                                                                   |
-| `--local`                  | Conecta a una instancia de Power BI Desktop en ejecución local (solo Windows).                                                                                                                                                                                                                                                                                              |
-| `--auth <method>`          | Método de autenticación: `auto`, `interactive`, `spn`, `env`, `managed-identity` (predeterminado: `auto`).                                                                                                                                                                                                                                  |
-| `--output-format <format>` | Formato de Stdout: `text` (predeterminado), `json`, `csv`, `tmsl` (alias `bim`), `tmdl`. `csv` se respeta en los comandos que emiten datos tabulares; `tmsl`/`tmdl` solo se respeta en `te get` y `te ls` para la serialización de objetos completos. Los comandos rechazan los formatos que no admiten. |
-| `--error-format <format>`  | Formato de stderr para errores, advertencias y sugerencias: `text` (predeterminado) o `json`. Para cualquier otro valor, se usa `text`. Es independiente de `--output-format`, así que puedes combinar stdout en JSON con errores en texto sin formato (o viceversa).                                    |
-| `--recent [N]`             | Usa un modelo que hayas usado recientemente. Sin valor = selector interactivo; `N` = el N-ésimo más reciente (1 = el último usado).                                                                                                                                                                                                                         |
-| `--non-interactive`        | Desactiva todas las indicaciones interactivas. Finaliza con un error accionable si falta algún dato obligatorio.                                                                                                                                                                                                                                                               |
-| `--debug`                  | Habilita el registro de depuración en stderr (cadenas de conexión, flujo de autenticación, tiempos).                                                                                                                                                                                                                                                                        |
+| Opción                     | Descripción                                                                                                                                                                                                                                                                                                                                                                                                       |
+| -------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `-m, --model <path>`       | Ruta al modelo semántico (carpeta TMDL, archivo `.bim`, carpeta `Database.json` o carpeta `.SemanticModel`).                                                                                                                                                                                                                                                                   |
+| `-s, --server <endpoint>`  | Nombre del Workspace o punto de conexión (p. ej., `MyWorkspace`, `powerbi://...`, `asazure://...`, `localhost`).                                                                                                                                                                                                                               |
+| `-d, --database <name>`    | Nombre del modelo semántico en el Workspace.                                                                                                                                                                                                                                                                                                                                                      |
+| `--local`                  | Conecta a una instancia de Power BI Desktop en ejecución local (solo Windows).                                                                                                                                                                                                                                                                                                 |
+| `--auth <method>`          | Método de autenticación: `auto`, `interactive`, `spn`, `env`, `managed-identity` (predeterminado: `auto`).                                                                                                                                                                                                                                     |
+| `--output-format <format>` | Formato de Stdout: `text` (predeterminado), `json`, `csv`, `tmsl` (alias `bim`), `tmdl`. `csv` se respeta en los comandos que emiten datos tabulares; `tmsl`/`tmdl` solo se respetan en `te get` y `te list` para la serialización de objetos completos. Los comandos rechazan los formatos que no admiten. |
+| `--error-format <format>`  | Formato de stderr para errores, advertencias y sugerencias: `text` (predeterminado) o `json`. Para cualquier otro valor, se usa `text`. Es independiente de `--output-format`, así que puedes combinar stdout en JSON con errores en texto sin formato (o viceversa).                                       |
+| `--recent [N]`             | Usa un modelo que hayas usado recientemente. Sin valor = selector interactivo; `N` = el N-ésimo más reciente (1 = el último usado).                                                                                                                                                                                                                            |
+| `--non-interactive`        | Desactiva todas las indicaciones interactivas. Finaliza con un error accionable si falta algún dato obligatorio.                                                                                                                                                                                                                                                                  |
+| `--debug`                  | Habilita el registro de depuración en stderr (cadenas de conexión, flujo de autenticación, tiempos).                                                                                                                                                                                                                                                                           |
 
 `te --version` muestra la versión de la CLI y sale.
 
@@ -141,6 +161,12 @@ En los comandos que leen un modelo, el orden de resolución es:
 
 el argumento posicional `<model>` → la opción global `--model` → `--server`/`--database` (remoto) → conexión activa de `te connect` → `--recent`.
 
+> [!NOTE]
+> **Las opciones mal escritas se rechazan de entrada.** Si pasas un `--flag` que no se reconoce en el comando que invocaste, la CLI finaliza con un error claro en lugar de interpretarlo silenciosamente como un argumento posicional. Esto detecta errores tipográficos como, por ejemplo, que `--force ` se convierta accidentalmente en `--forec` en scripts de CI.
+
+> [!NOTE]
+> **Nombres de servidor con puntos.** `-s`/`--server` trata un nombre con puntos (por ejemplo, `Sales.2026`) como el nombre de host de un servidor de Analysis Services, no como un Workspace de Power BI. Se muestra una advertencia cuando la CLI tiene que hacer esta interpretación, con una sugerencia para agregar `.Workspace` (por ejemplo, `Sales.2026.Workspace`) o usar una URL `powerbi://` completa si en realidad te referías al Workspace de Power BI. Se aplica a `te connect`, `te deploy`, `te refresh`, `te query`, `te vertipaq` y `te test run`.
+
 ## E/S del modelo
 
 ### load
@@ -159,8 +185,8 @@ Guarda un modelo en disco. Úsalo para escribir en archivos locales un modelo de
 
 `te save` acepta:
 
-- `-o, --output-path <path>` - archivo o carpeta de destino. **Opcional** - si se omite, `te save` vuelve a escribir en la ubicación de origen y conserva el formato original.
-- `--serialization <fmt>` - `tmdl`, `bim`, `te-folder`, `pbip`, `database.json`. De forma predeterminada, se deduce a partir del modelo cargado (origen BIM → BIM, TMDL `SemanticModel/` → TMDL en `definition/`).
+- `-o, --output-path <path>` - archivo o carpeta de destino. **Opcional** - si se omite, `te save` vuelve a escribir en la ubicación de origen y conserva el formato original. La extensión del archivo también sirve para inferir el formato: `.bim` escribe un BIM en un solo archivo, `.json` escribe una carpeta `Database.json` y una ruta sin extensión escribe una carpeta TMDL.
+- `--serialization <fmt>` - `tmdl`, `bim` (alias `tmsl`), `Database.json`, `pbip`. Si se omite, el formato se infiere a partir de la extensión de la ruta `-o` (o del modelo cargado cuando `-o` se omite por completo).
 - `--force` - omite la validación y sobrescribe la salida existente. Algunos rechazos (contenedores ambiguos, raíces de proyecto con varios `SemanticModel`) siguen ocurriendo incluso con `--force`.
 - `--skip-bpa` - omite por completo el control de BPA.
 - `--fix-bpa` - corrige automáticamente las infracciones de BPA cuando las reglas definen una expresión de corrección.
@@ -180,10 +206,12 @@ te save -o ./out -s my-workspace -d my-model --skip-validation   # Fast download
 
 ### open
 
-Abre un modelo en la aplicación de escritorio de Tabular Editor 3. **Solo para Windows** (requiere que TE3 esté instalado).
+Abre un modelo en la aplicación de escritorio de Tabular Editor 3. **Solo para Windows** (requiere que TE3 esté instalado). Sin argumentos, inicia TE3 con un Workspace en blanco.
 
 ```bash
-te open ./my-model
+te open                  # Launch TE3 with a blank workspace
+te open ./my-model       # Open a TMDL folder in TE3
+te open ./model.bim      # Open a BIM file in TE3
 ```
 
 ### init
@@ -196,7 +224,7 @@ Crea un nuevo modelo semántico vacío en la ruta especificada. De forma predete
 - `--compatibility-mode <mode>` - `PowerBI` (predeterminado) o `AnalysisServices`.
 - `--compatibility-level <N>` (alias `--compat`) - nivel de compatibilidad. De forma predeterminada, usa `1702` cuando el modo es `PowerBI`; `1500` en caso contrario. Consulta @update-compatibility-level.
 - `--name <name>` - nombre del modelo o de la base de datos (predeterminado: el nombre del directorio).
-- `--serialization <fmt>` - `tmdl` (predeterminado), `bim`, `te-folder`, `pbip`.
+- `--serialization <fmt>` - `tmdl` (predeterminado), `bim` (alias `tmsl`), `Database.json`, `pbip`.
 - `--force` - reemplaza cualquier archivo o directorio existente en la ruta de destino.
 
 ```bash
@@ -214,14 +242,18 @@ Establece una propiedad en un objeto del modelo. Acepta un argumento `<path>`.
 
 `te set` acepta:
 
-- `-q <property>` - nombre de la propiedad (por ejemplo, `expression`, `formatString`, `description`, `isHidden`).
-- `-i <value>` - valor (usa `-` para leer desde stdin).
+- `-q <property>` - nombre de la propiedad (por ejemplo, `expression`, `formatString`, `description`, `isHidden`). **Se puede repetir** — empareja cada `-q` con el `-i` siguiente para establecer varias propiedades en un solo comando.
+- `-i <value>` - valor (usa `-` para leer desde stdin). Un `-i` por cada `-q`.
+- `-t, --type <kind>` - desambiguación cuando la misma ruta podría referirse a varios tipos de objeto (`medida`, `Column`, `CalculatedColumn`, `Hierarchy`, `Calendar`, `partición`, `CalculationItem`).
 - `--save` / `--save-to <path>` - guarda los cambios.
+- `--serialization <fmt>` - sobrescribe la serialización al guardar (`tmdl`, `bim` (alias `tmsl`), `database.json`).
+- `--force` - guarda incluso si la modificación introduce errores de validación de DAX.
 
 ```bash
 te set Sales/Amount -q expression -i "SUM(Sales[Amt])" --save
 te set "'Net Sales'[Sales Amount]" -q formatString -i "#,0" --save   # DAX form with spaced names
 te set Sales -q isHidden -i true --save
+te set Sales/Amount -q formatString -i "#,0" -q description -i "Net sales" --save   # Multi-property
 ```
 
 ### add
@@ -231,7 +263,15 @@ Agrega un objeto al modelo. Especifica un `<path>` para el nuevo objeto (el elem
 `te add` acepta:
 
 - `-t, --type <type>`: tipo de objeto. Valores comunes: `Table`, `Measure`, `Column`, `CalculatedColumn`, `Hierarchy`, `Role`, `Perspective`, `Culture`, `CalculationGroup`, `CalculationItem`. Se admite el autocompletado con la tecla Tab; la lista completa se puede obtener ejecutando `te add --help`.
+- `-i <value>` - expresión o valor que se asignará al nuevo objeto (DAX para medidas/columnas calculadas, M para particiones, etc.). Combínalo con `-q` para establecer propiedades adicionales en el nuevo objeto en el mismo comando.
+- `-q <property>` - propiedad adicional que se establecerá en el nuevo objeto (se puede repetir; se combina con `-i`).
+- `--file <path>` - lee la expresión de `-i` desde un archivo en lugar de incluirla directamente en el comando.
+- `--mode <mode>` - modo de almacenamiento para tablas nuevas: `import` (predeterminado), `directQuery`, `dual`, `directLake`.
 - `--if-not-exists` - sale con código `0` sin error si el objeto ya existe. Úsalo en canalizaciones de CI/CD idempotentes.
+- `--save` / `--save-to <path>` - guarda los cambios.
+- `--serialization <fmt>` - sobrescribe la serialización al guardar (`tmdl`, `bim` (alias `tmsl`), `database.json`).
+- `--source-type <kind>` - tipo de origen inicial de la partición en una tabla nueva: `m`, `query` o `calculated`. Anula la detección heurística. `calculated` solo es válido con `-t CalculatedTable`.
+- `--force` - guarda incluso si la modificación introduce errores de validación de DAX.
 
 ```bash
 te add Sales/Revenue -t Measure -i "SUM(Sales[Amount])" --save
@@ -244,32 +284,42 @@ te add Roles/Reader -t Role --save                                         # New
 
 En las tablas vinculadas a datos, `te add` también admite la detección del esquema desde orígenes SQL, Lakehouse o Warehouse. Consulta `te add --help` para ver `--source`, `--endpoint`, `--source-table`, `--columns`, etc.
 
-### rm
+### remove
 
-Elimina un objeto. De forma predeterminada, comprueba las dependencias para evitar romper referencias existentes.
+Elimina un objeto. De forma predeterminada, comprueba las dependencias para evitar romper referencias existentes. (Alias: `rm`.)
 
-`te rm` acepta:
+`te remove` acepta:
 
-- `<path>` — argumento posicional: el objeto que se va a eliminar.
-- `--force` — omite la comprobación de objetos dependientes.
-- `--if-exists` — sale con código `0` sin error si el objeto no existe. Úsalo en canalizaciones de CI/CD idempotentes.
-- `--dry-run` — muestra una vista previa de la eliminación sin aplicarla.
-- `--save` — guarda el cambio en el modelo cargado.
+- `<path>` - argumento posicional: el objeto que se va a eliminar.
+- `-t, --type <kind>` - desambigua cuando la ruta coincide con varios elementos secundarios de una tabla (p. ej., una columna y una jerarquía con el mismo nombre).
+- `--force` - omite la comprobación de objetos dependientes.
+- `--if-exists` - sale con código `0` sin error si el objeto no existe. Úsalo en canalizaciones de CI/CD idempotentes.
+- `--dry-run` - muestra una vista previa de la eliminación sin aplicarla.
+- `--save` / `--save-to <path>` - guarda el cambio.
+- `--serialization <fmt>` - sobrescribe la serialización al guardar (`tmdl`, `bim` (alias `tmsl`), `database.json`).
 
 ```bash
-te rm Sales/Revenue --save
-te rm "'Sales'[Revenue]" --save              # DAX form
-te rm Sales/Revenue --dry-run                # Preview only
-te rm Sales/OldMeasure --if-exists --save    # Idempotent
+te remove Sales/Revenue --save
+te remove "'Sales'[Revenue]" --save              # DAX form
+te remove Sales/Revenue --dry-run                # Preview only
+te remove Sales/OldMeasure --if-exists --save    # Idempotent
 ```
 
-### mv
+### move
 
-Mueve o renombra un objeto del modelo. Tanto el origen como el destino son argumentos `<path>`.
+Mueve o renombra un objeto del modelo. Tanto el origen como el destino son argumentos `<path>`. (Alias: `mv` y `rename`.)
+
+`te move` acepta:
+
+- `-t, --type <kind>` - desambigua cuando la ruta de origen coincide con varios tipos de objeto (p. ej., una columna y una jerarquía con el mismo nombre).
+- `--save` / `--save-to <path>` - guarda el cambio.
+- `--serialization <fmt>` - sobrescribe la serialización al guardar (`tmdl`, `bim` (alias `tmsl`), `database.json`).
+- `--force` - guarda incluso si la mutación introduce errores de validación de DAX.
 
 ```bash
-te mv Sales/Revenue Finance/Revenue --save    # Move measure to another table
-te mv Sales/Revenue Sales/TotalRevenue --save # Rename measure
+te move Sales/Revenue Finance/Revenue --save                # Move measure to another table
+te move Sales/Revenue Sales/TotalRevenue --save             # Rename measure
+te move Sales/Date Sales/CalendarDate -t Hierarchy --save   # Disambiguate hierarchy from column
 ```
 
 ### replace
@@ -284,7 +334,7 @@ Busca y reemplaza texto en los objetos del modelo. Simulación de forma predeter
 - `--dry-run` - previsualiza los cambios sin aplicarlos. Comportamiento predeterminado.
 - `--save` - guarda la modificación en la ubicación de origen. Incompatible con `--revert` y `--stage`.
 - `--save-to <path>` - guarda en una ruta diferente (implica `--save`).
-- `--serialization <fmt>` - serialización del modelo: `tmdl`, `bim`, `te-folder`.
+- `--serialization <fmt>` - serialización del modelo: `tmdl`, `bim` (alias `tmsl`), `database.json`.
 - `--force` - guarda incluso si la sustitución introduce errores de validación de DAX.
 
 `--in expressions` recorre todas las propiedades que contienen expresiones:
@@ -305,31 +355,31 @@ te replace "SUM" "SUMX" --regex --in expressions --save
 
 ## Inspección
 
-### ls
+### list
 
-Enumera objetos con una navegación similar a la del sistema de archivos. Acepta un argumento `<path-filter>` que admite comodines. Tanto los contenedores de nivel de modelo (`Tables`, `Measures`, `Columns`, `Hierarchies`, `Relationships`, `Roles`, `Perspectives`, `Cultures`) como los contenedores con ámbito de tabla (`Sales/Measures`, `Sales/Columns`, …) se admiten.
+Enumera objetos con una navegación similar a la del sistema de archivos. Acepta un argumento `<path-filter>` que admite comodines. Se admiten tanto contenedores de nivel de modelo como contenedores con ámbito de tabla; consulta la [tabla de palabras clave de contenedores](#containers-and-keywords) anterior para ver la lista completa. (Alias: `ls`.)
 
-`te ls` acepta:
+`te list` acepta:
 
 - `--type <kind>` - limita a un tipo de objeto (`table`, `measure`, `column`, `hierarchy`, `partition`, `relationship`, `role`, `perspective`, `culture`). Sin `<path-filter>`, esto equivale a escribir la palabra clave del contenedor correspondiente.
 - `--paths-only` - emite una ruta de objeto por línea, ideal para pasarlo a `xargs`, `te get` o `te set`.
 - `--no-multiline` - contrae las celdas multilínea (normalmente expresiones DAX o M) a una sola línea y las trunca para que las filas sigan siendo fáciles de recorrer en tablas anchas. Solo afecta a la salida de texto; la salida JSON/CSV/TMSL no se ve afectada.
-- `--output-format tmsl` (alias `bim`) - genera los objetos coincidentes como un script TMSL/BIM. Útil para `te ls Tables --output-format bim > tables.json`. `--output-format tmdl` no es compatible con `ls` (TMDL solo admite un único objeto; usa `te get`).
+- `--output-format tmsl` (alias `bim`) - genera los objetos coincidentes como un script TMSL/BIM. Útil para `te list Tables --output-format bim > tables.json`. `--output-format tmdl` no es compatible con `ls` (TMDL solo admite un único objeto; usa `te get`).
 
 ```bash
-te ls                                     # All tables in the model
-te ls Sales                               # All children of Sales (columns + measures + hierarchies + partitions)
-te ls Sales/Measures                      # Just Sales's measures
-te ls 'Sales/*Amount'                     # Children of Sales whose name ends with Amount
-te ls 'Sa*'                               # Tables whose name starts with Sa (no auto-expansion)
-te ls '*/Amount'                          # An Amount column/measure across every table
-te ls 'Roles/Re*/Members'                 # Members of every role matching Re*
-te ls Sales/Geography/Levels              # All levels of the Geography hierarchy
-te ls "'Net Sales'/'Sales Amount'"        # Quote names containing spaces
-te ls Measures --paths-only               # One Table/Measure per line for piping
-te ls --type measure                      # Same as `te ls Measures`
-te ls Measures --no-multiline             # Wide table with column dividers, single-line DAX
-te ls Tables --output-format bim > tables.json   # All tables emitted as TMSL/BIM
+te list                                     # All tables in the model
+te list Sales                               # All children of Sales (columns + measures + hierarchies + partitions)
+te list Sales/Measures                      # Just Sales's measures
+te list 'Sales/*Amount'                     # Children of Sales whose name ends with Amount
+te list 'Sa*'                               # Tables whose name starts with Sa (no auto-expansion)
+te list '*/Amount'                          # An Amount column/measure across every table
+te list 'Roles/Re*/Members'                 # Members of every role matching Re*
+te list Sales/Geography/Levels              # All levels of the Geography hierarchy
+te list "'Net Sales'/'Sales Amount'"        # Quote names containing spaces
+te list Measures --paths-only               # One Table/Measure per line for piping
+te list --type measure                      # Same as `te list Measures`
+te list Measures --no-multiline             # Wide table with column dividers, single-line DAX
+te list Tables --output-format bim > tables.json   # All tables emitted as TMSL/BIM
 ```
 
 ### get
@@ -343,7 +393,7 @@ Obtiene las propiedades de un objeto del modelo. Acepta un `<path>`.
 - `--output-format tmsl` (alias `bim`) - genera el objeto resuelto como JSON TMSL/BIM.
 - `--output-format tmdl` - genera el objeto resuelto como TMDL (solo objetos con nombre).
 
-`te get` y `te ls` comparten un único catálogo de descriptores, por lo que todas las propiedades aparecen igual en todos los formatos: la tabla de texto y las salidas JSON y CSV muestran el mismo conjunto, y al agregar una propiedad nueva al modelo queda expuesta en todas partes.
+`te get` y `te list` comparten un único catálogo de descriptores, de modo que todas las propiedades se muestran igual en todos los formatos: la tabla de texto, JSON y CSV ven el mismo conjunto, y al agregar una propiedad nueva al modelo, esta queda expuesta en todos ellos.
 
 ```bash
 te get Sales/Amount -q expression                # Print DAX
@@ -381,6 +431,12 @@ Compara dos modelos para detectar diferencias estructurales. Devuelve los siguie
 ```bash
 te diff ./model-v1 ./model-v2
 te diff old.bim new.bim
+
+# Branch on exit code (POSIX sh):
+te diff ./a ./b; case $? in 0) echo same;; 1) echo different;; *) echo error;; esac
+
+# Branch on exit code (PowerShell):
+te diff ./a ./b; switch ($LASTEXITCODE) { 0 { 'same' } 1 { 'different' } default { 'error' } }
 ```
 
 ### deps
@@ -427,6 +483,9 @@ te validate --ci github --trx results.trx
 te validate --errors-only                 # Hide warnings and anti-pattern hints
 ```
 
+> [!NOTE]
+> `te validate` no admite `--output-format csv`: CSV se rechaza desde el principio con un error claro, en lugar de producir un resultado parcial. Usa `text` o `json` para la salida de validación.
+
 ### bpa run
 
 Ejecuta reglas de Best Practice Analyzer contra un modelo.
@@ -445,8 +504,8 @@ Ejecuta reglas de Best Practice Analyzer contra un modelo.
 - `--fix` - aplicar expresiones de corrección para corregir automáticamente las infracciones cuando sea posible.
 - `--save` - volver a guardar el modelo en el origen después de aplicar las correcciones.
 - `--save-to <path>` - guardar el modelo en una ruta diferente después de aplicar las correcciones.
-- `--serialization <fmt>` - serialización del modelo: `tmdl`, `bim`, `te-folder`.
-- `--fail-on <severity>` - umbral de fallo: `error` (predeterminado) o `warning`. Sale con el código `1` cuando las infracciones alcanzan el umbral.
+- `--serialization <fmt>` - serialización del modelo: `tmdl`, `bim` (alias `tmsl`), `database.json`.
+- `--fail-on <severity>` - umbral de fallo: `error` (predeterminado) o `warning`. Sale con el código `1` cuando las infracciones alcanzan el umbral. Los errores al cargar o evaluar reglas (expresiones no válidas, archivos de reglas ilegibles) también provocan un código de salida distinto de cero, independientemente de `--fail-on`.
 - `--ci <fmt>` - emitir comandos de registro de CI a stderr: `vsts` (Azure DevOps), `github` (GitHub Actions).
 - `--trx <path>` - escribir los resultados como un archivo `.trx` de VSTEST en la PATH especificada.
 - `--no-multiline` - contraer el contenido de varias líneas de las celdas de la tabla de infracciones en una sola línea. Solo para la salida de texto.
@@ -485,17 +544,17 @@ Administra colecciones de reglas de BPA: enumera, inspecciona, inicializa y acti
 
 Subcomandos:
 
-| Subcomando                      | Propósito                                                                                   |
-| ------------------------------- | ------------------------------------------------------------------------------------------- |
-| `add <id> [model]`              | Agrega una nueva regla de BPA.                                              |
-| [`disable`](#bpa-rules-disable) | Desactiva una regla de BPA integrada para el usuario actual.                |
-| [`enable`](#bpa-rules-enable)   | Vuelve a activar una regla de BPA integrada que se había desactivado antes. |
-| `ignore <rule-id> [model]`      | Agrega una regla a la lista de ignorados del modelo.                        |
-| [`init`](#bpa-rules-init)       | Crea un archivo vacío de reglas de BPA en la ruta PATH resuelta.            |
-| [`list`](#bpa-rules-list)       | Enumera las reglas de BPA de todos los orígenes con su estado.              |
-| `rm <rule-id> [model]`          | Elimina una regla de BPA.                                                   |
-| `set <rule-id> [model]`         | Actualiza las propiedades de una regla del BPA.                             |
-| `unignore <rule-id> [model]`    | Elimina una regla de la lista de reglas ignoradas del modelo.               |
+| Subcomando                                                 | Propósito                                                                                   |
+| ---------------------------------------------------------- | ------------------------------------------------------------------------------------------- |
+| `add <id> [model]`                                         | Agrega una nueva regla de BPA.                                              |
+| [`disable`](#bpa-rules-disable)                            | Desactiva una regla de BPA integrada para el usuario actual.                |
+| [`enable`](#bpa-rules-enable)                              | Vuelve a activar una regla de BPA integrada que se había desactivado antes. |
+| `ignore <rule-id> [model]`                                 | Agrega una regla a la lista de ignorados del modelo.                        |
+| [`init`](#bpa-rules-init)                                  | Crea un archivo vacío de reglas de BPA en la ruta PATH resuelta.            |
+| [`list`](#bpa-rules-list) (alias `ls`)  | Enumera las reglas de BPA de todos los orígenes con su estado.              |
+| `remove <rule-id> [model]` (alias `rm`) | Elimina una regla de BPA.                                                   |
+| `set <rule-id> [model]`                                    | Actualiza las propiedades de una regla del BPA.                             |
+| `unignore <rule-id> [model]`                               | Elimina una regla de la lista de reglas ignoradas del modelo.               |
 
 Todos los subcomandos de `te bpa rules` aceptan:
 
@@ -503,7 +562,7 @@ Todos los subcomandos de `te bpa rules` aceptan:
 - `--model-rules`: opera sobre las reglas incrustadas en la anotación del modelo en lugar de un archivo.
 
 > [!IMPORTANT]
-> `te bpa rules set` y `te bpa rules rm` se niegan a modificar los ID de reglas integradas. Si intentas hacerlo, el comando finaliza con el código `1` y te indica que uses `te bpa rules disable`. Para personalizar el comportamiento de una regla integrada, deshabilita la regla integrada y agrega una copia personalizada con un identificador distinto:
+> `te bpa rules set` y `te bpa rules remove` se niegan a modificar los ID de reglas integradas. Si intentas hacerlo, el comando finaliza con el código `1` y te indica que uses `te bpa rules disable`. Para personalizar el comportamiento de una regla integrada, deshabilita la regla integrada y agrega una copia personalizada con un identificador distinto:
 >
 > ```bash
 > te bpa rules disable TE3_BUILT_IN_DATE_TABLE_EXISTS
@@ -512,7 +571,7 @@ Todos los subcomandos de `te bpa rules` aceptan:
 
 #### bpa rules list
 
-Muestra las reglas de todos los orígenes (integradas, de usuario y del modelo).
+Muestra las reglas de todos los orígenes (integradas, de usuario y del modelo). (Alias: `ls`.)
 
 `te bpa rules list` acepta:
 
@@ -532,7 +591,7 @@ Las reglas integradas deshabilitadas se marcan con un marcador `[disabled]` junt
 
 #### bpa rules init
 
-Crea un archivo de reglas del BPA vacío (`[]`) en el PATH configurado. Úsalo una vez antes de ejecutar `te bpa rules set` / `te bpa rules rm` sobre una ruta que todavía no existe.
+Crea un archivo de reglas del BPA vacío (`[]`) en el PATH configurado. Úsalo una vez antes de ejecutar `te bpa rules set` / `te bpa rules remove` sobre una ruta que todavía no existe.
 
 `te bpa rules init` acepta:
 
@@ -547,6 +606,39 @@ te bpa rules init --rules-file ./MyRules.json
 te bpa rules init --force
 ```
 
+#### bpa rules add / set / remove / ignore / unignore
+
+Modifica el archivo de reglas (`add`, `set`, `remove` (alias `rm`)) o la lista de exclusión integrada en el modelo (`ignore`, `unignore`). Los tres subcomandos de modificación actúan sobre `--rules-file <path>` o `--model-rules` y se niegan a modificar los ID de reglas integradas.
+
+- `te bpa rules add <id>` - crea una regla nueva. Especifica cada propiedad como una opción con nombre:
+  - `--name <text>` - nombre legible de la regla (obligatorio).
+  - `--scope <list>` - tipos de objeto separados por comas a los que se aplica la regla: `medida`, `Column`, `Table`, `Hierarchy`, `partición`, `Relationship`, `Role`, `Perspective`, `Culture`, etc. (obligatorio).
+  - `--expression <text>` - predicado de Dynamic LINQ. Devuelve `true` para los objetos que infringen la regla (obligatorio).
+  - `--category <text>` - etiqueta de agrupación (por ejemplo, `Performance`, `Naming`, `DAX Expressions`).
+  - `--severity <1|2|3>` - `1` (información), `2` (advertencia, valor predeterminado), `3` (error).
+  - `--description <text>` - descripción orientada al usuario que se muestra cuando se activa la regla.
+  - `--fix-expression <text>` - expresión de Dynamic LINQ que utiliza `te bpa run --fix` para corregir automáticamente.
+- `te bpa rules set <id>` - actualiza las propiedades de una regla existente. Utiliza pares `-q <property> -i <value>` (repetibles). Nombres de propiedades: `name`, `expression`, `scope`, `category`, `severity`, `description`, `fixExpression`.
+- `te bpa rules remove <id>` - elimina una regla.
+- `te bpa rules ignore <id>` - añade un ID de regla a la anotación `BestPracticeAnalyzer_IgnoreRules` del modelo.
+- `te bpa rules unignore <id>` - elimina un ID de regla de la lista de reglas ignoradas del modelo.
+
+```bash
+# Add a rule: measures that are not hidden and have no description
+te bpa rules add MEASURE_NEEDS_DESCRIPTION \
+    --name "Measures should have a description" \
+    --scope Measure \
+    --expression "not IsHidden and string.IsNullOrEmpty(Description)" \
+    --severity 2 \
+    --category Metadata
+
+# Update severity on an existing rule
+te bpa rules set MEASURE_NEEDS_DESCRIPTION -q severity -i 3
+
+# Remove the rule
+te bpa rules remove MEASURE_NEEDS_DESCRIPTION
+```
+
 #### bpa rules disable
 
 Deshabilita una regla BPA integrada específica. El identificador de la regla se agrega a `bpa.disabledBuiltInRuleIds` en la configuración de tu CLI. Las ejecuciones posteriores del gate (deploy, save, mutation) y `te bpa run` omiten la regla deshabilitada.
@@ -571,6 +663,7 @@ Analiza las estadísticas de almacenamiento de VertiPaq.
 
 `te vertipaq` acepta:
 
+- `<path>` - argumento posicional opcional: un nombre de tabla para filtrar el análisis y limitarlo a una sola tabla.
 - `--columns`, `--relationships`, `--partitions`, `--all`.
 - `--detail` - muestra columnas expandidas (desglose del tamaño de datos/diccionario/jerarquía, codificación, segmentos).
 - `--fields <list>` - campos separados por comas para mostrar (p. ej., `--fields name,card,size,%tbl,%db,bar`). Los campos disponibles varían según la vista.
@@ -578,10 +671,12 @@ Analiza las estadísticas de almacenamiento de VertiPaq.
 - `--import <file.vpax>` - carga un archivo `.vpax` exportado previamente y lo analiza sin conexión.
 - `--obfuscate` - ofusca nombres y expresiones en el VPAX exportado.
 - `--top <N>`, `--stats`, `--annotate`, `--save`.
+- `--auth <method>` - sustituye el método de autenticación al conectarse a un modelo remoto.
 
 ```bash
-te vertipaq                    # Columns by size (default)
-te vertipaq --all              # Tables, columns, relationships, partitions
+te vertipaq                      # Columns by size (default)
+te vertipaq Sales                # Stats limited to the Sales table
+te vertipaq --all                # Tables, columns, relationships, partitions
 te vertipaq --export stats.vpax
 te vertipaq --import stats.vpax  # Analyze offline
 ```
@@ -616,7 +711,8 @@ Ejecuta una consulta DAX contra un modelo implementado.
 
 `te query` admite:
 
-- `-q, --query <dax>` - consulta en línea.
+- `<dax>` - argumento posicional: la consulta DAX que se va a ejecutar. Equivale a pasar `-q`. Utiliza la forma que se lea mejor; el `-q` explícito tiene prioridad si se proporcionan ambas.
+- `-q, --query <dax>` - consulta en línea (variante con opción con nombre del argumento posicional anterior).
 - `--file <file.dax>` - consulta desde un archivo.
 - `--limit <N>` - valor predeterminado: 100.
 - `-o, --output-file <path>` - escribe los resultados en un archivo (`.csv`, `.tsv`, `.json`, `.dax`).
@@ -624,7 +720,8 @@ Ejecuta una consulta DAX contra un modelo implementado.
 - `--no-validate` - omite la validación semántica de DAX previa a la ejecución.
 
 ```bash
-te query -q "EVALUATE TOPN(5, 'Sales')" -s my-ws -d my-model
+te query "EVALUATE TOPN(5, 'Sales')" -s my-ws -d my-model           # Positional DAX
+te query -q "EVALUATE TOPN(5, 'Sales')" -s my-ws -d my-model        # Named-flag form
 te query --file query.dax --output-format json
 ```
 
@@ -679,15 +776,29 @@ Administra y ejecuta macros desde un archivo JSON de macros (normalmente `MacroA
 
 Subcomandos:
 
-| Subcomando                       | Propósito                                                             |
-| -------------------------------- | --------------------------------------------------------------------- |
-| `list`                           | Listar macros.                                        |
-| [`run <name-or-id>`](#macro-run) | Ejecutar una macro.                                   |
-| `add <name>`                     | Agregar una macro.                                    |
-| `set <name-or-id>`               | Actualizar las propiedades de la macro.               |
-| `rm <name-or-id>`                | Eliminar una macro.                                   |
-| `sort`                           | Ordenar y reasignar los identificadores.              |
-| [`init`](#macro-init)            | Crear un archivo de macros vacío en la ruta resuelta. |
+| Subcomando                                            | Propósito                                                             |
+| ----------------------------------------------------- | --------------------------------------------------------------------- |
+| `list` (alias `ls`)                | Listar macros.                                        |
+| [`run <name-or-id>`](#macro-run)                      | Ejecutar una macro.                                   |
+| `add <name>`                                          | Agregar una macro.                                    |
+| `set <name-or-id>`                                    | Actualizar las propiedades de la macro.               |
+| `remove <name-or-id>` (alias `rm`) | Eliminar una macro.                                   |
+| `sort`                                                | Ordenar y reasignar los identificadores.              |
+| [`init`](#macro-init)                                 | Crear un archivo de macros vacío en la ruta resuelta. |
+
+#### macro add / set / remove
+
+Modifica el archivo de macros (`add`, `set`, `remove` (alias `rm`)). Los tres operan sobre `--macros <path>` (o el archivo de macros resultante).
+
+- `te macro add <name>` - crea una nueva macro. Indica el cuerpo del script mediante `-e "<code>"` (en línea) o `-s <file.cs>` (archivo de script). Opcional: `--tooltip <text>`, `--contexts <list>` (donde se aplica la macro; por ejemplo, `Table,Medida`), `--enabled true|false`.
+- `te macro set <name-or-id>`: actualiza las propiedades de la macro. Usa pares `-q <property> -i <value>` (se pueden repetir). Nombres de las propiedades: `name`, `execute`, `enabled`, `tooltip`, `validContexts`.
+- `te macro remove <name-or-id>`: elimina una macro.
+
+```bash
+te macro add MyMacro -e "Info(Selected.Measure.Name);" --tooltip "Print measure name" --contexts Measure
+te macro set MyMacro -q tooltip -i "Updated tooltip"
+te macro remove MyMacro
+```
 
 #### macro init
 
@@ -742,7 +853,7 @@ Implementa un modelo semántico en Power BI, Fabric o Azure Analysis Services.
 - `--bpa-rules <PATH>` - se puede repetir; anula `bpa.rules` de la configuración de tu CLI solo para este despliegue. Las reglas integradas siguen aplicándose a menos que `bpa.builtInRules` sea `false`.
 - `--force` - omite la confirmación interactiva (necesario para CI).
 - `--ci <fmt>` - `vsts` o `github`.
-- `--profile <name>` - uso puntual de un perfil de @te-cli-auth guardado.
+- `-p, --profile <name>` - uso puntual de un perfil de @te-cli-auth guardado.
 
 ```bash
 te deploy ./model -s my-workspace -d my-model --force --ci github
@@ -753,18 +864,21 @@ te deploy ./model --profile staging --force
 > [!IMPORTANT]
 > `te deploy` ejecuta el Best Practice Analyzer como control previo antes de realizar el despliegue. En modo interactivo, se muestran un resumen y un mensaje de confirmación, con **`n` como opción segura predeterminada**. En CI, pasa `--force` para omitir la confirmación. Consulta @te-cli-config para la configuración del control de BPA.
 
+> [!NOTE]
+> Cuando se establece `--output-format json`, la carga JSON de `te deploy` siempre incluye los valores resueltos de `server` y `database`, incluso cuando se han resuelto a partir de la conexión activa o de un perfil, en lugar de pasarse explícitamente. Las canalizaciones pueden usar estos campos para confirmar el destino del despliegue sin volver a analizar la línea de comandos. `te deploy` y `te format` también devuelven un código de salida distinto de cero si fallan con `--output-format json`, igual que en modo texto: la carga JSON es el registro del error, no una señal de éxito.
+
 ### refresh
 
 Inicia una actualización de datos en un modelo implementado.
 
 `te refresh` admite:
 
-- `--type <type>` - `full`, `dataonly`, `automatic`, `calculate`, `clearvalues`, `defragment`, `add` (predeterminado: `automatic`).
+- `--type <type>` - `full`, `dataonly` (alias `data-only`, `data`), `automatic` (alias `auto`), `calculate` (alias `calc`), `clearvalues` (alias `clear`), `defragment` (alias `defrag`), `add` (predeterminado: `automatic`).
 - `--table <name>` - actualiza tabla(s) específicas; se puede repetir.
 - `--partition <Table.Partition>` - actualiza partición(es) específicas.
 - `--apply-refresh-policy` - aplica la política de actualización para determinar qué particiones se actualizan con la actualización incremental.
 - `--effective-date <yyyy-MM-dd>` - establece la fecha efectiva que usa la política de actualización.
-- `--max-parallelism <N>` - establece el número máximo de particiones que se pueden actualizar en paralelo.
+- `--max-parallelism <N>` - establece el número máximo de particiones que se pueden actualizar en paralelo. Encapsula la actualización en un comando TMSL `sequence`.
 - `--dry-run` - muestra el script TMSL sin ejecutarlo.
 - `--no-progress`, `--trace [path]`.
 
@@ -782,7 +896,7 @@ Gestiona las políticas de actualización para la actualización incremental de
 te incremental-refresh show <table>
 ```
 
-Los subcomandos adicionales (`set`, `rm`, `apply`) están documentados en `te incremental-refresh --help`.
+Los subcomandos adicionales (`set`, `remove` (alias `rm`), `apply`) están documentados en `te incremental-refresh --help`.
 
 ## Pruebas
 
@@ -804,6 +918,8 @@ te test run --tag revenue
 
 ### test init / spec / use / list / snapshot / compare
 
+`te test list` también acepta el alias `ls`.
+
 Los subcomandos adicionales permiten crear la estructura de las pruebas, imprimir el formato de la especificación de aserciones, cambiar la suite activa, listar las suites, capturar instantáneas y comparar modelos. Consulta `te test --help` para más detalles.
 
 ```bash
@@ -819,12 +935,14 @@ te test init --from-model --model ./my-model  # Generate stubs from your measure
 Establece (o muestra) la conexión activa para la sesión actual del terminal. Consulta @te-cli-auth.
 
 ```bash
-te connect                         # Show current active connection
-te connect my-workspace my-model   # Remote
-te connect ./model                 # Local
-te connect --local                 # Power BI Desktop (Windows)
-te connect --profile prod          # Activate a saved profile
-te connect --clear                 # Clear the active connection (and any workspace mirror)
+te connect                                # Show current active connection
+te connect my-workspace my-model          # Remote (positional)
+te connect -s my-workspace -d my-model    # Remote (named-flag form)
+te connect ./model                        # Local
+te connect --local                        # Power BI Desktop (Windows)
+te connect --local my-report              # Filter by report name (multiple PBI Desktop instances)
+te connect --profile prod                 # Activate a saved profile
+te connect --clear                        # Clear the active connection (and any workspace mirror)
 ```
 
 #### Modo del área de trabajo (`-w` / `--workspace`)
@@ -833,11 +951,11 @@ Empareja un origen principal con un destino secundario para que cada `--save` po
 
 - `te connect <ws> <model> -w ./src` - el origen principal es remoto; `./src` recibe una exportación inicial de TMDL y refleja cada guardado.
 - `te connect ./src -w <ws> <model>` - el origen principal es local; un despliegue inicial envía el modelo al Workspace, y los guardados posteriores lo vuelven a desplegar automáticamente.
-- `--workspace-format <bim|TMDL>` - elige el formato en disco al sincronizarlo con una carpeta o archivo (por ejemplo, `-w ./model.bim` deduce BIM).
+- `--workspace-format <fmt>` - elige el formato en disco al reflejarlo en una carpeta/archivo: `tmdl`, `bim` (alias `tmsl`) o `database.json`. Cuando se omite, el formato se infiere a partir de la ruta de destino del Workspace (por ejemplo, `-w ./model.bim` infiere BIM).
 - `--workspace-auth <method>` - método de autenticación para un destino de Workspace remoto cuando el principal es local. Toma el valor de `--auth` si está establecido; de lo contrario, `auto`.
 - `--force`: obligatorio cuando el destino ya existe (carpeta no vacía o base de datos existente). Sin él, `te connect` muestra un prompt interactivo `y/n`, con `n` como opción segura predeterminada.
 
-Una vez activado, `te set --save`, `te rm --save`, `te script --save`, etc. guardan de forma transparente en ambos destinos. El orden de guardado siempre es **primero local y después remoto**, para que la copia en disco refleje el último cambio del usuario aunque falle el envío al servidor. Borra la réplica con `te connect --clear`.
+Una vez activado, `te set --save`, `te remove --save`, `te script --save`, etc. guardan de forma transparente en ambos destinos. El orden de guardado siempre es **primero local y después remoto**, para que la copia en disco refleje el último cambio del usuario aunque falle el envío al servidor. Borra la réplica con `te connect --clear`.
 
 ```bash
 te connect Finance "Revenue Model" -w ./revenue-model    # Mirror remote → local TMDL
@@ -850,25 +968,21 @@ Administra la autenticación almacenada en caché. Consulta @te-cli-auth.
 
 ### profile list / show / set / remove
 
-Administra perfiles de conexión con nombre. Consulta @te-cli-auth.
+Administra perfiles de conexión con nombre. (`te profile list` tiene como alias `ls`; `te profile remove` tiene como alias `rm`.) Consulta @te-cli-auth.
 
 ## Configuración
 
-### config show / paths / init / set
+### config list / paths / init / set
 
-Consulta y administra la configuración de la CLI y las sobrescrituras de PATH de TE3. Consulta @te-cli-config.
+Consulta y administra la configuración de la CLI y las sobrescrituras de PATH de TE3. (`te config list`, alias: `ls`.) Consulta @te-cli-config.
 
 ```bash
-te config show                          # Display all settings
+te config list                          # Display all settings
 te config paths                         # Resolved TE3 file paths
 te config init                          # Create default config
 te config set autoFormat true
 ```
 
-### license
-
-`te license` está reservado para la versión GA y no está disponible en esta versión preliminar. El comando sigue integrado con el analizador, por lo que los scripts existentes que lo invocan no darán error durante el análisis, pero todos los subcomandos finalizan con el código de salida `1` y mensajes de "no está disponible en esta versión preliminar". Consulta el [aviso de versión preliminar](xref:te-cli#preview-notice) en la página de información general para conocer el panorama más amplio de licencias.
-
 ### migrate
 
 Guía de referencia que muestra cómo las opciones heredadas de la CLI de Tabular Editor 2 se corresponden con la nueva CLI. Útil como referencia rápida mientras migras una canalización basada en TE2. Consulta @te-cli-migrate para ver la guía de migración completa.
@@ -885,10 +999,22 @@ te migrate --output-format json     # Machine-readable mapping
 
 Inicia una sesión REPL guiada con un prompt adaptado al modelo. Consulta @te-cli-interactive.
 
+> [!TIP]
+> Si ejecutas `te` en un terminal sin argumentos, también accederás al REPL de forma predeterminada (como si ejecutaras `te interactive`). Se controla mediante la clave de configuración `launchInteractiveMode`. Consulta @te-cli-interactive#auto-launch-on-empty-invocation.
+
+`te interactive` admite:
+
+- `<model>` - argumento posicional opcional: inicia la sesión con un modelo local, un archivo `.bim` o una carpeta `.SemanticModel` ya cargados.
+- `--no-banner` - omite el banner de bienvenida al iniciar. Útil si controlas el REPL desde scripts.
+- `--echo` - muestra en stdout cada comando ejecutado antes de su salida. Útil cuando canalizas comandos por stdin para que el registro muestre qué se ejecutó.
+- `--batch` - modo por lotes no interactivo: lee comandos de stdin línea a línea, ejecuta cada uno y sale al llegar al EOF. Se habilita automáticamente cuando stdin se redirige.
+- `--no-batch` - fuerza el modo TTY interactivo incluso cuando stdin se redirige (es mutuamente excluyente con `--batch`).
+
 ```bash
 te interactive                                # Connect later
 te interactive ./model                        # Start with a local model
 te interactive -s MyWorkspace -d MyModel      # Start with a remote model
+printf "list Measures\nexit\n" | te interactive ./model   # Pipe commands via stdin
 ```
 
 Las comillas y las referencias de estilo DAX funcionan igual que fuera de la sesión - consulta la sección [Rutas de objetos](#object-paths) de arriba y @te-cli-interactive para más detalles sobre la división de argv con reconocimiento de corchetes dentro del REPL.
@@ -899,12 +1025,12 @@ Muestra o administra la sesión actual del terminal. La CLI guarda el estado de
 
 Subcomandos:
 
-| Subcomando | Propósito                                                                                                                                                                                                 |
-| ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `show`     | Muestra los detalles de la sesión actual (ID, ruta de archivo, estado activo). Es la opción predeterminada cuando no se proporciona ningún subcomando. |
-| `list`     | Lista todos los archivos de sesión.                                                                                                                                                       |
-| `clear`    | Borra el estado activo de la sesión actual.                                                                                                                                               |
-| `prune`    | Elimina los archivos de sesión cuyo proceso de shell ya no está en ejecución.                                                                                                             |
+| Subcomando                             | Propósito                                                                                                                                                                                                 |
+| -------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `show`                                 | Muestra los detalles de la sesión actual (ID, ruta de archivo, estado activo). Es la opción predeterminada cuando no se proporciona ningún subcomando. |
+| `list` (alias `ls`) | Lista todos los archivos de sesión.                                                                                                                                                       |
+| `clear`                                | Borra el estado activo de la sesión actual.                                                                                                                                               |
+| `prune`                                | Elimina los archivos de sesión cuyo proceso de shell ya no está en ejecución.                                                                                                             |
 
 `te session prune` acepta:
 
@@ -932,11 +1058,11 @@ te completion fish
 
 ## Códigos de salida
 
-| Código de salida | Significado                                                                                                                                                                                                                                                          |
-| ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `0`              | Éxito.                                                                                                                                                                                                                                               |
-| `1`              | Fallo genérico (argumentos no válidos, fallo del comando, errores de validación, fallo de autenticación, el BPA gate falló con una gravedad ≥ error). Para `te diff`: se encontraron diferencias. |
-| `2`              | Solo en `te diff`: se produjo un error durante la comparación, por lo que se desconoce el estado de las diferencias.                                                                                                                 |
+| Código de salida | Significado                                                                                                                                                                                                                                                              |
+| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `0`              | Éxito.                                                                                                                                                                                                                                                   |
+| `1`              | Fallo genérico (argumentos no válidos, fallo del comando, errores de validación, fallo de autenticación, el gate de BPA falló con una gravedad >= error). Para `te diff`: se encontraron diferencias. |
+| `2`              | Solo en `te diff`: se produjo un error durante la comparación, por lo que se desconoce el estado de las diferencias.                                                                                                                     |
 
 Para un control detallado en las canalizaciones de CI, combina los códigos de salida con las anotaciones `--ci <vsts/github>` y los archivos de resultados `--trx`; consulta @te-cli-cicd.
 
diff --git a/localizedContent/es/content/features/te-cli/te-cli-config.md b/localizedContent/es/content/features/te-cli/te-cli-config.md
index ac979a97a..3eab6e00e 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-config.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-config.md
@@ -19,13 +19,13 @@ applies_to:
 
 La CLI de Tabular Editor lee una configuración opcional desde un archivo JSON. La configuración controla tres cosas:
 
-- **PATH de archivos** — donde la CLI lee las macros, las reglas de BPA y (opcionalmente) el ejecutable de TE3 Desktop, y donde escribe el registro de consultas.
-- **Valores predeterminados de comportamiento** — umbrales de BPA, formato automático y validación.
+- **Rutas de archivos** — dónde la CLI lee las macros, las reglas de BPA y (opcionalmente) el ejecutable de TE3 Desktop, y dónde escribir el registro de consultas.
+- **Valores predeterminados de comportamiento** — controles de BPA, formato automático y validación.
 - **Perfiles de conexión guardados** — la lista de perfiles con nombre entre los que puedes alternar.
 
 La CLI es independiente: no lee ni escribe en ningún PATH de instalación de la versión de escritorio de Tabular Editor 3. Los archivos de reglas de BPA y de macros deben definirse explícitamente en esta configuración (o inicializarse cuando haga falta con `te bpa rules init` / `te macro init`).
 
-La mayoría de los usuarios no necesitan editar el archivo de configuración directamente: `te config show`, `te config set <key> <value>` y `te profile set` cubren las operaciones habituales.
+La mayoría de los usuarios no necesitan editar el archivo de configuración directamente: `te config list`, `te config set <key> <value>` y `te profile set` cubren las operaciones habituales.
 
 ## Ubicación del archivo de configuración
 
@@ -35,7 +35,7 @@ Se comprueban las siguientes ubicaciones en este orden:
 2. `~/.config/te/config.json` (en Windows, `%USERPROFILE%\.config\te\config.json`).
 3. Si no hay archivo de configuración, la CLI usa los valores predeterminados integrados.
 
-`TE_CONFIG` se tiene en cuenta de forma coherente en todas las operaciones del archivo de configuración: `te config show`, `te config set`, `te config init` y `te config paths` leen y escriben en el PATH resuelto. Está pensado principalmente para pruebas, instalaciones mediante scripts y configuración por entorno.
+`TE_CONFIG` se tiene en cuenta de forma coherente en todas las operaciones del archivo de configuración: `te config list`, `te config set`, `te config init` y `te config paths` leen y escriben en la ruta resuelta. Está pensado principalmente para pruebas, instalaciones mediante scripts y configuración por entorno.
 
 Para crear una configuración predeterminada:
 
@@ -47,15 +47,15 @@ te config init --force     # Overwrite existing config
 ## Ver la configuración
 
 ```bash
-te config show                         # Display all settings
-te config show --output-format json    # Machine-readable
+te config list                         # Display all settings
+te config list --output-format json    # Machine-readable
 te config paths                        # Show resolved macros and BPA rule paths
 ```
 
 Usa `te config paths` para ver qué archivos usará realmente la CLI para las macros y las reglas de BPA. Es útil para depurar por qué faltan archivos de datos. La salida muestra dos filas: `macros` (la ruta del archivo de macros resuelta o `[not set]`) y `bpa.rules` (el primer archivo de reglas de BPA existente resuelto por el resolvedor de rutas, o `[not set]`).
 
 > [!NOTE]
-> `te config paths` emite campos `null` explícitamente en el modo `--output-format json` (por ejemplo, `{"macros": null, "bpa": {"rules": null}}`). Informar de los resultados de la resolución es precisamente el propósito del comando, así que `null` es una respuesta significativa: «se intentó, pero no se resolvió nada». `te config show --output-format json` elimina los campos `null` de forma predeterminada, así que quienes lo consuman deberían parsearlo de forma tolerante.
+> `te config paths` emite campos `null` explícitamente en el modo `--output-format json` (por ejemplo, `{"macros": null, "bpa": {"rules": null}}`). Informar de los resultados de la resolución es precisamente el propósito del comando, así que `null` es una respuesta significativa: «se intentó, pero no se resolvió nada». `te config list --output-format json` elimina los campos `null` de forma predeterminada, así que conviene que quien lo consuma lo interprete con tolerancia.
 
 ## Configurar valores
 
@@ -79,7 +79,7 @@ El esquema completo de configuración JSON con todas las claves en sus valores p
 
 ```json
 {
-  "formatVersion": 1,
+  "formatVersion": 2,
   "macros": null,
   "autoFormat": false,
   "validateOnMutation": true,
@@ -95,6 +95,7 @@ El esquema completo de configuración JSON con todas las claves en sus valores p
   },
 
   "interactiveEditMode": "stage",
+  "launchInteractiveMode": "auto",
 
   "formatOptions": {
     "useSemicolons": false,
@@ -142,18 +143,19 @@ Ejecuta `te config paths` para ver qué archivo resolvió realmente la CLI.
 
 Toda la configuración relacionada con BPA está en el objeto `bpa` y se referencia mediante claves con puntos en `te config set`.
 
-| Clave                        | Predeterminado | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
-| ---------------------------- | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `autoFormat`                 | `false`        | Ejecuta DAX Formatter sobre las expresiones modificadas después de `te add` / `te set` / `te mv` / `te macro run`. Usa el formateador interno de forma predeterminada; puedes optar por el servicio web de SQL BI mediante `formatOptions.useSqlBiDaxFormatter`.                                                                                                                                                                                                                                                                                                                                                    |
-| `validateOnMutation`         | `true`         | Después de un comando de modificación (`add`, `set`, `mv`, `replace --save`, `macro run`), comprueba que todas las referencias `Table[Column]` del modelo se sigan resolviendo. Detecta referencias huérfanas introducidas por cambios de nombre o eliminaciones antes de llegar al despliegue.                                                                                                                                                                                                                                                                                                  |
-| `bpa.onMutation`             | `false`        | Ejecuta un análisis de BPA acotado después de cada comando de modificación (`set`, `add`, `mv`, `rm`, `macro run`). Solo se comprueban los objetos de la tabla afectada, no los de todo el modelo; útil para obtener retroalimentación rápida durante ediciones iterativas.                                                                                                                                                                                                                                                                                                                      |
-| `bpa.onDeploy`               | `true`         | Ejecuta el control de BPA antes de que se ejecute `te deploy`. El despliegue se cancela si alguna regla se activa con una severidad ≥ error. Omítelo en una invocación concreta con `--skip-bpa`, o corrígelo automáticamente con `--fix-bpa`.                                                                                                                                                                                                                                                                                                                                                      |
-| `bpa.onSave`                 | `true`         | Ejecuta el control de BPA antes de que `te save -o` escriba en disco. Omítelo en una invocación concreta con `--skip-bpa` o `--force`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                              |
-| `bpa.builtInRules`           | `true`         | Incluye el conjunto depurado de reglas integradas de BPA cada vez que se ejecute el control. Configúralo en `false` para ignorar por completo las reglas integradas; entonces el control ejecutará solo las reglas configuradas mediante `bpa.rules` y cualquier regla incrustada en el modelo.                                                                                                                                                                                                                                                                                                                     |
-| `bpa.disabledBuiltInRuleIds` | `null`         | ID de reglas integradas individuales que se excluirán de la puerta de calidad. Este valor se modifica mediante `te bpa rules disable <id>` / `te bpa rules enable <id>`; es preferible usar esos comandos en lugar de editar el arreglo directamente.                                                                                                                                                                                                                                                                                                                                                               |
-| `vertipaqOnRefresh`          | `false`        | Tras una actualización correcta (`full`, `dataonly`, `automatic` o `add`), ejecuta automáticamente el análisis de VertiPaq para mostrar estadísticas de almacenamiento de las tablas actualizadas. Útil para detectar de inmediato regresiones inesperadas de cardinalidad o memoria.                                                                                                                                                                                                                                                                                                            |
-| `interactiveEditMode`        | `stage`        | Comportamiento predeterminado para las mutaciones en memoria dentro de `te interactive`. `stage` mantiene las mutaciones en memoria hasta que se invoca `save` (la opción más segura); `save` escribe en el origen después de cada comando que modifica el estado (úsese con cuidado en orígenes remotos: cada `set` desencadena una escritura XMLA); `revert` descarta las mutaciones después de cada comando, a menos que se haya pasado `--save` o `--stage`. Las marcas `--save` / `--revert` / `--stage` por comando siempre prevalecen. |
-| `disableTelemetry`           | `false`        | Desactiva la telemetría de uso anónima. La CLI recopila datos básicos de uso de comandos (nombre del comando, código de salida y duración) para orientar la priorización de funciones. La CLI nunca recopila el contenido del modelo, PATH ni el texto de las consultas.                                                                                                                                                                                                                                                                                                         |
+| Clave                        | Predeterminado | Descripción                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ---------------------------- | -------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `autoFormat`                 | `false`        | Ejecuta DAX Formatter en las expresiones modificadas después de `te add` / `te set` / `te move` / `te macro run`. Usa el formateador interno de forma predeterminada; puedes optar por el servicio web de SQL BI mediante `formatOptions.useSqlBiDaxFormatter`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `validateOnMutation`         | `true`         | Después de un comando de modificación (`add`, `set`, `mv`, `replace --save`, `macro run`), comprueba que todas las referencias `Table[Column]` del modelo se sigan resolviendo. Detecta referencias huérfanas introducidas por cambios de nombre o eliminaciones antes de llegar al despliegue.                                                                                                                                                                                                                                                                                                                                                                                                                                                                         |
+| `bpa.onMutation`             | `false`        | Ejecuta un análisis de BPA acotado después de cada comando de modificación (`set`, `add`, `mv`, `rm`, `macro run`). Solo se comprueban los objetos de la tabla afectada, no los de todo el modelo; útil para obtener retroalimentación rápida durante ediciones iterativas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `bpa.onDeploy`               | `true`         | Ejecuta el control de BPA antes de que se ejecute `te deploy`. El despliegue se aborta si se dispara alguna regla con una gravedad >= error. Omítelo en una invocación concreta con `--skip-bpa`, o corrígelo automáticamente con `--fix-bpa`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             |
+| `bpa.onSave`                 | `true`         | Ejecuta el control de BPA antes de que `te save -o` escriba en disco. Omítelo en una invocación concreta con `--skip-bpa` o `--force`.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
+| `bpa.builtInRules`           | `true`         | Incluye el conjunto depurado de reglas integradas de BPA cada vez que se ejecute el control. Configúralo en `false` para ignorar por completo las reglas integradas; entonces el control ejecutará solo las reglas configuradas mediante `bpa.rules` y cualquier regla incrustada en el modelo.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            |
+| `bpa.disabledBuiltInRuleIds` | `null`         | ID de reglas integradas individuales que se excluirán de la puerta de calidad. Este valor se modifica mediante `te bpa rules disable <id>` / `te bpa rules enable <id>`; es preferible usar esos comandos en lugar de editar el arreglo directamente.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      |
+| `vertipaqOnRefresh`          | `false`        | Tras una actualización correcta (`full`, `dataonly`, `automatic` o `add`), ejecuta automáticamente el análisis de VertiPaq para mostrar estadísticas de almacenamiento de las tablas actualizadas. Útil para detectar de inmediato regresiones inesperadas de cardinalidad o memoria.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   |
+| `interactiveEditMode`        | `stage`        | Comportamiento predeterminado para las mutaciones en memoria dentro de `te interactive`. `stage` mantiene las mutaciones en memoria hasta que se invoca `save` (la opción más segura); `save` escribe en el origen después de cada comando que modifica el estado (úsese con cuidado en orígenes remotos: cada `set` desencadena una escritura XMLA); `revert` descarta las mutaciones después de cada comando, a menos que se haya pasado `--save` o `--stage`. Las marcas `--save` / `--revert` / `--stage` por comando siempre prevalecen.                                                                                                                                                                        |
+| `launchInteractiveMode`      | `auto`         | Indica si al ejecutar `te` en un terminal sin argumentos se inicia el REPL interactivo. `auto` (predeterminado) inicia el REPL solo cuando los tres flujos (stdin, stdout y stderr) están asociados a un TTY, de modo que los scripts y las canalizaciones de CI pasan al análisis normal. `always` inicia el REPL independientemente de la redirección. `never` desactiva por completo el inicio automático y restaura el comportamiento tradicional de mostrar ayuda cuando no hay argumentos. La opción global `--non-interactive` fuerza `never` para una sola invocación. También puede establecerse para una sola invocación mediante la variable de entorno `TE_INTERACTIVE`. |
+| `disableTelemetry`           | `false`        | Desactiva la telemetría de uso anónima. La CLI recopila datos básicos de uso de comandos (nombre del comando, código de salida y duración) para orientar la priorización de funciones. La CLI nunca recopila el contenido del modelo, PATH ni el texto de las consultas.                                                                                                                                                                                                                                                                                                                                                                                                                                                                                |
 
 ```bash
 te config set bpa.rules "/etc/te/team.json,/etc/te/strict.json"
@@ -200,11 +202,11 @@ El control BPA es la red de seguridad que impide que se guarde o se despliegue u
 
 - `te deploy` ejecuta el control, a menos que se pase `--skip-bpa` o que `bpa.onDeploy` sea `false`.
 - `te save` ejecuta el control, a menos que se pase `--skip-bpa` (o `--force`) o que `bpa.onSave` sea `false`.
-- `te add`, `te set`, `te mv`, `te macro run` ejecutan el control solo cuando `bpa.onMutation` es `true`.
+- `te add`, `te set`, `te move`, `te macro run` ejecutan el control solo cuando `bpa.onMutation` es `true`.
 
 El control carga las reglas de BPA desde `bpa.rules` y, de forma predeterminada, el conjunto de reglas integrado (controlado por `bpa.builtInRules`). Las reglas integradas pueden excluirse individualmente mediante `bpa.disabledBuiltInRuleIds`; se administran con `te bpa rules disable <id>` / `te bpa rules enable <id>`.
 
-Cuando el control se activa y encuentra infracciones con gravedad ≥ `error`, el comando falla con el código de salida `1` y un resumen de las infracciones. Opciones para resolverlo:
+Cuando el control se activa y detecta incumplimientos con gravedad >= `error`, el comando falla con el código de salida `1` y un resumen de los incumplimientos. Opciones para resolverlo:
 
 - `--fix-bpa` - aplica en memoria la `fixExpression` de la regla al artefacto que se va a desplegar o guardar; los archivos fuente no se modifican.
 - `--skip-bpa` - desactiva el control solo para este comando.
@@ -219,13 +221,13 @@ te bpa run ./model --fix --save     # Apply fixes to the source
 
 ### Reglas de BPA integradas
 
-La CLI incluye un único conjunto canónico de reglas de BPA integradas, incrustado como recurso JSON. Las reglas integradas son de solo lectura: `te bpa rules set` y `te bpa rules rm` se niegan a modificar los ID integrados y remiten a los usuarios a `te bpa rules disable` en su lugar. Para personalizar el comportamiento de una regla integrada, cópiala en tu archivo local de reglas como una regla nueva con un ID distinto y deshabilita la regla integrada.
+La CLI incluye un único conjunto canónico de reglas de BPA integradas, incrustado como recurso JSON. Las reglas integradas son de solo lectura: `te bpa rules set` y `te bpa rules remove` se niegan a modificar los ID integrados y remiten a los usuarios a `te bpa rules disable` en su lugar. Para personalizar el comportamiento de una regla integrada, cópiala en tu archivo local de reglas como una regla nueva con un ID distinto y deshabilita la regla integrada.
 
 Tanto `bpa.builtInRules` como `bpa.disabledBuiltInRuleIds` se aplican de forma coherente a la validación de implementación/guardado/mutación **y** al comando manual `te bpa run`: si deshabilitas una regla una vez con `te bpa rules disable`, queda excluida en todas partes.
 
 ## Comportamiento tras la mutación
 
-Cuando ejecutas un comando que modifica (`te add`, `te set`, `te mv`, `te replace --save`, `te macro run`), la CLI realiza estas comprobaciones automáticamente:
+Cuando ejecutas un comando que modifica (`te add`, `te set`, `te move`, `te replace --save`, `te macro run`), la CLI realiza estas comprobaciones automáticamente:
 
 1. **Los errores de TOM** siempre se muestran. Un DAX o M no válidos en medidas, columnas, particiones o elementos de cálculo siempre hacen que el comando falle.
 2. **La validación del esquema** (`validateOnMutation`, valor predeterminado `true`) comprueba que las referencias `Table[Column]` en DAX sigan resolviéndose y verifica la consistencia de los metadatos.
@@ -238,18 +240,19 @@ Deshabilita una comprobación con `te config set <key> false`, o limita esa rela
 
 Usa las siguientes variables de entorno específicas de la CLI para PATH, comportamiento y diagnósticos. Para las variables de autenticación de Azure (`AZURE_CLIENT_ID`, `AZURE_TENANT_ID`, `AZURE_CLIENT_CERTIFICATE_PATH`, etc.), consulta @te-cli-auth.
 
-| Variable         | Propósito                                                                                                                                                                                                                                                                                                                                                                      |
-| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `TE_CONFIG`      | Ruta de acceso a un archivo de configuración alternativo. Se respeta en todas las operaciones de `te config` (`show`, `set`, `init`, `paths`).                                                                                                                                                                              |
-| `TE_MACROS_PATH` | Anula la ruta del archivo de macros (segundo en el orden de resolución; ver arriba). La leen los comandos `te macro`.                                                                                                                                                                                                       |
-| `TE_BPA_RULES`   | Anula la lista de archivos/URL de reglas de BPA utilizada por los subcomandos `te bpa run` y `te bpa rules`.                                                                                                                                                                                                                                                   |
-| `TE_BPA_CONFIG`  | Anula la ruta de acceso a la configuración del gate de BPA (`.te-bpa.json`) que lee el gate de despliegue/guardado.                                                                                                                                                                                                                         |
-| `TE3_EXE_PATH`   | Ruta al binario de escritorio de Tabular Editor 3. Se usa **solo** con `te open`; puedes dejarla sin definir en Linux/macOS o si no usas `te open`. Si no se especifica, se usa la búsqueda en `PATH`.                                                                                                                         |
-| `TE_DEBUG`       | Establece el valor en `1` para habilitar el registro de depuración globalmente (igual que `--debug` o `debug: true` en la configuración).                                                                                                                                                                                                   |
-| `NO_SPINNER`     | Establece el valor en `1` o `true` para desactivar los indicadores de progreso animados (alternativa a `spinner: false` en la configuración).                                                                                                                                                                                               |
-| `CI`             | Se detecta automáticamente. Cuando vale `1` o `true`, la CLI desactiva el spinner y cambia a una salida de texto sin formato. La mayoría de los runners de CI lo configuran automáticamente.                                                                                                                                   |
-| `TE_SESSION`     | Sobrescribe el identificador de sesión por terminal que se usa para el estado de la conexión activa. Útil para ejecutar varias sesiones aisladas de la CLI dentro del mismo shell, por ejemplo, en trabajos de matriz de CI en paralelo. Inspecciona y gestiona las sesiones con [`te session`](xref:te-cli-commands#session). |
-| `TE_COMPAT`      | Establécela en `te2` para forzar el modo de compatibilidad con TE2; consulta @te-cli-migrate.                                                                                                                                                                                                                                                     |
+| Variable         | Propósito                                                                                                                                                                                                                                                                                                                                                                                                                |
+| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
+| `TE_CONFIG`      | Ruta de acceso a un archivo de configuración alternativo. Se respeta en todas las operaciones de `te config` (`show`, `set`, `init`, `paths`).                                                                                                                                                                                                                        |
+| `TE_MACROS_PATH` | Anula la ruta del archivo de macros (segundo en el orden de resolución; ver arriba). La leen los comandos `te macro`.                                                                                                                                                                                                                                                 |
+| `TE_BPA_RULES`   | Anula la lista de archivos/URL de reglas de BPA utilizada por los subcomandos `te bpa run` y `te bpa rules`.                                                                                                                                                                                                                                                                                             |
+| `TE_BPA_CONFIG`  | Anula la ruta de acceso a la configuración del gate de BPA (`.te-bpa.json`) que lee el gate de despliegue/guardado.                                                                                                                                                                                                                                                                   |
+| `TE3_EXE_PATH`   | Ruta al binario de escritorio de Tabular Editor 3. Se usa **solo** con `te open`; puedes dejarla sin definir en Linux/macOS o si no usas `te open`. Si no se especifica, se usa la búsqueda en `PATH`.                                                                                                                                                                   |
+| `TE_DEBUG`       | Establece el valor en `1` para habilitar el registro de depuración globalmente (igual que `--debug` o `debug: true` en la configuración).                                                                                                                                                                                                                                             |
+| `NO_SPINNER`     | Establece el valor en `1` o `true` para desactivar los indicadores de progreso animados (alternativa a `spinner: false` en la configuración).                                                                                                                                                                                                                                         |
+| `CI`             | Se detecta automáticamente. Cuando vale `1` o `true`, la CLI desactiva el spinner y cambia a una salida de texto sin formato. La mayoría de los runners de CI lo configuran automáticamente.                                                                                                                                                                             |
+| `TE_SESSION`     | Sobrescribe el identificador de sesión por terminal que se usa para el estado de la conexión activa. Útil para ejecutar varias sesiones aisladas de la CLI dentro del mismo shell, por ejemplo, en trabajos de matriz de CI en paralelo. Inspecciona y gestiona las sesiones con [`te session`](xref:te-cli-commands#session).                                           |
+| `TE_INTERACTIVE` | Anula `launchInteractiveMode` para una sola invocación. Acepta `auto`, `always` o `never`. Útil para scripts puntuales que quieran usar el REPL interactivo (`TE_INTERACTIVE=always`) o forzar el comportamiento clásico de mostrar ayuda cuando no hay argumentos (`TE_INTERACTIVE=never`) sin tocar el archivo de configuración. |
+| `TE_COMPAT`      | Establécela en `te2` para forzar el modo de compatibilidad con TE2; consulta @te-cli-migrate.                                                                                                                                                                                                                                                                                               |
 
 ## Páginas relacionadas
 
diff --git a/localizedContent/es/content/features/te-cli/te-cli-interactive.md b/localizedContent/es/content/features/te-cli/te-cli-interactive.md
index 98f169e6c..98df33d5a 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-interactive.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-interactive.md
@@ -2,7 +2,7 @@
 uid: te-cli-interactive
 title: Modo interactivo
 author: Peer Grønnerup
-updated: 2026-05-12
+updated: 2026-06-26
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -29,6 +29,13 @@ te interactive ./model                      # Start with a local model
 te interactive -s MyWorkspace -d MyModel    # Start with a remote model
 ```
 
+`te interactive` acepta algunas opciones para ajustar la sesión:
+
+- `--no-banner` - omite el banner de bienvenida al iniciar.
+- `--echo` - escribe en stdout cada comando ejecutado antes de su salida. Útil para llevar un registro cuando se controla la REPL desde un script.
+- `--batch` - modo por lotes no interactivo: lee comandos de stdin línea por línea, ejecuta cada uno y sale al llegar a EOF. Se habilita automáticamente cuando stdin está redirigido.
+- `--no-batch` - fuerza el modo TTY interactivo incluso cuando stdin está redirigido (mutuamente excluyente con `--batch`).
+
 La sesión imprime un banner de bienvenida, muestra el modelo activo y te sitúa en un prompt con contexto del modelo:
 
 ![Sesión del modo interactivo de Tabular Editor CLI](~/content/assets/images/features/cli/cli-interactive-mode.png)
@@ -84,6 +91,85 @@ Cuando el modo interactivo está activo, los comandos que necesitan información
 
 Para desactivar las indicaciones en un único comando dentro de la sesión, pasa `--non-interactive`.
 
+## Entrada canalizada y redirigida
+
+El modo interactivo también acepta stdin canalizado o redirigido, de modo que puedes controlar la misma REPL desde un script en lugar de introducir los comandos a mano. Cada línea de entrada se ejecuta como un comando, exactamente igual que si la hubieras introducido en el prompt, y la sesión termina cuando se agota la entrada (o cuando llega a una línea `exit`).
+
+```bash
+printf "ls\nexit\n" | te interactive ./model        # bash / git-bash
+te interactive ./model < script.te                  # redirected file
+```
+
+```bat
+(echo ls & echo exit) | te interactive .\model      :: Windows cmd.exe
+```
+
+Las líneas que empiezan por `#` se tratan como comentarios y se omiten, así que puedes anotar un archivo de script:
+
+```
+# script.te - inspect the model, then exit
+ls tables
+ls measures
+exit
+```
+
+### Modo por lotes y códigos de salida
+
+Cuando stdin está canalizado, `--batch` es el valor **predeterminado**: la sesión se detiene en el primer comando que falla y sale con un código distinto de cero, lo que hace que una ejecución canalizada sea segura para usarla como paso de compilación o de CI. Usa `--no-batch` para seguir ejecutando las líneas restantes incluso después de que falle un comando. El código de salida del proceso es `0` si la ejecución finaliza correctamente y distinto de cero cuando falla un comando en modo por lotes.
+
+```bash
+# Default when piped: stop at the first failing command, exit non-zero
+printf "bpa run --fail-on error\ndeploy --force\nexit\n" | te interactive ./model
+
+# Run every line regardless of failures
+printf "bpa run --fail-on error\ndeploy --force\nexit\n" | te interactive ./model --no-batch
+```
+
+### Transcripciones legibles
+
+`--echo` escribe cada línea de entrada en stdout antes de su salida, lo que resulta práctico al capturar una transcripción de una ejecución canalizada. Las líneas de comentario no se muestran.
+
+```bash
+printf "ls tables\nexit\n" | te interactive ./model --echo
+```
+
+### Opciones
+
+| Opción        | Descripción                                                                                                                                          |
+| ------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `--no-banner` | Suprime el banner de bienvenida.                                                                                                     |
+| `--echo`      | Escribe cada línea de entrada en stdout (útil para transcripciones de ejecuciones canalizadas).                   |
+| `--batch`     | Sale con un código distinto de cero en el primer comando que falla (predeterminado cuando stdin está canalizado). |
+| `--no-batch`  | Continúa tras los errores incluso cuando stdin se canaliza por una tubería.                                                          |
+
+### Banner de bienvenida frente al aviso de versión preliminar
+
+Pueden aparecer dos mensajes distintos al iniciar una sesión; no los confundas:
+
+- El **banner de bienvenida** es la pantalla inicial interactiva descrita en [Iniciar una sesión](#starting-a-session). Se suprime con `--no-banner`. Cuando stdin se canaliza por una tubería, el banner de bienvenida ni siquiera se muestra, así que `--no-banner` solo tiene un efecto visible en una sesión interactiva (TTY) real.
+- El **aviso de caducidad de la versión preliminar** (`This is an early preview release ...`) es otro de los **mensajes**. Siempre se escribe en **stderr** y **no** se ve afectado por `--no-banner`. Suprímelo con `te config set hidePreviewNotice true`.
+
+## Inicio automático al invocar sin argumentos
+
+Ejecutar `te` en una terminal sin argumentos te lleva directamente al REPL interactivo, así que explorar un modelo es tan rápido como abrir una terminal y escribir `te`. Cuando stdin, stdout o stderr se redirigen (salida por tubería, pipelines de CI, scripts), la CLI continúa con el análisis habitual y muestra la ayuda en su lugar, así que los scripts de shell que invocan `te` sin un subcomando siguen comportándose de la misma manera.
+
+Este comportamiento se controla con la clave de configuración `launchInteractiveMode`, que admite tres valores:
+
+| Valor                                      | Efecto                                                                                                                                                                           |
+| ------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `auto` (predeterminado) | Inicia el REPL solo cuando los tres flujos están adjuntos a un TTY. De lo contrario, pasa al análisis normal.                                    |
+| `always`                                   | Inicia el REPL aunque haya redirección de flujos. Útil si siempre quieres una sesión interactiva.                                                |
+| `never`                                    | No inicia nunca el REPL automáticamente. `te` por sí solo muestra la ayuda, igual que antes de la versión 0.6.0. |
+
+Cámbialo globalmente con:
+
+```bash
+te config set launchInteractiveMode never    # keep the classic help-on-empty behavior
+te config set launchInteractiveMode auto     # restore the default
+```
+
+Puedes anularlo para una única ejecución mediante la variable de entorno `TE_INTERACTIVE` (con los mismos valores) o pasar `--non-interactive` en la línea de comandos; ambas opciones fuerzan `never` en esa ejecución, por lo que `te --non-interactive` muestra la ayuda en lugar de iniciar el REPL.
+
 ## Cuándo usar el modo interactivo frente al no interactivo
 
 - **El modo interactivo** es ideal para explorar, aprender la CLI, hacer ediciones masivas puntuales sobre un único modelo y realizar demos.
diff --git a/localizedContent/es/content/features/te-cli/te-cli-limitations.md b/localizedContent/es/content/features/te-cli/te-cli-limitations.md
index d425a054d..79b497c51 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-limitations.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-limitations.md
@@ -43,9 +43,9 @@ La CLI ejecuta C# Scripts (`te script`) sobre el mismo objeto `Model` que usas e
 
 | Limitación                                                                              | Notas / Solución alternativa                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                 |
 | --------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **Las fuentes de reglas de BPA deben ser URL HTTPS o rutas de archivos locales**        | Solo se aceptan las URL `https://` y las rutas de archivo locales sin esquema. `http://` se reconoce, pero se rechaza deliberadamente en tiempo de carga con un error claro; como las reglas de BPA son expresiones de reglas ejecutables, obtenerlas a través de un canal no autenticado supondría un riesgo de manipulación. Otros esquemas de URL (`file://`, `ftp://`, …) no se admiten. Se aplica tanto a `te bpa run --rules` como a la lista de reglas configurada mediante [`te config set`](xref:te-cli-commands#config-show--paths--init--set). |
+| **Las fuentes de reglas de BPA deben ser URL HTTPS o rutas de archivos locales**        | Solo se aceptan las URL `https://` y las rutas de archivo locales sin esquema. `http://` se reconoce, pero se rechaza deliberadamente en tiempo de carga con un error claro; como las reglas de BPA son expresiones de reglas ejecutables, obtenerlas a través de un canal no autenticado supondría un riesgo de manipulación. Otros esquemas de URL (`file://`, `ftp://`, …) no se admiten. Se aplica tanto a `te bpa run --rules` como a la lista de reglas configurada mediante [`te config set`](xref:te-cli-commands#config-list--paths--init--set). |
 | **La validación de las URL de las reglas se realiza en el gate, no en `te config set`** | Un error tipográfico como `http://` lo acepta `te config set` y solo sale a la luz cuando BPA se ejecuta realmente. Después de editar las fuentes de reglas configuradas, ejecuta `te bpa run` (o `te validate`) una vez para comprobar que cada URL se carga correctamente.                                                                                                                                                                                                                                                                                                              |
-| **`--rules` no desactiva las reglas integradas**                                        | Cuando se pasa `te bpa run --rules <path-or-url>`, las reglas proporcionadas sustituyen las entradas de [`bpa.rules`](xref:te-cli-commands#config-show--paths--init--set) y `TE_BPA_RULES` para esa invocación, pero los valores predeterminados integrados siguen cargándose también. Para ejecutar solo el archivo de reglas explícito, pasa también `--no-defaults`.                                                                                                                                                                                                                                      |
+| **`--rules` no desactiva las reglas integradas**                                        | Cuando se pasa `te bpa run --rules <path-or-url>`, las reglas proporcionadas sustituyen las entradas de [`bpa.rules`](xref:te-cli-commands#config-list--paths--init--set) y `TE_BPA_RULES` para esa invocación, pero los valores predeterminados integrados se cargan igualmente. Para ejecutar solo el archivo de reglas explícito, pasa también `--no-defaults`.                                                                                                                                                                                                                                           |
 | **No hay ninguna opción por invocación para omitir la configuración de `bpa.rules`**    | Una vez configurado `bpa.rules`, cada `te bpa run` carga esas reglas además de las integradas. Actualmente no hay ninguna opción para omitir los archivos de reglas configurados en una sola ejecución. Solución alternativa: pasa `--rules <path-or-url>` explícitamente; esta opción sustituye por completo `bpa.rules` y `TE_BPA_RULES` para esa invocación.                                                                                                                                                                                                              |
 
 ## Validación
@@ -56,9 +56,9 @@ La CLI ejecuta C# Scripts (`te script`) sobre el mismo objeto `Model` que usas e
 
 ## E/S del modelo
 
-| Limitación                                                                       | Notas / Solución alternativa                                                                                                                                                                                                                                                                                                                                                                               |
-| -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **`--serialization` no puede combinar una serialización con un contenedor PBIP** | La opción `--serialization` en [`te save`](xref:te-cli-commands#save) trata `bim`, `tmdl`, `te-folder` y `pbip` como mutuamente excluyentes, por lo que actualmente no se puede generar un contenedor PBIP alrededor de un modelo serializado con TMSL (`.bim`). Guarda TMDL dentro de un contenedor PBIP, o guarda `.bim` fuera de un contenedor PBIP. |
+| Limitación                                                                       | Notas / Solución alternativa                                                                                                                                                                                                                                                                                                                                                                                     |
+| -------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`--serialization` no puede combinar una serialización con un contenedor PBIP** | La opción `--serialization` en [`te save`](xref:te-cli-commands#save) trata `bim`, `tmdl`, `Database.json` y `pbip` como mutuamente excluyentes, por lo que actualmente no es posible generar un contenedor PBIP alrededor de un modelo serializado con TMSL (`.bim`). Guarda TMDL dentro de un contenedor PBIP, o guarda `.bim` fuera de un contenedor PBIP. |
 
 ## Autenticación
 
diff --git a/localizedContent/es/content/features/te-cli/te-cli-migrate.md b/localizedContent/es/content/features/te-cli/te-cli-migrate.md
index f6ff7920a..4e7faf5e0 100644
--- a/localizedContent/es/content/features/te-cli/te-cli-migrate.md
+++ b/localizedContent/es/content/features/te-cli/te-cli-migrate.md
@@ -55,34 +55,34 @@ Consulta la salida del comando `te migrate` para ver el mapeo actual, que reflej
 
 Un resumen no exhaustivo de los flags más usados. Ejecuta `te migrate` para ver la lista completa.
 
-| Flag de TE2                                                        | Nuevo equivalente en la CLI                                             | Notas                                                                                                                                                                                                                                                         |
-| ------------------------------------------------------------------ | ----------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `file` (posicional)                             | `te <command> <path>` o el flag global `--model`                        | Primer argumento posicional en la mayoría de los comandos.                                                                                                                                                                                    |
-| `server`, `database`                                               | `te connect <server>` o `te deploy <server> <database>`                 | El servidor ya no es un argumento posicional global.                                                                                                                                                                                          |
-| `-L` / `-LOCAL`                                                    | `te connect --local`                                                    | Solo para Windows.                                                                                                                                                                                                                            |
-| `-S` / `-SCRIPT`                                                   | `te script -S <file.csx>` o `-e "code"`                                 | Admite varios scripts, código en línea y stdin. Nota: `-S` en mayúsculas; `-s` en minúsculas corresponde a la opción global `--server`.                                                                       |
-| `-A` / `-ANALYZE`                                                  | `te bpa run --rules <file-or-url>`                                      | Admite `--fail-on`, `--fix` y varios archivos de reglas.                                                                                                                                                                                      |
-| `-AX` / `-ANALYZEX`                                                | `te bpa run --rules <file>` (sin `--model-rules`)    | Excluir las reglas incrustadas en el modelo es ahora el comportamiento predeterminado.                                                                                                                                                        |
-| `-B` / `-BIM`                                                      | `te save <model> -o <file.bim> --serialization bim`                     |                                                                                                                                                                                                                                                               |
-| `-F` / `-FOLDER`                                                   | `te save <model> -o <dir> --serialization te-folder`                    | Tras `-D`, el `-F` de TE2 significa `-FULL`. Consulta `--deploy-full`.                                                                                                                                                        |
-| `-TMDL`                                                            | `te save <model> -o <dir> --serialization tmdl`                         | TMDL es el formato de guardado predeterminado.                                                                                                                                                                                                |
-| `-D` / `-DEPLOY`                                                   | `te deploy <server> <database> <model>`                                 | Comando independiente con opciones con nombre.                                                                                                                                                                                                |
-| `-O` / `-OVERWRITE`                                                | (predeterminado) o `--create-only` para no aplicarlo | La sobrescritura es el comportamiento predeterminado en la nueva CLI.                                                                                                                                                                         |
-| `-C` / `-CONNECTIONS`                                              | `te deploy --deploy-connections`                                        |                                                                                                                                                                                                                                                               |
-| `-P` / `-PARTITIONS`                                               | `te deploy --deploy-partitions`                                         |                                                                                                                                                                                                                                                               |
-| `-Y` / `-SKIPPOLICY`                                               | `te deploy --deploy-partitions --skip-refresh-policy`                   | Requiere `--deploy-partitions`.                                                                                                                                                                                                               |
-| `-SHARED`                                                          | `te deploy --deploy-shared-expressions`                                 | Después de `-D`, `-S` en TE2 significa `-SHARED`.                                                                                                                                                                                             |
-| `-R` / `-ROLES`                                                    | `te deploy --deploy-roles`                                              |                                                                                                                                                                                                                                                               |
-| `-M` / `-MEMBERS`                                                  | `te deploy --deploy-role-members`                                       |                                                                                                                                                                                                                                                               |
-| `-FULL` (después de `-D`)                       | `te deploy --deploy-full`                                               | Equivale a: sobrescritura + conexiones + particiones + elementos compartidos + roles + miembros de rol.                                                                                                                       |
-| `-X` / `-XMLA <file>`                                              | `te deploy ... --xmla <file>`                                           | Usa `-` para stdout.                                                                                                                                                                                                                          |
-| `-V` / `-VSTS`                                                     | `--ci vsts` en `validate`, `bpa run`, `deploy`                          | Emite anotaciones `##vso[...]` en stderr.                                                                                                                                                                                                     |
-| `-G` / `-GITHUB`                                                   | `--ci github`                                                           | Emite anotaciones `::error::` / `::warning::`.                                                                                                                                                                                                |
-| `-T` / `-TRX <file>`                                               | `--trx <file>` en `validate`, `bpa run`, `test run`                     | Archivo `.trx` de VSTEST para publicar pruebas en Azure DevOps.                                                                                                                                                                               |
-| `-W` / `-WARN`                                                     | (predeterminado)                                     | Las advertencias siempre se incluyen en el Report de resultados de la implementación.                                                                                                                                                         |
-| `-E` / `-ERR`                                                      | (predeterminado)                                     | La implementación devuelve un código de salida distinto de cero cuando hay errores de DAX.                                                                                                                                                    |
-| `-SC` / `-SCHEMACHECK`                                             | _Aún no se ha implementado._                            | La comprobación del esquema de TE2 se conecta a los Data source reales. A diferencia de `te validate` (validación semántica de DAX, sin conexión al Data source).                                          |
-| `-L` / `-LOGIN <user> <pass>` (después de `-D`) | `te auth login -u <id> -p <secret> -t <tenant>`                         | Usa una entidad de servicio o credenciales basadas en variables de entorno. El inicio de sesión se guarda en caché, así que los comandos posteriores obtienen tokens de forma silenciosa; consulta @te-cli-auth. |
+| Flag de TE2                                                        | Nuevo equivalente en la CLI                                                      | Notas                                                                                                                                                                                                                                                         |
+| ------------------------------------------------------------------ | -------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `file` (posicional)                             | `te <command> <path>` o el flag global `--model`                                 | Primer argumento posicional en la mayoría de los comandos.                                                                                                                                                                                    |
+| `server`, `database`                                               | `te connect <server> <database>` o `te deploy <model> -s <server> -d <database>` | El servidor ya no es un argumento posicional global; `te deploy` solo toma `<model>` como argumento posicional, y server y database se especifican mediante opciones con nombre.                                                              |
+| `-L` / `-LOCAL`                                                    | `te connect --local`                                                             | Solo para Windows.                                                                                                                                                                                                                            |
+| `-S` / `-SCRIPT`                                                   | `te script -S <file.csx>` o `-e "code"`                                          | Admite varios scripts, código en línea y stdin. Nota: `-S` en mayúsculas; `-s` en minúsculas corresponde a la opción global `--server`.                                                                       |
+| `-A` / `-ANALYZE`                                                  | `te bpa run --rules <file-or-url>`                                               | Admite `--fail-on`, `--fix` y varios archivos de reglas.                                                                                                                                                                                      |
+| `-AX` / `-ANALYZEX`                                                | `te bpa run --rules <file>` (sin `--model-rules`)             | Excluir las reglas incrustadas en el modelo es ahora el comportamiento predeterminado.                                                                                                                                                        |
+| `-B` / `-BIM`                                                      | `te save <model> -o <file.bim> --serialization bim`                              |                                                                                                                                                                                                                                                               |
+| `-F` / `-FOLDER`                                                   | `te save <model> -o <dir> --serialization Database.json`                         | Tras `-D`, el `-F` de TE2 significa `-FULL`. Consulta `--deploy-full`.                                                                                                                                                        |
+| `-TMDL`                                                            | `te save <model> -o <dir> --serialization tmdl`                                  | TMDL es el formato de guardado predeterminado.                                                                                                                                                                                                |
+| `-D` / `-DEPLOY`                                                   | `te deploy <model> -s <server> -d <database>`                                    | Comando independiente con opciones con nombre; solo `<model>` es un argumento posicional.                                                                                                                                                     |
+| `-O` / `-OVERWRITE`                                                | (predeterminado) o `--create-only` para no aplicarlo          | La sobrescritura es el comportamiento predeterminado en la nueva CLI.                                                                                                                                                                         |
+| `-C` / `-CONNECTIONS`                                              | `te deploy --deploy-connections`                                                 |                                                                                                                                                                                                                                                               |
+| `-P` / `-PARTITIONS`                                               | `te deploy --deploy-partitions`                                                  |                                                                                                                                                                                                                                                               |
+| `-Y` / `-SKIPPOLICY`                                               | `te deploy --deploy-partitions --skip-refresh-policy`                            | Requiere `--deploy-partitions`.                                                                                                                                                                                                               |
+| `-SHARED`                                                          | `te deploy --deploy-shared-expressions`                                          | Después de `-D`, `-S` en TE2 significa `-SHARED`.                                                                                                                                                                                             |
+| `-R` / `-ROLES`                                                    | `te deploy --deploy-roles`                                                       |                                                                                                                                                                                                                                                               |
+| `-M` / `-MEMBERS`                                                  | `te deploy --deploy-role-members`                                                |                                                                                                                                                                                                                                                               |
+| `-FULL` (después de `-D`)                       | `te deploy --deploy-full`                                                        | Equivale a: sobrescritura + conexiones + particiones + elementos compartidos + roles + miembros de rol.                                                                                                                       |
+| `-X` / `-XMLA <file>`                                              | `te deploy ... --xmla <file>`                                                    | Usa `-` para stdout.                                                                                                                                                                                                                          |
+| `-V` / `-VSTS`                                                     | `--ci vsts` en `validate`, `bpa run`, `deploy`                                   | Emite anotaciones `##vso[...]` en stderr.                                                                                                                                                                                                     |
+| `-G` / `-GITHUB`                                                   | `--ci github`                                                                    | Emite anotaciones `::error::` / `::warning::`.                                                                                                                                                                                                |
+| `-T` / `-TRX <file>`                                               | `--trx <file>` en `validate`, `bpa run`, `test run`                              | Archivo `.trx` de VSTEST para publicar pruebas en Azure DevOps.                                                                                                                                                                               |
+| `-W` / `-WARN`                                                     | (predeterminado)                                              | Las advertencias siempre se incluyen en el Report de resultados de la implementación.                                                                                                                                                         |
+| `-E` / `-ERR`                                                      | (predeterminado)                                              | La implementación devuelve un código de salida distinto de cero cuando hay errores de DAX.                                                                                                                                                    |
+| `-SC` / `-SCHEMACHECK`                                             | _Aún no se ha implementado._                                     | La comprobación del esquema de TE2 se conecta a los Data source reales. A diferencia de `te validate` (validación semántica de DAX, sin conexión al Data source).                                          |
+| `-L` / `-LOGIN <user> <pass>` (después de `-D`) | `te auth login -u <id> -p <secret> -t <tenant>`                                  | Usa una entidad de servicio o credenciales basadas en variables de entorno. El inicio de sesión se guarda en caché, así que los comandos posteriores obtienen tokens de forma silenciosa; consulta @te-cli-auth. |
 
 ## Guía de migración
 
diff --git a/localizedContent/es/content/features/te-cli/te-cli.md b/localizedContent/es/content/features/te-cli/te-cli.md
index 2a20f42dc..e1c69555a 100644
--- a/localizedContent/es/content/features/te-cli/te-cli.md
+++ b/localizedContent/es/content/features/te-cli/te-cli.md
@@ -27,8 +27,8 @@ A diferencia de las opciones de línea de comandos de `TabularEditor.exe` exclus
 
 Tres pilares de diseño están presentes en todos los comandos:
 
-- **Salida estructurada** — JSON, CSV, TMDL y TMSL, además del texto legible predeterminado.
-- **Modo no interactivo** — una opción global `--non-interactive` que desactiva las indicaciones y falla de inmediato.
+- **Salida estructurada** — JSON, CSV, TMDL y TMSL, junto con el texto predeterminado legible para humanos.
+- **Modo no interactivo** — una opción global `--non-interactive` que desactiva los avisos y hace que el comando falle inmediatamente.
 - **Errores claros** — se escriben en stderr con códigos de salida predecibles.
 
 En conjunto, hacen que el mismo binario funcione bien para tres perfiles muy distintos:
@@ -49,31 +49,34 @@ Consulta @te-cli-commands para ver una referencia completa de los comandos, con
 | Familia                                                                        | Qué hace                                                                                        | Comandos de ejemplo                                                                                                                                                                      |
 | ------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [E/S del modelo](xref:te-cli-commands#model-io)                                | Cargar, guardar, convertir e inicializar modelos                                                | [`te load`](xref:te-cli-commands#load), [`te save`](xref:te-cli-commands#save), [`te init`](xref:te-cli-commands#init)                                                                   |
-| [Edición del modelo](xref:te-cli-commands#model-editing)                       | Obtener y establecer propiedades; añadir, quitar y mover objetos                                | [`te set`](xref:te-cli-commands#set), [`te add`](xref:te-cli-commands#add), [`te rm`](xref:te-cli-commands#rm), [`te mv`](xref:te-cli-commands#mv)                                       |
-| [Inspección](xref:te-cli-commands#inspection)                                  | Listar objetos, buscar, comparar y analizar dependencias                                        | [`te ls`](xref:te-cli-commands#ls), [`te find`](xref:te-cli-commands#find), [`te diff`](xref:te-cli-commands#diff), [`te deps`](xref:te-cli-commands#deps)                               |
+| [Edición del modelo](xref:te-cli-commands#model-editing)                       | Obtener y establecer propiedades; añadir, quitar y mover objetos                                | [`te set`](xref:te-cli-commands#set), [`te add`](xref:te-cli-commands#add), [`te remove`](xref:te-cli-commands#remove), [`te move`](xref:te-cli-commands#move)                           |
+| [Inspección](xref:te-cli-commands#inspection)                                  | Listar objetos, buscar, comparar y analizar dependencias                                        | [`te list`](xref:te-cli-commands#list), [`te find`](xref:te-cli-commands#find), [`te diff`](xref:te-cli-commands#diff), [`te deps`](xref:te-cli-commands#deps)                           |
 | [Análisis y calidad](xref:te-cli-commands#analysis-and-quality)                | Validar, ejecutar BPA, dar formato a DAX y analizar el almacenamiento                           | [`te validate`](xref:te-cli-commands#validate), [`te bpa run`](xref:te-cli-commands#bpa-run), [`te format`](xref:te-cli-commands#format), [`te vertipaq`](xref:te-cli-commands#vertipaq) |
 | [Ejecución](xref:te-cli-commands#execution)                                    | Ejecutar consultas DAX, C# Scripts y macros                                                     | [`te query`](xref:te-cli-commands#query), [`te script`](xref:te-cli-commands#script), [`te macro`](xref:te-cli-commands#macro)                                                           |
 | [Implementación y actualización](xref:te-cli-commands#deployment-and-refresh)  | Implementar en el Workspace, iniciar una actualización y realizar una actualización incremental | [`te deploy`](xref:te-cli-commands#deploy), [`te refresh`](xref:te-cli-commands#refresh), [`te incremental-refresh`](xref:te-cli-commands#incremental-refresh)                           |
 | [Pruebas](xref:te-cli-commands#testing)                                        | Pruebas de aserciones, instantáneas, comparación A/B                                            | [`te test run`](xref:te-cli-commands#test-run)                                                                                                                                           |
 | [Conexión y autenticación](xref:te-cli-commands#connection-and-authentication) | Conéctate a los Workspace y gestiona la autenticación y los perfiles                            | [`te connect`](xref:te-cli-commands#connect), [`te auth`](xref:te-cli-commands#auth-login--status--logout), [`te profile`](xref:te-cli-commands#profile-list--show--set--remove)         |
-| [Configuración](xref:te-cli-commands#configuration)                            | Configuración y licencias                                                                       | [`te config`](xref:te-cli-commands#config-show--paths--init--set)                                                                                                                        |
+| [Configuración](xref:te-cli-commands#configuration)                            | Configuración y licencias                                                                       | [`te config`](xref:te-cli-commands#config-list--paths--init--set)                                                                                                                        |
 | [Shell](xref:te-cli-commands#shell)                                            | Modo interactivo, estado de la sesión, completado automático del shell                          | [`te interactive`](xref:te-cli-commands#interactive), [`te session`](xref:te-cli-commands#session), [`te completion`](xref:te-cli-commands#completion)                                   |
 
+> [!TIP]
+> La documentación usa los verbos canónicos en formato largo (`list`, `remove`, `move`), pero las formas cortas clásicas siguen funcionando como alias (`ls`, `rm`, `mv`, `rename`). Esto se aplica a los comandos de nivel superior y a los subcomandos `remove` / `list` dentro de grupos como `te bpa rules`, `te macro`, `te config`, `te profile`, `te session` y `te test`. Consulta @te-cli-commands#command-aliases para ver el mapeo completo.
+
 ## Primeros pasos
 
 1. **Regístrate o inicia sesión** en [tabulareditor.com](https://tabulareditor.com/download-tabular-editor-cli) con una cuenta de Tabular Editor.
 2. **Descarga e instala**: consulta @te-cli-install para ver las instrucciones para Windows, macOS y Linux.
 3. **Autentícate**: ejecuta `te auth login` para conectarte a Power BI o Fabric. Consulta @te-cli-auth.
-4. **Ejecuta tu primer comando**: `te --help` enumera todos los comandos; `te <command> --help` muestra las opciones detalladas.
+4. **Ejecuta tu primer comando**: `te --help` enumera todos los comandos; `te <command> --help` muestra las opciones detalladas. Consejo: si ejecutas `te` por sí solo en un terminal, entrarás en el REPL interactivo, una forma cómoda de explorar un modelo. Consulta @te-cli-interactive.
 
 Para ver por primera vez un modelo en vivo, solo necesitas dos comandos:
 
 ```bash
 te auth login
-te ls -s MyWorkspace -d MyModel
+te list -s MyWorkspace -d MyModel
 ```
 
-![Salida de ejemplo de te ls en la CLI de Tabular Editor](~/content/assets/images/features/cli/cli-command-ls.png)
+![Salida de ejemplo de te list en la CLI de Tabular Editor](~/content/assets/images/features/cli/cli-command-ls.png)
 
 ## Aviso de versión preliminar
 
diff --git a/localizedContent/es/content/features/views/tom-explorer-view.md b/localizedContent/es/content/features/views/tom-explorer-view.md
index cdbf86e9a..790b15e4b 100644
--- a/localizedContent/es/content/features/views/tom-explorer-view.md
+++ b/localizedContent/es/content/features/views/tom-explorer-view.md
@@ -2,7 +2,7 @@
 uid: tom-explorer-view
 title: Vista del Explorador TOM
 author: Morten Lønskov
-updated: 2026-03-19
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -52,7 +52,7 @@ El menú del botón derecho incluye los siguientes elementos, algunos de los cua
   Muestra un submenú que permite crear nuevas medidas, columnas, jerarquías, carpetas de visualización o elementos de cálculo bajo el objeto seleccionado. Las opciones disponibles dependen del tipo de objeto seleccionado.
 
 - **Mover a un grupo**:
-  Te permite organizar la tabla en un grupo de tablas dentro del Explorador TOM para navegar por el modelo con más facilidad. Esta opción solo está disponible para tablas.
+  Abre un submenú para organizar las tablas seleccionadas en un grupo de tablas y facilitar la navegación por el modelo. El submenú muestra los grupos de tablas existentes, una entrada **(Nuevo...)** que crea un grupo a partir de las tablas seleccionadas y abre el editor para nombrarlo, y una entrada **(Ninguno)** que elimina la asignación al grupo de tablas. Esta opción solo está disponible para tablas.
 
 - **Hacer invisible**:
   Marca el objeto como no visible en las herramientas cliente. La tabla sigue formando parte del modelo, pero está oculta para los autores de informes. Como alternativa, puedes usar el atajo **Ctrl+I** para ocultar el objeto.
diff --git a/localizedContent/es/content/getting-started/github-flow.md b/localizedContent/es/content/getting-started/github-flow.md
new file mode 100644
index 000000000..d358249d0
--- /dev/null
+++ b/localizedContent/es/content/getting-started/github-flow.md
@@ -0,0 +1,310 @@
+---
+uid: github-flow
+title: GitHub Flow y el patrón Octopus Merge
+author: Just Blindbæk
+updated: 2026-07-03
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      full: true
+    - product: Tabular Editor 3
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          full: true
+        - edition: Enterprise
+          full: true
+---
+
+# GitHub Flow y el patrón Octopus Merge
+
+Este artículo explica el flujo de trabajo diario de **GitHub Flow** recomendado en [Habilitar el desarrollo en paralelo con Git y Guardar en carpeta](xref:parallel-development), así como el patrón **Octopus Merge** que lo respalda: una forma de mantener un entorno de prueba compartido continuamente actualizado con todo lo que esté en curso en ese momento. La segunda mitad del artículo recorre una canalización de referencia completa que implementa esto y que, como verás, acaba abarcando bastante más que solo el paso de la fusión.
+
+## GitHub Flow en el día a día
+
+La regla de GitHub Flow es simple: `main` siempre está listo para implementarse y todo el trabajo se realiza en ramas de corta duración que parten de `main`; aun así, conviene dejar explícitos algunos detalles para un equipo encargado de un modelo semántico.
+
+**Crear una rama de funcionalidad:**
+
+```cmd
+git checkout main
+git pull
+git checkout -b feature/add-tax-calculation
+```
+
+**Desarrollo local.** El desarrollador trabaja en Tabular Editor 3. Cada vez que pulsa **Ctrl+S** ocurren dos cosas:
+
+- Los metadatos del modelo se guardan en disco en [formato Guardar en carpeta (Database.json)](xref:parallel-development#what-is-save-to-folder), listos para añadirse al área de preparación y hacer commit en la rama de funcionalidad en Git.
+- Si el [modo del área de trabajo](xref:workspace-mode) está habilitado, el modelo se sincroniza simultáneamente con la base de datos del Workspace personal del desarrollador dentro de un Workspace de desarrollo compartido, lo que permite hacer pruebas en vivo en Tabular Editor y que Power BI Desktop se conecte [directamente a la base de datos del Workspace](xref:workspace-mode#advantages-of-workspace-mode) para validar el Report.
+
+```cmd
+git add .
+git commit -m "Add tax calculation measure and supporting columns"
+git push
+```
+
+> [!WARNING]
+> No habilites la integración de Git de Fabric en el Workspace que hospeda tus bases de datos de Workspace. Tabular Editor escribe directamente en las bases de datos de Workspace a través del punto de conexión XMLA, y esas escrituras no tienen ninguna relación con tus ramas de Git; habilitar la integración con Git en ese mismo Workspace genera cambios conflictivos, fuera de Git, en la misma base de datos. Esto también se señala en la [documentación del modo del área de trabajo de Workspace](xref:workspace-mode).
+
+**Abrir una pull request.** Cuando el desarrollador está listo para realizar pruebas más amplias, abre una pull request dirigida a `main`. Este es el punto en el que GitHub Flow, por sí solo, deja una pregunta abierta para los equipos de BI: con varios desarrolladores, cada uno con una PR abierta a la vez, ¿qué debería reflejar realmente el entorno de prueba compartido? Eso es lo que responde Octopus Merge; lo verás más abajo.
+
+**Aprobación y fusión.** Una vez que los revisores técnicos y de negocio han dado su visto bueno tras probar en el entorno de prueba compartido, la rama de funcionalidad se fusiona en `main` y se elimina.
+
+**Despliegue en UAT / producción.** O bien cada fusión en `main` desencadena el despliegue automáticamente, o bien las fusiones se acumulan y se despliegan con una cadencia programada (por ejemplo, semanal). Ambos son compatibles con GitHub Flow: la estructura de ramas es la misma en ambos casos; lo único que cambia es el disparador del lanzamiento.
+
+## Octopus Merge: mantener actualizado el entorno de pruebas
+
+##### Nota: aclaración de nombres
+
+«Octopus merge» se usa en el ecosistema de Git para referirse a tres cosas relacionadas, pero distintas. Conviene precisar a cuál nos referimos aquí:
+
+1. **La estrategia nativa de octopus merge de Git** — la estrategia de fusión que Git usa automáticamente cuando ejecutas `git merge branch-a branch-b branch-c`, combinando más de dos cabezas de rama en un único commit de fusión _siempre que no haya conflictos_. Si alguna rama entra en conflicto con el merge en curso, el comando completo falla: Git no intenta resolver ni aislar conflictos entre más de dos ramas. Este es un mecanismo de bajo nivel de Git, no un flujo de trabajo.
+2. **`lesfurets/git-octopus`**: una herramienta de línea de comandos de código abierto, hoy archivada, que convertía esta estrategia nativa en un flujo de trabajo de «continuous merge»: identificaba un conjunto de ramas según un patrón de nombres, las fusionaba, hacía push del resultado a una rama desechable y repetía el proceso con cada push. También incluía herramientas para recorrer las ramas una a una y localizar cuál provocaba un conflicto. La herramienta en sí ya no se mantiene y no es lo que recomendamos implementar directamente, pero el flujo de trabajo que introdujo es exactamente el patrón que se describe a continuación.
+3. **El patrón Octopus Merge descrito en este artículo**: un pipeline de CI/CD personalizado que detecta todas las pull requests actualmente abiertas (que no están en borrador) dirigidas a `main`, fusiona sus ramas de origen usando la estrategia nativa de octopus merge de Git del punto (1), hace push del resultado a una rama desechable y despliega esa rama en un entorno de pruebas compartido. El patrón es la misma idea que en (2), reimplementada como un script de pipeline que controlas —por ejemplo, un workflow de GitHub Actions o un script de Azure Pipelines que llama a la API REST de Azure DevOps— en lugar de una herramienta independiente de terceros.
+
+Cuando este artículo dice «Octopus Merge», se refiere a (3). Ten en cuenta que (3) _usa_ la estrategia nativa del punto (1) como mecanismo real de fusión: el valor que aporta está en la automatización y en el ciclo de vida de las ramas alrededor de esa fusión, no en una forma alternativa de fusionar.
+
+En resumen, el patrón es este: **tu entorno de pruebas siempre refleja la combinación de todo lo que está actualmente en curso**; no solo una funcionalidad aislada. Cada vez que un desarrollador hace push a cualquier pull request abierta que no esté en borrador, el pipeline reconstruye desde cero la rama combinada y la vuelve a desplegar.
+
+```mermaid
+flowchart LR
+    main(["main"]) -.->|"deleted + recreated"| temp
+    prA["feature/A<br/>(open PR)"] --> temp
+    prB["feature/B<br/>(open PR)"] --> temp
+    prC["feature/C<br/>(draft PR — excluded)"]:::draft
+    temp[["♻️ octopus/temp<br/>deleted + recreated from main<br/>on every run"]] --> test(["Test workspace"])
+
+    classDef draft stroke-dasharray: 5 5,opacity:0.55;
+```
+
+> [!NOTE]
+> Tabular Editor ahora dispone de una CLI multiplataforma (`te`) en versión preliminar pública limitada, diseñada específicamente para CI/CD: modo no interactivo, anotaciones nativas de GitHub Actions/Azure DevOps, salida VSTEST y un comando `te test run` para ejecutar pruebas de regresión como parte de un pipeline. Encaja de forma natural con el tipo de pipeline descrito a continuación, y merece la pena seguirlo de cerca. En el momento de escribir esto, la propia documentación de Tabular Editor desaconseja usarlo en pipelines de producción durante la versión preliminar (se indica que la compilación preliminar caduca el 2026-09-30), por lo que la implementación de referencia de este artículo usa en su lugar la CLI consolidada `TabularEditor.exe`. Consulta [Integración de CI/CD](xref:te-cli-cicd) para conocer las capacidades actuales y ver ejemplos de la nueva CLI.
+
+<!-- FUTURE SPLIT POINT: everything from "Reference implementation" onward is a candidate to become its own page once it grows further (e.g. once release/production deployment past the test environment is added). -->
+
+## Implementación de referencia
+
+Lo que sigue es un pipeline completo y funcional que implementa Octopus Merge, pero conviene dejar claro desde el principio que hace bastante más que solo el paso de merge. Una ejecución completa también descarga Tabular Editor y valida el modelo fusionado con tus reglas de buenas prácticas y con el esquema en vivo de la Data source, antes de desplegarlo en el Workspace de pruebas compartido. Octopus Merge es la tarea 1 de 5; el resto es un pipeline de CI/CD de propósito general para modelos semánticos que, además, consume la salida de Octopus Merge. El despliegue de los Report sobre ese modelo — un aspecto aparte, con su propia variabilidad según la organización — se aborda brevemente al final.
+
+Los ejemplos siguientes muestran tanto **Azure Pipelines** (que invoca la API REST de Azure DevOps) como **GitHub Actions** (que invoca la API REST de GitHub) para el trabajo de fusión, ya que ambas plataformas se diferencian principalmente en cómo se autentican y consultan los pull requests; las operaciones de Git subyacentes y las invocaciones a la CLI de Tabular Editor son idénticas en ambos casos.
+
+### Descripción general del pipeline
+
+Una ejecución completa consta de varios trabajos, cada uno con dependencias explícitas respecto a los anteriores:
+
+```mermaid
+flowchart TD
+    merge["Octopus merge"] --> dl["Download Tabular Editor"]
+    dl --> bpa["BPA verification"]
+    dl --> schema["Schema validation"]
+    bpa --> deploy["Model deployment"]
+    schema --> deploy
+```
+
+Ejecutar cada fase como un trabajo independiente —en lugar de un único script largo— te da un indicador independiente de aprobado/reprobado para cada aspecto (conflictos de fusión frente a infracciones de BPA frente a deriva del esquema frente a errores de despliegue), lo que permite diagnosticar mucho más rápido qué fue lo que salió mal cuando falla una ejecución.
+
+##### Nota: requisitos del agente del pipeline
+
+Como `TabularEditor.exe` solo se ejecuta en Windows, todos los trabajos que lo invoquen necesitan un agente/runner basado en Windows; esto incluye los trabajos de verificación de BPA, validación de esquema y despliegue del modelo. Un agente de Windows hospedado en la nube funciona bien siempre que pueda acceder, a través de la red, a tu Workspace de prueba y a tu Data source; un agente autohospedado solo es necesario si no se puede acceder a esos endpoints desde fuera de tu red (por ejemplo, una Data source local). El propio trabajo de fusión de Octopus no tiene esa limitación, ya que solo necesita Git.
+
+### Cómo se desencadena el pipeline
+
+El pipeline no se activa con un disparador normal por push en Git. Como necesita fusionar _todos_ los pull requests abiertos en ese momento, no solo el que cambió, normalmente se configura sin un disparador automático por rama y se invoca de una de estas dos maneras:
+
+- **Desde un pipeline de pull requests o una política de rama**, para que se ejecute cada vez que se cree un pull request dirigido a `main`, o cada vez que se haga push de un nuevo commit a cualquier rama con un pull request abierto.
+- **De forma programada** (por ejemplo, cada pocos minutos), como alternativa más simple si a tu plataforma de CI/CD le resulta incómodo configurar directamente "ejecutar con cualquier actualización de rama de una PR abierta".
+
+Ambos enfoques logran el mismo efecto: cualquier push en cualquier pull request abierto hace que se reconstruya el entorno de prueba combinado.
+
+### Trabajo 1: fusión de Octopus
+
+Este trabajo se encarga de detectar todos los pull requests abiertos en ese momento, fusionarlos y publicar el resultado en una rama desechable.
+
+**Qué hace, paso a paso:**
+
+1. **Autenticarse y consultar los pull requests.** El trabajo invoca la API REST de la plataforma de control de código fuente para listar los pull requests abiertos dirigidos a `main`, autenticándose con un token con permiso para listar pull requests (incluidos los borradores; el filtrado ocurre después, no a nivel de la API).
+2. **Filtrar los pull requests no borrador.** Se excluyen los pull requests en borrador; así, los desarrolladores pueden hacer push de commits de trabajo en curso sin incorporarlos a la compilación de prueba compartida. Una PR solo entra en la fusión cuando se marca como lista para revisión.
+3. **Clonar el repositorio desde cero.** En lugar de reutilizar un checkout anterior, el trabajo clona el repositorio desde cero en cada ejecución y se autentica con el propio token de acceso del pipeline. Esto garantiza que la fusión siempre parta de un estado limpio y conocido.
+4. **Eliminar y recrear la rama desechable.** Tanto la copia remota como la local de la rama de salida desechable (por ejemplo, `octopus/temp`) se eliminan de forma forzada si existen y luego se recrean desde `main`. La rama nunca se actualiza mediante fast-forward ni se reutiliza entre ejecuciones; siempre se reconstruye desde cero.
+5. **Fusiona todas las ramas de los pull requests que cumplan los requisitos con un solo comando.** Al pasar más de dos ramas a `git merge`, Git invoca automáticamente su estrategia nativa de fusión octopus — aquí es donde el patrón usa el mecanismo subyacente de Git descrito anteriormente.
+6. **Haz push del resultado** si la fusión se completó correctamente.
+
+**Azure Pipelines**, invocando la API REST de Azure DevOps:
+
+```yaml
+- task: PowerShell@2
+  displayName: Git octopus merge
+  inputs:
+    targetType: 'inline'
+    script: |
+      $prs = Invoke-RestMethod -Uri "https://dev.azure.com/$(Org)/$(Project)/_apis/git/repositories/$(Repo)/pullrequests?api-version=7.0" `
+        -Headers @{ Authorization = "Bearer $(System.AccessToken)" }
+      $branches = $prs.value | Where-Object { $_.isDraft -eq $false -and $_.targetRefName -eq "refs/heads/main" } |
+        ForEach-Object { $_.sourceRefName -replace 'refs/heads', 'origin' }
+
+      git clone $(Build.Repository.Uri) repo --quiet
+      cd repo
+      git checkout main --quiet
+      git push origin --delete octopus/temp --quiet 2>$null
+      git checkout -b octopus/temp --quiet
+      if ($branches.Count -gt 0) {
+        git merge --quiet $branches
+      }
+      git push --set-upstream origin octopus/temp --quiet
+```
+
+**GitHub Actions**, invocando la API REST de GitHub mediante la CLI `gh`:
+
+```yaml
+- name: Git octopus merge
+  env:
+    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  run: |
+    branches=$(gh pr list --base main --state open --json isDraft,headRefName \
+      --jq '.[] | select(.isDraft == false) | .headRefName')
+
+    git clone "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY" repo --quiet
+    cd repo
+    git checkout main --quiet
+    git push origin --delete octopus/temp --quiet || true
+    git checkout -b octopus/temp --quiet
+    if [ -n "$branches" ]; then
+      git merge --quiet $(echo "$branches" | sed 's/^/origin\//')
+    fi
+    git push --set-upstream origin octopus/temp --quiet
+```
+
+Ambas versiones hacen lo mismo: enumeran las PR abiertas que no están en borrador y que apuntan a `main`, las resuelven a referencias de rama y las fusionan en una rama `octopus/temp` recién recreada.
+
+**Cómo gestionar una fusión fallida:**
+
+Si la fusión falla —muy probablemente por un conflicto entre dos o más de las pull requests abiertas—, no te limites a registrar un error y detenerte. Una implementación correcta debería restablecer el directorio de trabajo y hacer push de un **commit vacío de marcador de posición** a la rama desechable antes de marcar como fallida la ejecución del pipeline:
+
+```
+git reset --hard --quiet
+git checkout main --quiet
+git branch -D octopus/temp --quiet
+git checkout -b octopus/temp --quiet
+git config user.email "octopus-merge@users.noreply.github.com"
+git config user.name "Octopus Merge"
+git commit --allow-empty -m "init" --quiet
+git push origin octopus/temp --quiet
+```
+
+Esto importa porque los trabajos posteriores (verificación de BPA, validación de esquema, despliegue) pueden depender de que la rama desechable exista en _algún_ estado bien definido. Sin este paso, una fusión fallida podría dejar la rama ausente o fusionada a medias, y provocar errores secundarios confusos en trabajos posteriores en lugar de un único error claro en el paso de fusión.
+
+##### Nota: cómo diagnosticar qué rama causó el conflicto
+
+Una implementación sencilla de este patrón no identifica automáticamente qué pull request causó un conflicto de fusión; solo genera un **Report** indicando que la fusión falló. Es una limitación real frente a la herramienta archivada `lesfurets/git-octopus`, que incluía utilidades para iterar por las ramas una a una hasta aislar a la culpable. En la práctica, la mayoría de los equipos lo resuelven manualmente: dejan de publicar temporalmente las pull requests que sospechan (las vuelven a marcar como borrador o las cierran) y vuelven a ejecutar el pipeline hasta que la fusión vuelva a completarse correctamente, para acotar qué rama era la responsable. Si este proceso de prueba y error se convierte en un cuello de botella para tu equipo, merece la pena añadir a tu pipeline un paso automatizado de bisección, rama por rama.
+
+### Trabajo 2: Descargar Tabular Editor
+
+Como los trabajos siguientes necesitan invocar la CLI de Tabular Editor, y no puede darse por hecho que los agentes de compilación la tengan preinstalada, un trabajo independiente descarga una copia portátil de Tabular Editor al inicio de cada ejecución:
+
+- Obtiene directamente la versión más reciente (por ejemplo, desde la página de lanzamientos de GitHub de Tabular Editor).
+- La descomprime y descarta el archivo descargado.
+- Deja el `TabularEditor.exe` extraído disponible para los trabajos posteriores en el mismo agente/runner.
+
+Descargar siempre la versión más reciente en cada ejecución mantiene el pipeline actualizado automáticamente, sin tener que hacer seguimiento ni actualizar un número de versión fijo; aun así, si tu equipo quiere compilaciones deterministas y reproducibles, conviene considerar como alternativa fijar una versión concreta y actualizarla de forma deliberada.
+
+### Trabajo 3: Verificación de BPA
+
+Este trabajo ejecuta el [Best Practices Analyzer](xref:best-practice-analyzer) de Tabular Editor sobre cada modelo semántico generado por la fusión y lo valida frente a las reglas de calidad centrales de tu equipo.
+
+Si tu repositorio contiene más de un modelo semántico —algo habitual en equipos de BI que dan servicio a varias áreas de negocio—, cada modelo suele estar en su propia subcarpeta, y el trabajo recorre cada uno de ellos:
+
+```
+TabularEditor.exe "<path-to-model>" -A "<path-to-BPARules.json>" -V
+```
+
+- `-A` indica a Tabular Editor qué archivo de reglas de BPA debe usar para la comprobación.
+- `-V` verifica el modelo e informa del resultado en un Report.
+
+> [!NOTE]
+> Decide desde el principio si una infracción de BPA debe **hacer fallar** la canalización o solo **emitir una advertencia**. Es tentador empezar con advertencias mientras aún ajustas el conjunto de reglas, pero si eso se deja así a largo plazo, las infracciones pueden acumularse silenciosamente sin llegar nunca a bloquear una implementación. Trata un paso de BPA que solo emite advertencias como un estado temporal del que hay que salir, no como una configuración permanente.
+
+### Trabajo 4: Validación del esquema
+
+Este trabajo compara el esquema esperado de cada modelo con su Data source real y en vivo para detectar, por ejemplo, una columna renombrada o ausente antes de que provoque un error de actualización en el entorno de prueba.
+
+```
+TabularEditor.exe "<path-to-model>" -S "<path-to-connection-script>.cs" -SC -V -W
+```
+
+- `-S` ejecuta un C# Script que establece la cadena de conexión de la Data source del modelo; normalmente la lee de una variable de entorno o de un secreto de la canalización, para que nunca sea necesario confirmar los detalles reales de la conexión en el control de código fuente.
+- `-SC` realiza la comprobación del esquema, comparando los metadatos del modelo con el origen activo.
+- `-V -W` verifican el resultado y controlan cómo se tratan las advertencias.
+
+Si tus modelos dependen de objetos de base de datos que también se implementan como parte de tu canalización —por ejemplo, vistas SQL publicadas desde el control de código fuente—, asegúrate de que ese paso de implementación se ejecute _antes_ de la validación de esquema, para que la comprobación se haga contra exactamente los objetos que verá el modelo una vez que todo se haya implementado en el entorno de prueba. Es fácil pasar por alto esta dependencia de orden si ambos trabajos se escriben de forma independiente.
+
+> [!NOTE]
+> El mecanismo específico para implementar objetos de datos previos (vistas SQL y otros artefactos de base de datos) dependerá de la plataforma de datos de tu organización y no forma parte del patrón Octopus Merge en sí. Lo único que importa para este patrón es que la validación de esquema se realice después de que tu Data source esté en el estado esperado para el entorno de prueba; cómo se llega a ese estado depende de ti.
+
+### Trabajo 5: Implementación del modelo
+
+Una vez que la verificación de BPA y la validación de esquema se han completado correctamente, este trabajo implementa el modelo combinado en el Workspace de prueba compartido mediante el formato Guardar en carpeta (`Database.json`) de Tabular Editor, y lo despliega directamente a través del punto de conexión XMLA:
+
+```
+TabularEditor.exe "<path-to-model>\database.json" -D "Provider=MSOLAP;Data Source=<XMLA-endpoint>;User ID=app:<app-id>@<tenant-id>;Password=<app-secret>;LocaleIdentifier=1033" "<model-name>" -O -P -R -W -V -E
+```
+
+Algunos puntos que conviene destacar:
+
+- La autenticación se realiza mediante una **entidad de servicio** (un registro de aplicación de Azure AD), no con una cuenta de usuario; es lo adecuado para una canalización desatendida y evita tener que guardar las credenciales de un usuario real en los secretos de la canalización.
+- El nombre del modelo que se pasa a Tabular Editor normalmente coincide con el nombre de la carpeta, de modo que un repositorio que contiene varios modelos implementa cada uno en un Dataset con el nombre correspondiente.
+- Las opciones `-O -P -R -W -V -E` cubren sobrescritura, procesamiento, roles, advertencias, verificación y gestión de errores; consulta la [referencia de la CLI de Tabular Editor](xref:command-line-options) para ver la lista completa de opciones si necesitas ajustar alguna de ellas para tu propia configuración.
+
+> [!NOTE]
+> Los revisores de negocio que dan su visto bueno en el entorno de prueba compartido están validando un Report, no una conexión XMLA directa; en la práctica, aún hace falta que algún paso implemente y vincule los informes de Power BI al modelo de prueba recién implementado (y, opcionalmente, actualice cualquier App de Power BI publicada) antes de que ese visto bueno pueda darse. Que se vuelva a implementar cada Report en cada ejecución, o solo los que se vean afectados por los cambios actuales, es el tipo de decisión que varía lo suficiente según la organización como para quedar fuera del alcance de este patrón; consulta @powerbi-cicd para esa parte de la canalización.
+
+### Diagrama completo del flujo de trabajo
+
+```mermaid
+flowchart TB
+    subgraph dev["Developer"]
+        direction LR
+        d1["Create feature branch"] --> d2["Local commits"] --> d3["Open PR<br/>(ready for review)"]
+    end
+
+    subgraph ci["CI Pipeline"]
+        direction LR
+        c1["Octopus merge"] -->|"success"| c2["Download Tabular Editor"]
+        c1 -.->|"conflict"| c1f["Empty placeholder commit"]
+        c2 --> c3["BPA verification"]
+        c2 --> c4["Schema validation"]
+        c3 --> c5["Model deployment"]
+        c4 --> c5
+    end
+
+    subgraph review["Review"]
+        direction LR
+        r1["Technical sign-off"] --> r2["Business sign-off"]
+    end
+
+    subgraph release["Release"]
+        direction LR
+        rel1["Merge to main"] --> rel2["Deploy to UAT / production"]
+    end
+
+    d3 --> c1
+    c5 --> r1
+    r2 --> rel1
+    c1f -.->|"developer resolves conflict, pushes fix"| d2
+    r1 -.->|"changes requested, developer pushes fix"| d2
+```
+
+## Principios clave
+
+- `main` siempre está lista para desplegarse; las ramas de características son de corta duración e independientes.
+- La rama desechable se elimina y se recrea a partir de `main` en cada ejecución; nunca se hace un fast-forward ni se reutiliza.
+- Una fusión fallida debería dejar la rama descartable en un estado bien definido (aunque quede vacía), y no en un estado inexistente o a medio fusionar.
+- Cada etapa de validación (BPA, esquema) debería ser un trabajo independiente en el pipeline, con su propio indicador de éxito o fallo, en lugar de integrarse en un único script.
+- Los pasos específicos de la organización (como el despliegue de vistas SQL) deben estar claramente separados del patrón genérico, tanto en el código del pipeline como en la documentación interna, para que el patrón siga siendo portable si necesitas aplicarlo a otro proyecto.
+
+## Siguientes pasos
+
+- [Habilitar el desarrollo en paralelo con Git y Guardar en carpeta](xref:parallel-development) — la estrategia de ramificación que admite este pipeline.
+- [Integración de CI/CD](xref:te-cli-cicd) — los patrones de CI/CD de la nueva CLI de Tabular Editor, actualmente en vista previa pública limitada.
+- @powerbi-cicd
+- @as-cicd
diff --git a/localizedContent/es/content/getting-started/parallel-development.md b/localizedContent/es/content/getting-started/parallel-development.md
index 746e4a895..b29053811 100644
--- a/localizedContent/es/content/getting-started/parallel-development.md
+++ b/localizedContent/es/content/getting-started/parallel-development.md
@@ -2,7 +2,7 @@
 uid: parallel-development
 title: Habilitar el desarrollo en paralelo con Git y Guardar en carpeta
 author: Daniel Otykier
-updated: 2026-06-11
+updated: 2026-07-03
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -127,66 +127,131 @@ A continuación, se analiza qué estrategias de ramificación conviene usar al d
 
 La estrategia de ramificación determinará cómo será el flujo de trabajo diario de desarrollo y, en muchos casos, las ramas se alinearán directamente con las metodologías que utilice tu equipo. Por ejemplo, al usar el [proceso ágil en Azure DevOps](https://docs.microsoft.com/en-us/azure/devops/boards/work-items/guidance/agile-process-workflow?view=azure-devops), tu backlog constaría de **Épicas**, **Características**, **Historias de usuario**, **Tareas** y **Defectos**.
 
-En la terminología ágil, una **Historia de usuario** es una unidad de trabajo entregable y comprobable. La Historia de usuario puede constar de varias **Tareas**, que son unidades de trabajo más pequeñas que deben realizarse, normalmente por un desarrollador, antes de que la Historia de usuario pueda entregarse. En un mundo ideal, todas las Historias de usuario se desglosan en tareas manejables, cada una de las cuales requiere solo un par de horas para completarse, sumando como mucho unos pocos días para toda la Historia de usuario. Esto haría que una Historia de usuario fuera una candidata ideal para lo que se conoce como una rama temática, en la que el desarrollador podría hacer uno o varios commits por cada una de las tareas dentro de la Historia de usuario. Una vez que se han completado todas las tareas, querrás entregar la Historia de usuario al cliente. En ese momento, la rama temática se fusiona en una rama de entrega (por ejemplo, una rama "Test") y el código se despliega en un entorno de pruebas.
+En la terminología ágil, una **Historia de usuario** es una unidad de trabajo entregable y comprobable. Una historia de usuario puede constar de varias **tareas** —unidades de trabajo más pequeñas que un desarrollador realiza antes de poder entregar la historia de usuario. En un mundo ideal, todas las historias de usuario se desglosan en tareas manejables; cada una requiere solo un par de horas para completarse y, en total, no suman más que unos pocos días para toda la historia de usuario. Esto convierte a una historia de usuario en una candidata ideal para una rama de funcionalidad de corta duración, donde el desarrollador hace uno o varios commits por tarea antes de fusionar la rama y desplegar el código para su prueba.
 
-Determinar una estrategia de ramificación adecuada depende de muchos factores. En general, Microsoft recomienda la estrategia [Trunk-based Development](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops) ([vídeo](https://youtu.be/t_4lLR6F_yk?t=232)) para la entrega ágil y continua de incrementos pequeños. La idea principal es crear ramas a partir de la rama "Main" para cada nueva funcionalidad o corrección de errores (consulta la imagen a continuación). Los procesos de revisión de código se aplican mediante pull requests desde las ramas de características hacia "Main" y, mediante la característica Branch Policy de Azure DevOps, podemos configurar reglas que exijan que el código se compile sin errores antes de poder completar un pull request.
+Determinar una estrategia de ramificación adecuada depende de muchos factores: el tamaño del equipo, la cadencia de lanzamientos, las restricciones regulatorias, cuántos modelos semánticos mantienes y lo madura que sea ya tu configuración de CI/CD. Este artículo presenta tres estrategias:
 
-![Trunk Based Development](~/content/assets/images/trunk-based-development.png)
+- **[GitHub Flow + Octopus Merge](#github-flow--octopus-merge)** — nuestro enfoque recomendado para la mayoría de los equipos de modelos semánticos y el tema principal de este artículo.
+- **[GitFlow](#gitflow-branching-and-deployment-environments)** — una alternativa válida, especialmente adecuada para equipos con ciclos de lanzamiento formales y poco frecuentes o con requisitos de aprobación regulatoria.
+- **[Desarrollo basado en trunk puro](#trunk-based-development)** — el enfoque más simple. Conviene entenderlo como referencia, aunque la mayoría de los equipos de BI querrán la estructura adicional que ofrece GitHub Flow.
+
+> [!NOTE]
+> Tabular Editor es independiente de la estrategia de ramificación. Guardar en carpeta y el modo del área de trabajo funcionan igual, elijas la estrategia que elijas a continuación; la recomendación de este artículo se basa en patrones que hemos visto funcionar en implementaciones empresariales, no en una limitación impuesta por la herramienta.
+
+## GitHub Flow + Octopus Merge
+
+Para los equipos que crean modelos semánticos con Tabular Editor y Power BI, recomendamos **[GitHub Flow](https://docs.github.com/en/get-started/using-github/github-flow)** combinado con un patrón de **Octopus Merge** para las pruebas de integración continua.
+
+GitHub Flow es un modelo de ramificación ligero con una única regla innegociable: **`main` siempre se puede desplegar.** Todo el trabajo se realiza en una rama de funcionalidad de corta duración creada a partir de `main`; nadie hace commits directamente en `main`; las ramas se fusionan de nuevo mediante una pull request tras la revisión y cuando las comprobaciones automatizadas hayan pasado. A diferencia de GitFlow, no hay una rama `develop` ni una rama independiente por entorno: la promoción entre entornos (dev → test → UAT → producción) la gestiona el pipeline de despliegue, no las ramas de larga duración.
+
+```mermaid
+gitGraph
+    commit id: "inicial"
+    branch "feature/add-tax-calculation"
+    commit id: "agregar medida"
+    commit id: "agregar columna"
+    checkout main
+    merge "feature/add-tax-calculation" id: "PR fusionada: cálculo de impuestos"
+    branch "feature/fix-rls"
+    commit id: "corregir rol"
+    checkout main
+    merge "feature/fix-rls" id: "PR fusionada: corregir RLS"
+    branch "feature/new-report-page"
+    commit id: "wip"
+    checkout main
+    commit id: "hotfix"
+    merge "feature/new-report-page" id: "PR fusionada: nueva página del Report"
+```
 
-### Trunk-based Development
+`main` se mantiene en una sola línea y siempre se puede desplegar; las ramas de funcionalidad de corta duración parten de ella y se fusionan de nuevo directamente mediante una pull request. Contrástalo con el diagrama de GitFlow más abajo en la página, que tiene cinco líneas paralelas de larga duración.
 
-Sin embargo, este tipo de estrategia puede no ser viable para equipos de desarrollo de Business Intelligence, por varias razones:
+Por sí solo, GitHub Flow no responde a una pregunta específica de los equipos de BI: cuando varios desarrolladores tienen cada uno una pull request abierta, ¿qué refleja tu entorno de prueba compartido en cada momento? **Octopus Merge** responde a esto: un pipeline de CI fusiona continuamente todas las pull requests abiertas en ese momento en una rama desechable y despliega el resultado en un entorno de prueba compartido, de modo que los usuarios de negocio siempre validan la combinación de todo lo que está en curso, no solo una funcionalidad aislada. Consulta [GitHub Flow y el patrón Octopus Merge](xref:github-flow) para ver cómo funciona el patrón y cómo implementarlo.
 
-- Las nuevas características suelen requerir pruebas y validación prolongadas por parte de los usuarios de negocio, lo que puede tardar varias semanas en completarse. Por lo tanto, probablemente necesitarás un entorno de pruebas orientado al usuario.
-- Las soluciones de BI son de varios niveles y, por lo general, constan de una capa de Data Warehouse con ETL, una capa de Master Data Management, una capa semántica y Report. Existen dependencias entre estas capas, lo que complica aún más las pruebas y el despliegue.
-- El equipo de BI puede ser responsable de desarrollar y mantener varios modelos semánticos diferentes, que dan servicio a distintas áreas del negocio (Ventas, Inventario, Logística, Finanzas, RR.
-- ¡El aspecto más importante de una solución de BI son los datos! Como desarrollador de BI, no tienes el lujo de limitarte a extraer el código del control de versiones, pulsar F5 y tener una solución completa en funcionamiento en los pocos minutos que se tarda en compilarlo. Tu solución necesita datos, y esos datos deben cargarse, pasar por un proceso de ETL o procesarse a través de varias capas hasta llegar al usuario final. Incluir los datos en tus flujos de trabajo de DevOps podría disparar los tiempos de compilación y despliegue de minutos a horas, o incluso a días. En algunos escenarios, puede que ni siquiera sea posible, debido a limitaciones de recursos o de presupuesto.
+Algunas razones por las que esta combinación encaja especialmente bien con el desarrollo de modelos semánticos:
 
-No cabe duda de que un equipo de BI se beneficiaría de una estrategia de ramificación que admita el desarrollo en paralelo en cualquiera de las capas de la solución completa de BI, de modo que pueda mezclar y combinar las funcionalidades que estén listas para probar. Pero, especialmente por el último punto de la lista anterior, tenemos que pensar bien cómo vamos a manejar los datos. Por ejemplo, si añadimos un nuevo atributo a una dimensión, ¿queremos que la dimensión se cargue automáticamente como parte de nuestras canalizaciones de compilación y despliegue? Si cargar una dimensión así solo lleva unos minutos, probablemente no haya problema; pero ¿qué pasa si estamos añadiendo una nueva columna a una tabla de hechos con miles de millones de filas? Y si los desarrolladores trabajan en nuevas funcionalidades en paralelo, ¿debería cada desarrollador tener su propia base de datos de desarrollo o cómo evitamos, si no, que se pisen entre sí en una base de datos compartida?
+- **Modelo mental más simple.** Tener dos conceptos de rama en lugar de los cinco de GitFlow reduce la carga de incorporación, especialmente en equipos que incluyen autores de Reports y analistas de negocio junto con desarrolladores de modelos.
+- **`main` siempre se puede desplegar.** Si necesitas publicar una corrección urgente —una medida rota, un cambio de RLS relacionado con la seguridad—, no tienes que averiguar cuál de varias ramas de larga duración refleja la producción en ese momento.
+- **La promoción entre entornos se gestiona en el pipeline, no en la estructura de ramas.** Agregar un nuevo entorno es un cambio en el pipeline, no una nueva rama permanente en la que cada desarrollador tenga que recordar fusionar sus cambios.
+- **Las ramas de corta duración reducen los conflictos de fusión** — algo importante para Octopus Merge, ya que fusiona todas las ramas abiertas a la vez para las pruebas de integración. Cuanto menos tiempo dure cada rama, menor será la superficie expuesta a conflictos.
+- **Encaja mejor con la entrega continua de productos de datos** que el modelo de "release train" versionado de GitFlow, ya que los modelos semánticos tienden a evolucionar de forma incremental en lugar de lanzarse en entregas discretas.
 
-No hay una respuesta fácil a las preguntas anteriores, especialmente si se tienen en cuenta todos los niveles de una solución de BI y las distintas combinaciones y flujos de trabajo preferidos por los equipos de BI de todo el mundo. Además, cuando entremos en la automatización real de compilación, despliegue y pruebas, nos centraremos principalmente en Analysis Services. Las capas de ETL y de base de datos tienen sus propios retos desde una perspectiva de DevOps, que quedan fuera del alcance de este artículo. Pero antes de continuar, veamos otra estrategia de ramificación y cómo podría adoptarse en los flujos de trabajo de BI.
+Nada de esto significa que GitFlow sea incorrecto — consulta [ramificación de GitFlow y entornos de implementación](#gitflow-branching-and-deployment-environments) más abajo para ver cuándo sigue siendo una buena opción.
 
-### Ramificación de GitFlow y entornos de despliegue
+### Principios clave
+
+- `main` siempre está listo para desplegarse.
+- Las ramas de funcionalidad son de vida corta e independientes.
+- El entorno de pruebas siempre refleja la combinación de todo lo que está actualmente en curso, no solo una funcionalidad aislada. Consulta [GitHub Flow y el patrón Octopus Merge](xref:github-flow) para ver cómo hacerlo.
+- La integración de Git de Fabric **no** debe habilitarse en ningún Workspace que se use para las bases de datos de Workspace de Tabular Editor — Tabular Editor escribe directamente en las bases de datos de Workspace a través del punto de conexión XMLA, y esas escrituras no guardan relación con tus ramas en Git. Esto también se menciona en la [documentación del modo del área de trabajo](xref:workspace-mode).
+
+## Ramificación de GitFlow y entornos de despliegue
+
+GitFlow sigue siendo una opción sólida para equipos con una necesidad real de la estructura que aporta; por ejemplo, lanzamientos formales versionados, puertas de aprobación regulatoria vinculadas a ramas específicas o ciclos de lanzamiento poco frecuentes (p. ej., mensuales o trimestrales) en los que una rama `develop` persistente y las ramas de lanzamiento encajan de forma natural con tu proceso. Si eso describe a tu equipo, merece mucho la pena usar el enfoque que se presenta a continuación.
 
 La estrategia descrita a continuación se basa en [GitFlow de Vincent Driessen](https://nvie.com/posts/a-successful-git-branching-model/).
 
 ![Gitflow](~/content/assets/images/gitflow.png)
 
-Implementar una estrategia de ramificación como esta puede ayudar a resolver algunos de los problemas de DevOps habituales en equipos de BI, siempre que dediques algo de tiempo a definir cómo se correlacionan las ramas con tus entornos de despliegue. En un mundo ideal, necesitarías al menos 4 entornos distintos para dar soporte completo a GitFlow:
+Implementar una estrategia de ramificación similar a esta puede ayudar a resolver algunos de los problemas de DevOps habituales en equipos de BI, siempre que dediques algo de tiempo a definir cómo se correlacionan las ramas con tus entornos de despliegue. En un mundo ideal, necesitarías al menos 4 entornos distintos para dar soporte completo a GitFlow:
 
 - El entorno de **producción**, que siempre debería contener el código del HEAD de la rama master.
 - Un entorno **canary**, que siempre debería contener el código del HEAD de la rama develop. Aquí es donde normalmente programas despliegues nocturnos y ejecutas las pruebas de integración para asegurarte de que las funcionalidades que entrarán en la próxima versión para producción funcionen bien juntas.
 - Uno o varios entornos de **UAT** donde tú y los usuarios de negocio probáis y validáis nuevas funcionalidades. El despliegue se hace directamente desde la rama de funcionalidad que contiene el código que debe probarse. Necesitarás varios entornos de prueba si quieres probar varias funcionalidades nuevas en paralelo. Con un poco de coordinación, suele bastar con un único entorno de pruebas, siempre que consideres cuidadosamente las dependencias entre tus capas de BI.
 - Uno o varios entornos **sandbox** en los que tú y tu equipo pueden desarrollar nuevas funcionalidades sin afectar a ninguno de los entornos anteriores. Al igual que con el entorno de pruebas, normalmente basta con tener un único entorno sandbox compartido.
 
-Tenemos que recalcar que, en realidad, no existe una solución que sirva para todo. Quizá no estés construyendo tu solución en la nube y, por tanto, no tengas la escalabilidad o flexibilidad para aprovisionar nuevos recursos en segundos o minutos. O quizá tus volúmenes de datos sean muy grandes, lo que hace poco práctico replicar entornos por limitaciones de recursos, coste o tiempo. Antes de continuar, asegúrate también de preguntarte si de verdad necesitas dar soporte al desarrollo y las pruebas en paralelo. Esto rara vez se da en equipos pequeños con pocas partes interesadas; en ese caso, aún puedes beneficiarte de CI/CD, pero la estrategia de ramificación GitFlow puede ser excesiva.
+Tenemos que recalcar que, en realidad, no existe una solución que sirva para todo. Quizá no estés construyendo tu solución en la nube y, por tanto, no tengas la escalabilidad o flexibilidad para aprovisionar nuevos recursos en segundos o minutos. O quizá tus volúmenes de datos sean muy grandes, lo que hace poco práctico replicar entornos por limitaciones de recursos, coste o tiempo.
+
+Aunque necesites dar soporte al desarrollo en paralelo, es posible que varios desarrolladores compartan sin problema el mismo entorno de desarrollo o sandbox, sin demasiadas complicaciones. En particular, para modelos tabulares, recomendamos que los desarrolladores sigan usando [bases de datos de Workspace](xref:workspace-mode) individuales para evitar "pisarse el trabajo" entre ellos.
+
+> [!NOTE]
+> Si estás evaluando GitFlow principalmente porque necesitas un entorno de pruebas compartido y siempre actualizado que refleje el trabajo en curso, plantéate si [GitHub Flow + Octopus Merge](#github-flow--octopus-merge) podría darte el mismo resultado con menos sobrecarga de gestión de ramas. La rama `develop`/canary de GitFlow y la rama de pruebas desechable de Octopus Merge resuelven un problema parecido de formas distintas.
+
+## Desarrollo basado en trunk
+
+El desarrollo basado en trunk es el modelo de ramificación más simple posible: los desarrolladores hacen commits de cambios pequeños y frecuentes directamente en `main`, o mediante ramas de funcionalidad de vida muy corta que se fusionan de nuevo en cuestión de horas. En general, Microsoft recomienda [Trunk-based Development](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops) ([vídeo](https://youtu.be/t_4lLR6F_yk?t=232)) para la entrega ágil y continua de incrementos pequeños.
+
+![Trunk Based Development](~/content/assets/images/trunk-based-development.png)
 
-Aunque necesites dar soporte al desarrollo en paralelo, es posible que varios desarrolladores compartan sin problema el mismo entorno de desarrollo o sandbox, sin demasiadas complicaciones. En particular, para modelos tabulares, recomendamos que los desarrolladores sigan usando [bases de datos de Workspace](xref:workspace-mode) individuales para evitar "pisarse" entre ellos.
+En su forma más pura, el desarrollo basado en trunk puede generar fricciones reales en equipos de BI:
+
+- Las nuevas funcionalidades suelen requerir pruebas y validación prolongadas por parte de los usuarios de negocio, lo que puede llevar varias semanas; por eso necesitas algún lugar donde validar el trabajo en curso que no sea `main`.
+- Las soluciones de BI son multicapa (Warehouse/ETL, Master Data Management, capa semántica, Reports), con dependencias entre capas que complican las pruebas y el despliegue.
+- Un equipo de BI puede mantener varios modelos semánticos en distintas etapas de madurez y con ritmos diferentes.
+- Hay que cargar, pasar por ETL y procesar los datos — no solo el código — para que un cambio se pueda probar. Incluir actualizaciones completas de datos en cada compilación podría hacer que los tiempos de ejecución de la canalización pasen de minutos a horas y, en tablas de hechos muy grandes, a veces ni siquiera es viable.
+
+**GitHub Flow + Octopus Merge, como se ha descrito arriba, se entiende mejor como un refinamiento de trunk-based development que aborda directamente estas preocupaciones** — en lugar de una desviación de este enfoque. Mantiene la simplicidad fundamental de trunk-based development (una única rama de larga duración, ramas de características de corta duración, sin release trains) y añade justo la pieza que les falta a los equipos de BI: un entorno de pruebas compartido, poblado por la canalización en lugar de por una rama de larga duración, que siempre refleja el estado combinado actual del trabajo en curso. Si estás eligiendo entre las tres estrategias de esta página, por lo general recomendaríamos GitHub Flow + Octopus Merge a un equipo al que le gusta la simplicidad de trunk-based development, pero que se ha topado con las limitaciones anteriores.
 
 ## Flujo de trabajo habitual
 
-Suponiendo que ya tienes un repositorio Git configurado y alineado con tu estrategia de ramificación, añadir el "código fuente" de tu modelo tabular al repositorio consiste simplemente en usar Tabular Editor para guardar los metadatos en una nueva rama de un repositorio local. Luego, preparas y haces commit de los nuevos archivos, haces push de tu rama al repositorio remoto y creas un pull request para fusionar tu rama en la rama principal.
+Suponiendo que ya tienes un repositorio Git configurado y alineado con tu estrategia de ramificación, añadir el "código fuente" de tu modelo tabular al repositorio consiste simplemente en usar Tabular Editor para guardar los metadatos en una nueva rama de un repositorio local. Luego, preparas y haces commit de los nuevos archivos, haces push de tu rama al repositorio remoto y creas un pull request para que tu rama se fusione con la rama principal.
+
+Los comandos exactos son los mismos independientemente de la estrategia anterior que elijas; lo que cambia es lo que ocurre _después_ de abrir el pull request (consulta [GitHub Flow y el patrón Octopus Merge](xref:github-flow) para el caso de GitHub Flow, o tu proceso de release/canary para GitFlow). En general, el flujo de trabajo es así:
 
-El flujo de trabajo exacto depende de tu estrategia de ramificación y de cómo se hayan configurado tus repositorios Git. En general, el flujo de trabajo sería algo así:
+1. Antes de empezar a trabajar en una nueva funcionalidad, crea una nueva rama de características en Git:
 
-1. Antes de empezar a trabajar en una nueva funcionalidad, crea una nueva rama de funcionalidad en git. En un escenario de desarrollo basado en trunk, necesitarías los siguientes comandos de Git para hacer checkout de la rama principal, obtener la última versión del código y crear desde ahí la rama de funcionalidad:
    ```cmd
    git checkout main
    git pull
-   git checkout -b "feature\AddTaxCalculation"
+   git checkout -b feature/add-tax-calculation
    ```
+
 2. Abre los metadatos de tu modelo desde el repositorio git local en Tabular Editor. Idealmente, usa una [base de datos de Workspace](xref:workspace-mode) para facilitar las pruebas y la depuración del código DAX.
+
 3. Realiza los cambios necesarios en tu modelo usando Tabular Editor. Guarda los cambios de forma continua (CTRL+S). Haz commit de los cambios de código en git con regularidad después de guardar, para evitar perder trabajo y mantener un historial completo de todos los cambios realizados:
+
    ```cmd
    git add .
    git commit -m "Description of what was changed and why since last commit"
    git push
    ```
+
 4. Si no usas una base de datos de Workspace, utiliza la opción **Model > Deploy...** de Tabular Editor para desplegar en un entorno sandbox o de desarrollo, y así probar los cambios realizados en los metadatos del modelo.
+
 5. Cuando hayas terminado y todo el código se haya confirmado y enviado al repositorio remoto, envía una solicitud de incorporación de cambios para que tu código quede integrado con la rama principal. Si se produce un conflicto de fusión, tendrás que resolverlo localmente; por ejemplo, con Visual Studio Team Explorer o simplemente abriendo los archivos .json en un editor de texto para resolver los conflictos (Git inserta marcadores de conflicto para indicar qué partes del código tienen conflictos).
-6. Una vez resueltos todos los conflictos, puede haber un proceso de revisión de código, la ejecución automatizada de compilaciones y pruebas basada en las políticas de rama, etc., para completar la solicitud de incorporación de cambios. Sin embargo, esto depende de tu estrategia de ramificación y de la configuración general.
 
-En los siguientes artículos presentamos más detalles sobre cómo configurar las políticas de rama de Git, configurar canalizaciones automatizadas de compilación e implementación, etc., con Azure DevOps. Se pueden usar técnicas similares en otros entornos de compilación automatizada y de alojamiento de Git, como TeamCity, GitHub, etc.
+6. Una vez resueltos todos los conflictos, puede haber un proceso de revisión de código y de ejecución automatizada de compilaciones y pruebas —incluido, si usas el enfoque de GitHub Flow anterior, el despliegue de pruebas de Octopus Merge— antes de que se pueda completar el pull request.
+
+En los siguientes artículos ofrecemos más detalles sobre cómo configurar las políticas de rama de Git, establecer canalizaciones automatizadas de compilación y despliegue, etc., con Azure DevOps y GitHub Actions. Se pueden usar técnicas similares en otros entornos de compilación automatizada y de alojamiento de Git, como TeamCity, GitLab, etc.
 
 ## Siguientes pasos
 
diff --git a/localizedContent/es/content/references/downloads.md b/localizedContent/es/content/references/downloads.md
index 75a840d20..370d0abce 100644
--- a/localizedContent/es/content/references/downloads.md
+++ b/localizedContent/es/content/references/downloads.md
@@ -2,7 +2,7 @@
 uid: downloads
 title: Todas las descargas
 author: Daniel Otykier
-updated: 2026-04-17
+updated: 2026-07-10
 ---
 
 # Descargas de Tabular Editor 3
@@ -11,14 +11,14 @@ Esta página ofrece instrucciones de descarga e instalación para Tabular Editor
 
 ## Última versión
 
-Descargas de Tabular Editor 3.26.1 para **.NET 8**:
+Descargas de Tabular Editor 3.26.3 para **.NET 8**:
 
-- Descargar [Tabular Editor 3.26.1 (64 bits)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.x64.Net8.exe) _(recomendado)_
-- Descargar [Tabular Editor 3.26.1 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.ARM64.Net8.exe)
-- Versiones portátiles: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.zip)
-- Versión MSI: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.msi)
+- Descargar [Tabular Editor 3.26.3 (64 bits)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) _(recomendado)_
+- Descargar [Tabular Editor 3.26.3 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+- Versiones portátiles: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+- Versión MSI: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
 
-Lee las [últimas notas de la versión](release-notes/3_26_1.md).
+Consulta las [notas de la versión más recientes](release-notes/3_26_3.md).
 
 ## Instrucciones de instalación
 
@@ -30,6 +30,14 @@ No es necesario desinstalar versiones anteriores al actualizar a una versión m
 
 ## Historial
 
+- 2026-07-10 **Tabular Editor 3.26.3** (_[Notas de la versión](release-notes/3_26_3.md)_)
+  - .NET 8: instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+  - .NET 8: versión portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+  - .NET 8: instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+- 2026-06-25 **Tabular Editor 3.26.2** (_[Notas de la versión](release-notes/3_26_2.md)_)
+  - .NET 8 instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
+  - .NET 8 portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
+  - .NET 8 instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
 - 2026-04-17 **Tabular Editor 3.26.1** (_[Notas de la versión](release-notes/3_26_1.md)_)
   - Instalador de .NET 8 (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.ARM64.Net8.exe)
   - Versión portátil de .NET 8 (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.zip)
@@ -62,16 +70,5 @@ No es necesario desinstalar versiones anteriores al actualizar a una versión m
   - .NET 8 instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.Installer.x64.Net8.exe), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.Installer.x86.Net8.exe)
   - .NET 8 portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x64.Net8.zip), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x86.Net8.zip)
   - .NET 8 instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x64.Net8.msi), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x86.Net8.msi)
-- 2025-04-25 **Tabular Editor 3.21.0** (_[Notas de la versión](release-notes/3_21_0.md)_)
-  - .NET 8 instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.Installer.x64.Net8.exe), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.Installer.x86.Net8.exe)
-  - .NET 8 portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x64.Net8.zip), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x86.Net8.zip)
-  - .NET 8 instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x64.Net8.msi), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x86.Net8.msi)
-- 2025-04-11 **Tabular Editor 3.20.1** (_[Notas de la versión](release-notes/3_20_1.md)_)
-  - .NET 8 instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x64.Net8.exe), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x86.Net8.exe)
-  - .NET 8 portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.Net8.zip), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.Net8.zip)
-  - .NET 8 instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.Net8.msi), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.Net8.msi)
-  - .NET 6 instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x64.exe), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x86.exe)
-  - .NET 6 portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.zip), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.zip)
-  - .NET 6 instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.msi), [x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.msi)
 
 Para versiones anteriores, consulta el [historial completo de versiones](release-history.md).
\ No newline at end of file
diff --git a/localizedContent/es/content/references/release-history.md b/localizedContent/es/content/references/release-history.md
index b994408c1..341551c61 100644
--- a/localizedContent/es/content/references/release-history.md
+++ b/localizedContent/es/content/references/release-history.md
@@ -5,6 +5,14 @@ title: Historial completo de versiones
 
 # Historial completo de versiones
 
+- 2026-07-10 **Tabular Editor 3.26.3** (_[Notas de la versión](release-notes/3_26_3.md)_)
+  - .NET 8 - instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+  - .NET 8 - versión portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+  - .NET 8 - instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+- 2026-06-25 **Tabular Editor 3.26.2** (_[Notas de la versión](release-notes/3_26_2.md)_)
+  - .NET 8 instalador (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
+  - .NET 8 portátil (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
+  - .NET 8 instalador (.msi): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
 - 2026-04-17 **Tabular Editor 3.26.1** (_[Notas de la versión](release-notes/3_26_1.md)_)
   - Instalador de .NET 8 (.exe): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.ARM64.Net8.exe)
   - Versión portátil de .NET 8 (.zip): [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.zip)
diff --git a/localizedContent/es/content/references/release-notes/3_26_2.md b/localizedContent/es/content/references/release-notes/3_26_2.md
new file mode 100644
index 000000000..e8e557548
--- /dev/null
+++ b/localizedContent/es/content/references/release-notes/3_26_2.md
@@ -0,0 +1,120 @@
+---
+uid: release-3-26-2
+---
+
+# Tabular Editor 3.26.2
+
+# [**Descargas**](#tab/downloads)
+
+Descargas de Tabular Editor 3.26.2:
+
+- Descargar [Tabular Editor 3.26.2 (x64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe) _(recomendado)_
+- Descargar [Tabular Editor 3.26.2 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
+- Versiones portátiles: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
+- Versión MSI: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
+
+_Si aún no has usado Tabular Editor 3, tienes derecho a una prueba de 30 días, que puedes activar después de la instalación. También puedes [comprar una licencia](https://tabulareditor.com/licensing)._
+
+# [**Sumas de comprobación SHA-256**](#tab/checksums)
+
+| Archivo                                                                                                                                                                                                                                            | Entorno de ejecución para «.NET» | Plataforma | SHA-256                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------- | ------------------------------------------------------------------ |
+| [TabularEditor.3.26.2.Installer.x64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe)     | .NET 8                           | x64        | `CDCEEF571902E58E3368F5A60BBF6926C310B34B2CC4ABA2F3D28B9A5C1C98AC` |
+| [TabularEditor.3.26.2.x64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi)                                         | .NET 8                           | x64        | `D3C0FA8184855C57D16D78CD9D2A44A7622E3C67CD07CFDC7B6D0EA59FB30E09` |
+| [TabularEditor.3.26.2.x64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip)                                         | .NET 8                           | x64        | `B4A2B836E6DA359E798D7546934F1A477C2F4C74D653995D77D2F182A57A8725` |
+| [TabularEditor.3.26.2.Installer.ARM64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe) | .NET 8                           | ARM64      | `7CC1E25D51EA665787500DC460BB533F457E26FF7AE5A4B9F44480F980F1998F` |
+| [TabularEditor.3.26.2.ARM64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)                                     | .NET 8                           | ARM64      | `A8A6E324D38E80140B171B5D7F84C5EBADD6AFE2810529504F332091ECF7E682` |
+| [TabularEditor.3.26.2.ARM64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)                                     | .NET 8                           | ARM64      | `B265579D384A6586B7599CBC0A54032C5F477D3A485FC1F773F79D4B31D128C6` |
+
+***
+
+Echa un vistazo a nuestro [blog del lanzamiento](https://tabulareditor.com/blog/tabular-editor-3-june-2026-release) para obtener una breve visión general de las actualizaciones más importantes de este lanzamiento.
+
+## Mejoras en la versión 3.26.2
+
+- Se añadió el submenú contextual de clic derecho **Mover a grupo** para las tablas del Explorador TOM. El submenú muestra los grupos de tablas existentes, una opción **(Nuevo...)** que crea un grupo nuevo con las tablas seleccionadas y abre el editor de nombres, y una opción **(Ninguno)** que quita la asignación del grupo de tablas.
+
+- Se actualizaron los preajustes de modelos en las preferencias del Asistente de IA con las últimas versiones, para que los usuarios puedan elegir modelos actuales sin escribir un ID de modelo personalizado. Se agregaron `claude-fable-5` y `claude-opus-4-8` de Anthropic, y `gpt-5.5`/`gpt-5.5-pro` de OpenAI, junto con otras variantes actuales de GPT-5. Se eliminaron las entradas obsoletas (como las variantes antiguas de Codex) y el modelo predeterminado de OpenAI ahora es `gpt-5.5`.
+
+- **Mejoras del analizador semántico**
+  - Se agregó compatibilidad con parámetros opcionales con expresiones predeterminadas en las UDF de DAX.
+  - El analizador semántico ahora emite mensajes de advertencia o error adecuados cuando se llama a una UDF con un parámetro que no coincide con su tipo declarado (por ejemplo, al pasar un valor escalar a un parámetro `TABLEREF`, etc.)
+  - El analizador semántico ahora informa de un error cuando `IGNORE` se usa en cualquier lugar que no sea directamente como argumento de expresión de `SUMMARIZECOLUMNS`, en consonancia con el comportamiento del motor.
+  - El analizador semántico ahora admite el nuevo componente opcional y los parámetros de escape introducidos para la función `NAMEOF` en Power BI Desktop de abril de 2026. Las palabras clave de componente válidas son `TABLE`, `COLUMN`, `MEASURE`, `CALENDAR`, `FULL`, `SELF`, `PARENT`; las palabras clave de escape válidas son `ESCAPED`, `UNESCAPED`, `MINIMALLYESCAPED`. El tipo de valor devuelto no cambia (cadena escalar). Por ejemplo, `EVALUATE { NAMEOF([MyMeasure], TABLE, MINIMALLYESCAPED) }` devuelve el componente del nombre de la tabla de una referencia de medida totalmente calificada. <br/><br/>
+
+- **Mejoras de Semantic Bridge**
+  - Al importar una Databricks Metric View, ahora se incorporan los metadatos de la vista al modelo semántico.
+    - `comment` pasa a ser la descripción del modelo, las dimensiones y las medidas.
+    - `display_name` pasa a ser el nombre visible para el usuario en el modelo TOM, con `name` como alternativa si no se ha definido ningún `display_name`.
+    - El `format` de medidas y dimensiones se traduce a FormatString de TOM, y el DataType de la columna o medida resultante se infiere a partir del formato (moneda, porcentaje, fecha, etc.).
+      Las especificaciones de formato sin un equivalente claro en TOM recurren a un valor predeterminado razonable y generan una advertencia.
+  - Se ha mejorado la traducción de SQL a DAX: los recuentos de filas (`COUNT(*)`), las referencias `MEASURE(name)`, las operaciones binarias, los literales (incluido `NULL` -> `BLANK()`), la asignación de `/` al `DIVIDE` seguro frente a valores en blanco y la precedencia de los paréntesis ahora se traducen correctamente.
+    - Las expresiones fuera del conjunto reconocido siguen recurriendo al SQL literal, con una advertencia.
+    - La traducción a DAX se hace con el mejor esfuerzo posible; revísala y valídala antes de implementarla.
+  - Se agregó soporte para esquemas en copo de nieve con uniones anidadas.
+  - La deserialización de YAML acepta tanto `fields:` como `dimensions:` en el nivel superior: la especificación Databricks v1.1 los trata como alias.
+    El recorrido de ida y vuelta conserva la palabra clave que haya usado el YAML de origen. Las vistas creadas en TE3 (sin YAML de origen) usan `dimensions:` de forma predeterminada para v1.1 y anteriores: el alias `fields:` se introdujo después de que se publicara la especificación v1.1, así que mantenemos la compatibilidad con las herramientas que usan la especificación 1.1 original.
+    Aparece una advertencia de deserialización cuando una vista v1.1+ usa `dimensions:` (la especificación marca `fields:` como opción preferida a partir de v1.1), y aparece una advertencia equivalente cuando una vista anterior a v1.1 usa `fields:`.
+    - En la superficie de scripting de C# Script, `Dimension` pasa a llamarse `Field` (`view.Fields`, `view.AddField`, `Dimension` -> `Field`, `MakeValidationRuleForDimension` -> `MakeValidationRuleForField`, `ctx.DimensionNames` -> `ctx.FieldNames`).
+    - Los nombres heredados se mantienen como alias obsoletos que siguen compilando y ejecutándose con advertencias de desuso, por lo que los scripts existentes y las rutas almacenadas como `Model.Dimensions["x"]` siguen funcionando.
+  - Las medidas de ventana (incluido el campo `offset:` de v1.1) se conservan en la deserialización y serialización de YAML. Aún no traducimos las características que la especificación marca como experimentales; el round-trip de YAML las conserva para que no se pierdan.
+  - Las uniones ahora admiten dos propiedades nuevas en la especificación v1.1 actualizada:
+    - Se admite el mapa `rely:`
+    - El campo `cardinality:` se conserva en la ida y vuelta tanto para los dos valores de la especificación (`many_to_one`, `one_to_many`) como cuando se omite.
+      Un valor desconocido usa `many_to_one` como valor predeterminado, con una advertencia.
+      - Las uniones declaradas con `cardinality: one_to_many` se siguen importando, pero la relación con el origen se omite intencionadamente: la especificación v1.1 trata estas uniones como orígenes de hechos independientes, agregados por separado a la granularidad del origen.
+        La tabla combinada se sigue creando para que aparezca en el modelo TOM resultante, pero sin las relaciones definidas.
+        Se muestra una advertencia que señala esta diferencia en cada unión afectada.
+
+## Correcciones de errores en 3.26.2
+
+- Se corrigió un error por el que el chat de IA fallaba con un error `BadRequest` ("temperature is deprecated for this model") en Anthropic Claude Opus 4.7+ y Fable 5, que dejaron de admitir el parámetro de muestreo `temperature`. La lógica de reintento que reenvía la solicitud de forma transparente sin indicar explícitamente `temperature` ahora también reconoce la redacción de este proveedor, además de los casos que ya se contemplaban.
+
+- Ahora se sugieren calendarios en el autocompletado para las funciones `NAMEOF` y `TABLEOF`, junto con tablas, columnas y medidas. Esto incluye calendarios que no tienen configuradas columnas de unidad de tiempo (como un calendario recién agregado y aún sin configurar), que antes se omitían. Al escribir un prefijo entre comillas simples (por ejemplo, `'My Cal`), ahora se limitan las sugerencias a los calendarios coincidentes, igual que ocurre con las tablas.
+
+- La ordenación y la paginación en la **Vista previa de datos** de la tabla ahora son más fiables en todos los modos de almacenamiento:
+
+- La ordenación por una columna que no tiene jerarquía de atributos ya no devuelve las filas en un orden incorrecto. Cuando es posible, la paginación ahora usa la función `WINDOW` (en motores que la admiten, para tablas con clave primaria); de lo contrario, la vista previa muestra las primeras filas e indica que el desplazamiento está desactivado.
+
+- La disponibilidad de la jerarquía de atributos ahora se lee directamente del servidor, por lo que sigue siendo correcta incluso después de que el modelo se procese fuera de Tabular Editor.
+
+- Las tablas DirectQuery ahora muestran correctamente las primeras filas (la paginación no es posible con DirectQuery), junto con un mensaje informativo.
+
+- Los metadatos de la vista previa se almacenan en caché durante la sesión y solo se actualizan cuando haces clic en **Actualizar**, lo que evita viajes de ida y vuelta innecesarios al servidor (incluidas las consultas repetidas de recuento de filas).
+
+- El formateador de DAX ya no elimina el calificador de tabla de los bloques `DEFINE MEASURE` cuando la tabla principal no se puede resolver en el modelo. Antes, esto podía convertir un `MEASURE 'Sales'[Amount] = ...` válido en el inválido `MEASURE [Amount] = ...`, lo que invalidaba la instrucción.
+
+- El analizador semántico ya no informa de un error espurio cuando se usa una función de eliminación de filtros (`ALL`, `ALLSELECTED`, `REMOVEFILTERS` o `ALLCROSSFILTERED`) como expresión principal del cuerpo de una función DAX definida por el usuario; por ejemplo: `FUNCTION F = () => REMOVEFILTERS('Sales')`. Estas UDF son válidas cuando se invocan como argumento de filtro de `CALCULATE`. El uso incorrecto se sigue notificando en los puntos de invocación, y los modificadores de relación (`CROSSFILTER` / `USERELATIONSHIP`) y `KEEPFILTERS` siguen siendo inválidos como cuerpos de UDF, en consonancia con el comportamiento del motor.
+
+- Al cambiar el nombre de una tabla a la que se hace referencia dentro de una llamada a la función NAMEOF, la corrección de fórmulas ahora actualiza correctamente la referencia a esa tabla.
+
+- El analizador semántico ya no informa de un error espurio cuando `TABLEOF(...)` se pasa como argumento de referencia de tabla a `ALL`, `ALLEXCEPT`, `ALLSELECTED`, `ALLNOBLANKROW`, `ALLCROSSFILTERED` o `REMOVEFILTERS`.
+
+- La acción **Actualizar esquema de tabla** ahora se comporta correctamente cuando se invoca en una combinación de tipos de objetos o cuando se invoca en un Grupo de tablas.
+
+---
+
+## ¿Vienes de Tabular Editor 2.x?
+
+Mira [este vídeo](https://youtu.be/O4ATwdzCvWc) para hacer un recorrido rápido por las principales funcionalidades de Tabular Editor 3. Además, asegúrate de consultar nuestra [guía de inicio](https://docs.tabulareditor.com/onboarding/index.html).
+
+**Descripción general de las principales características de Tabular Editor 3:**
+
+- IDE totalmente personalizable, con compatibilidad con múltiples monitores, soporte HiDPI y temas
+- Nuevo y potente editor de código DAX con autocompletado, comprobación de sintaxis, plegado de código y mucho, mucho más
+- \*Modo del área de trabajo, que permite guardar los cambios en disco y sincronizar simultáneamente los metadatos del modelo con Analysis Services
+- \*Previsualizar datos de tablas con desplazamiento infinito, crear PivotGrids o escribir consultas DAX para explorar el modelo o probar la lógica de cálculo
+- \*Programar actualizaciones de datos
+- Actualizar los esquemas de las tablas tanto en Data sources de proveedor como en orígenes de datos estructurados (sí, ¡incluso para consultas M!)
+- Crear diagramas del Data model
+- Crear scripts DAX que permiten editar varias medidas u otros objetos calculados en un solo documento
+- Grabar C# Scripts y guardarlos como macros (antes conocidas como "Custom Actions")
+- Integración con el Analizador VertiPaq
+- Depurador de DAX
+- Integración del Optimizador de DAX
+- Acciones de código para refactorizar fácilmente tus expresiones DAX.
+
+\*=Solo disponible cuando se está conectado a una instancia de Analysis Services o Power BI
+
+---
+
diff --git a/localizedContent/es/content/references/release-notes/3_26_3.md b/localizedContent/es/content/references/release-notes/3_26_3.md
new file mode 100644
index 000000000..3cbeac989
--- /dev/null
+++ b/localizedContent/es/content/references/release-notes/3_26_3.md
@@ -0,0 +1,65 @@
+---
+uid: release-3-26-3
+---
+
+# Tabular Editor 3.26.3
+
+# [**Descargas**](#tab/downloads)
+
+Descargas de Tabular Editor 3.26.3:
+
+- Descargar [Tabular Editor 3.26.3 (x64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) _(recomendado)_
+- Descargar [Tabular Editor 3.26.3 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+- Versiones portátiles: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+- Versión MSI: [x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+
+_Si aún no has usado Tabular Editor 3, tienes derecho a una prueba de 30 días, que puedes activar después de la instalación. También puedes [comprar una licencia](https://tabulareditor.com/licensing)._
+
+# [**Sumas de comprobación SHA-256**](#tab/checksums)
+
+| Archivo                                                                                                                                                                                                                                            | Entorno de ejecución para «.NET» | Plataforma | SHA-256                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ | ---------- | ------------------------------------------------------------------ |
+| [TabularEditor.3.26.3.Installer.x64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe)     | .NET 8                           | x64        | `2413B042E935F010EA03E1EE7D01B6F0CDD076B10F29F1CD5651BECE1F4ADEEC` |
+| [TabularEditor.3.26.3.x64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi)                                         | .NET 8                           | x64        | `AE7DBAE6A0432EFDB75765F6C1B3CE91495018F058A24BE67EB2BC7DF39BD915` |
+| [TabularEditor.3.26.3.x64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip)                                         | .NET 8                           | x64        | `AAEB730DADA50A424F55D0AC41961E23D09F3913A72DB240319D78271BF7DAE2` |
+| [TabularEditor.3.26.3.Installer.ARM64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe) | .NET 8                           | ARM64      | `8563D579F32F776A8BF4BA75D17C11B1094E1550B24DD448A2404D63860E8F78` |
+| [TabularEditor.3.26.3.ARM64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)                                     | .NET 8                           | ARM64      | `FC9F0B2D7B8F75BFDCBFB534CF8450E44014E706D1FB125544317A0C4683D4F2` |
+| [TabularEditor.3.26.3.ARM64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)                                     | .NET 8                           | ARM64      | `37312FB9D663FA59AB07D3AA45F88B21B8FF812B8F185AF8DCFCB4D9A8583AA7` |
+
+***
+
+## Correcciones de errores en la versión 3.26.3
+
+- Se corrigió un problema por el cual un Archivo > Revertir fallido (por ejemplo, cuando el TMDL en disco contiene una referencia que no se puede resolver) podía desactivar de forma permanente el seguimiento de cambios sin guardar durante el resto de la sesión. Antes, las ediciones posteriores dejaban de mostrar el asterisco de cambios sin guardar, y Revertir o Cerrar podían descartarlos sin mostrar ninguna advertencia. Ahora el seguimiento de cambios sigue activo después de una reversión fallida.
+- En los modelos serializados en carpetas (TMDL), Archivo > Revertir ya no hace que el modelo aparezca como si tuviera cambios sin guardar después de una reversión correcta. Antes, el asterisco de la barra de título y la confirmación "¿Actualizar metadatos desde el origen?" seguían apareciendo en cada reversión posterior hasta que se guardaba el modelo.
+- Se corrigió el autocompletado de DAX, que sugería funciones definidas por el usuario (UDF) que no eran válidas en el contexto actual del argumento y omitía otras que sí eran válidas. Ahora las UDF se filtran según su tipo de retorno inferido: cuando se espera un escalar, solo se muestran las UDF que devuelven un escalar, una tabla de una sola columna o un parámetro de entrada sin tipo; cuando se espera una tabla, solo se muestran las UDF que devuelven tablas (o passthrough); y los argumentos de filtro (como los de CALCULATE / CALCULATETABLE) ahora también incluyen sugerencias de UDF, que antes se omitían por completo. Las UDF cuya definición contiene un error semántico (por ejemplo, uno que requiere contexto de fila o usa MATCHBY de forma incorrecta) ya no se ofrecen como sugerencias, ya que no pueden invocarse de forma válida.
+- El formateador de DAX ya no sustituye el `=` del valor predeterminado de un parámetro de una función DAX por `:`. Antes, al dar formato a una función como `(p = [m]) => 1`, se generaba la expresión no válida `(p: [m]) => 1`, porque el formateador asumía que cualquier token posterior al nombre de un parámetro era una anotación de tipo `: type`. Ahora las anotaciones de tipo, los valores predeterminados y la combinación de ambos (`p: INT64 = 1`) se formatean correctamente.
+- Se corrigió un problema por el que marcar un problema del Optimizador de DAX como ignorado no tenía efecto después de cargar una nueva versión de un modelo ofuscado: el problema ignorado volvía a aparecer como abierto. Ahora los problemas ignorados se conservan entre versiones de los modelos ofuscados.
+- Se corrigió un cierre inesperado intermitente ("Collection was modified") que podía producirse en la vista del Optimizador de DAX justo después de cargar un modelo o una nueva versión. Ahora la vista se actualiza mientras todavía se muestra el spinner de progreso, en lugar de actualizarse en segundo plano mientras se redibujaba la ventana.
+
+---
+
+## Vienes de Tabular Editor 2.x?
+
+Mira [este vídeo](https://youtu.be/O4ATwdzCvWc) para hacer un recorrido rápido por las principales funcionalidades de Tabular Editor 3. Además, asegúrate de consultar nuestra [guía de inicio](https://docs.tabulareditor.com/onboarding/index.html).
+
+**Resumen de las principales funcionalidades de Tabular Editor 3:**
+
+- IDE totalmente personalizable, con compatibilidad con varios monitores, Hi-DPI y temas
+- Nuevo y potente editor de código DAX con autocompletado, comprobación de sintaxis, plegado de código y mucho, mucho más
+- \*Modo del área de trabajo, que te permite guardar los cambios en disco y sincronizar los metadatos del modelo con Analysis Services simultáneamente
+- \*Previsualiza los datos de la tabla con desplazamiento infinito, crea PivotGrids o escribe consultas DAX para explorar el modelo o probar la lógica de cálculo
+- \*Programar actualizaciones de datos
+- Actualizar los esquemas de las tablas tanto en los Data source del proveedor como en los orígenes de datos estructurados (sí, ¡incluso para consultas M!)
+- Crear diagramas del Data model
+- Crear scripts DAX que te permitan editar varias medidas u otros objetos calculados en un solo documento
+- Grabar C# Scripts y guardarlos como macros (antes conocidas como "Custom Actions")
+- Integración con el Analizador VertiPaq
+- Depurador de DAX
+- Integración del Optimizador de DAX
+- Acciones de código para refactorizar fácilmente tus expresiones DAX.
+
+\*=Solo mientras estés conectado a una instancia de Analysis Services o Power BI
+
+---
+
diff --git a/localizedContent/es/content/references/whats-new.md b/localizedContent/es/content/references/whats-new.md
index 446ae73af..bb21d3ba3 100644
--- a/localizedContent/es/content/references/whats-new.md
+++ b/localizedContent/es/content/references/whats-new.md
@@ -2,7 +2,7 @@
 uid: whats-new
 title: Novedades
 author: Morten Lønskov
-updated: 2026-03-19
+updated: 2026-06-24
 ---
 
 <script>
@@ -12,4 +12,4 @@ updated: 2026-03-19
     }
 </script>
 
-<iframe id="content-iframe" src="../whats-new/index.html?version=3.26.0" title="What's new" style="border:none;width:100%;"></iframe>
+<iframe id="content-iframe" src="../whats-new/index.html?version=3.26.2" title="What's new" style="border:none;width:100%;"></iframe>
diff --git a/localizedContent/es/content/tutorials/udfs.md b/localizedContent/es/content/tutorials/udfs.md
index 2c5d6d9b5..f65e47e02 100644
--- a/localizedContent/es/content/tutorials/udfs.md
+++ b/localizedContent/es/content/tutorials/udfs.md
@@ -2,7 +2,7 @@
 uid: udfs
 title: Funciones DAX definidas por el usuario
 author: Daniel Otykier
-updated: 2026-03-19
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -20,7 +20,7 @@ applies_to:
 
 # Funciones DAX definidas por el usuario
 
-Las funciones DAX definidas por el usuario (UDFs) constituyen una nueva capacidad de los modelos semánticos, introducida en Power BI Desktop con la actualización de septiembre de 2025.
+Las UDF de DAX (funciones DAX definidas por el usuario) son una característica de los modelos semánticos. La característica pasó a versión preliminar con la actualización de septiembre de 2025 de Power BI Desktop y está [disponible de forma general](https://community.fabric.microsoft.com/t5/Power-BI-Updates-Blog/DAX-User-Defined-Functions-Generally-Available/ba-p/5185738) desde la versión de junio de 2026 de Power BI.
 
 La característica te permite crear funciones DAX reutilizables que puedes invocar desde cualquier expresión DAX de tu modelo, incluso desde otras funciones. Esta potente característica te ayuda a mantener la coherencia, reducir la duplicación de código y crear expresiones DAX más fáciles de mantener.
 
@@ -133,8 +133,31 @@ Además de especificar el modo de evaluación, también puedes restringir el tip
 
 Estas especificaciones de tipo son opcionales, pero si se indican, realizarán una conversión de tipo implícita en los argumentos que se pasen a la función y también afectarán a las sugerencias de autocompletado en Tabular Editor 3 al escribir código DAX que llame a la función.
 
+Tabular Editor 3 valida los argumentos según los tipos de parámetro declarados. Si llama a una UDF con un argumento que no coincide con el tipo de su parámetro —por ejemplo, si pasa un valor escalar cuando se espera un parámetro `TABLEREF`—, el Analizador semántico genera un Report de advertencia o un error.
+
 Consulta la [especificación de Microsoft para las UDF](https://learn.microsoft.com/en-us/dax/best-practices/dax-user-defined-functions) para ver la lista completa de restricciones disponibles.
 
+### Parámetros opcionales con expresiones predeterminadas
+
+A partir de la versión 3.26.2, Tabular Editor 3 admite parámetros opcionales con expresiones predeterminadas. Añade `= expression` después del nombre del parámetro (y después de cualquier indicación de tipo o modo de evaluación) para que el parámetro sea opcional. Cuando quien llama omite el argumento, la expresión predeterminada proporciona el valor.
+
+```dax
+FUNCTION AddTax =
+    (
+        amount: NUMERIC,        // Parámetro obligatorio
+        taxRate: NUMERIC = 0.1  // Parámetro opcional; el valor predeterminado es 10 %
+    )
+    => amount * (1 + taxRate)
+```
+
+Si llamas a `AddTax(10)`, obtienes `11`, mientras que si llamas a `AddTax(10, 0.25)`, obtienes `12.5`.
+
+Los parámetros opcionales se rigen por algunas reglas:
+
+- Puedes dejar vacío un argumento para usar su valor predeterminado; por ejemplo, `MyFunc(1,,3)` omite el segundo argumento. El número mínimo de argumentos lo determina la posición del parámetro obligatorio situado más a la derecha.
+- Una expresión predeterminada solo puede hacer referencia a nombres (columnas, tablas, medidas, funciones) visibles donde se define la función, y no puede hacer referencia a otro parámetro de la misma función.
+- La comprobación de tipos con respecto a la indicación de tipo de un parámetro solo se aplica cuando se usa la expresión predeterminada; en cambio, un argumento pasado explícitamente se comprueba con respecto a esa indicación.
+
 ## Uso de las UDF en tu modelo
 
 ### En expresiones de objetos
@@ -311,15 +334,15 @@ Tabular Editor 3 detecta automáticamente cualquier comentario y lo muestra corr
 
 **La función no funciona tras el despliegue**
 
-- Comprueba que tu entorno de destino admite UDFs (nivel de compatibilidad 1702 o superior). A fecha del dieciséis de septiembre de 2025, Power BI Service todavía no admite UDFs, ni tampoco Azure Analysis Services ni SQL Server Analysis Services.
+- Comprueba que tu entorno de destino admite UDFs (nivel de compatibilidad 1702 o superior). El servicio Power BI admite las UDF a partir de la versión de junio de 2026. Azure Analysis Services y SQL Server Analysis Services no admiten las UDF.
 
 ## Limitaciones
 
-- No todos los entornos de Power BI admiten UDFs (requiere compilaciones específicas)
+- Las UDF requieren un nivel de compatibilidad 1702 o superior; Azure Analysis Services y SQL Server Analysis Services no las admiten
 - Las UDFs no pueden ser recursivas (llamarse a sí mismas)
 
 > [!NOTE]
-> A partir de junio de 2026, las UDF están [disponibles de forma general](https://community.fabric.microsoft.com/t5/Power-BI-Updates-Blog/DAX-User-Defined-Functions-Generally-Available/ba-p/5185738). Como parte de esto, las UDF ahora admiten expresiones predeterminadas y parámetros opcionales. Sin embargo, Tabular Editor 3 muestra actualmente un mensaje de error incorrecto cuando se usa la sintaxis de la expresión predeterminada. Este problema se corregirá en nuestra próxima actualización de Tabular Editor 3.
+> Con la [disponibilidad general](https://community.fabric.microsoft.com/t5/Power-BI-Updates-Blog/DAX-User-Defined-Functions-Generally-Available/ba-p/5185738) de las UDF en junio de 2026, las UDF admiten parámetros opcionales con expresiones predeterminadas. Tabular Editor 3 admite esta sintaxis desde la versión 3.26.2. Las versiones anteriores muestran un mensaje de error incorrecto cuando usas la sintaxis de expresión predeterminada.
 
 ---
 
diff --git a/localizedContent/zh/content/features/ai-assistant.md b/localizedContent/zh/content/features/ai-assistant.md
index 591cfe2ee..fd98941b0 100644
--- a/localizedContent/zh/content/features/ai-assistant.md
+++ b/localizedContent/zh/content/features/ai-assistant.md
@@ -2,7 +2,7 @@
 uid: ai-assistant
 title: AI 助手
 author: Morten Lønskov
-updated: 2026-04-17
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -44,20 +44,20 @@ AI 助手采用自带密钥 BYOK 模式。 你只需从受支持的提供商中
 
 ## 支持的提供程序
 
-在 **工具 > 偏好 > AI 助手 > AI 提供程序** 下配置 AI 提供程序。 从下拉列表中选择一个提供商——在你完成配置之前，默认是 **无（AI 已禁用）**——输入你的 API 密钥，并可按需替换默认模型。 对于 OpenAI 和 Anthropic，**模型名称** 字段是一个预先填入已知模型的组合框；你也可以输入自定义模型名称。
+在 **工具 > 偏好 > AI 助手 > AI 提供程序** 下配置 AI 提供程序。 从下拉列表中选择一个提供商——在你完成配置之前，默认是 **无（AI 已禁用）**——输入你的 API 密钥，并可按需替换默认模型。 对于 OpenAI 和 Anthropic，**模型名称**字段是一个预先填充了当前模型的下拉框——包括 Anthropic 的 `claude-fable-5` 和 `claude-opus-4-8`，以及 OpenAI 的 `gpt-5.5` 和 `gpt-5.5-pro`——这样你无需手动输入自定义 ID，也能直接选择较新的模型。 你也可以输入自定义模型名称。
 
-| 提供程序           | 默认模型              | 需要配置                           |
-| -------------- | ----------------- | ------------------------------ |
-| OpenAI         | gpt-4o            | API 密钥。 可选：基础 URL、组织 ID 和项目 ID |
-| Anthropic      | claude-sonnet-4-6 | API 密钥。 可选：基础 URL              |
-| Azure OpenAI   | 视部署而定             | API 密钥、端点 URL 和部署名称            |
-| 自定义（兼容 OpenAI） | 由用户指定             | API 密钥和自定义端点 URL               |
+| 提供程序           | 默认模型                    | 需要配置                           |
+| -------------- | ----------------------- | ------------------------------ |
+| OpenAI         | gpt-5.5 | API 密钥。 可选：基础 URL、组织 ID 和项目 ID |
+| Anthropic      | claude-sonnet-4-6       | API 密钥。 可选：基础 URL              |
+| Azure OpenAI   | 视部署而定                   | API 密钥、端点 URL 和部署名称            |
+| 自定义（兼容 OpenAI） | 由用户指定                   | API 密钥和自定义端点 URL               |
 
 ![AI 助手提供程序偏好设置选择](~/content/assets/images/ai-assistant/ai-assistant-provider-preferences.png)
 
 ### OpenAI
 
-将提供程序选择为 **OpenAI**，然后输入你的 API 密钥。 如果你的 OpenAI 账户使用组织 ID 和项目 ID，也可以选择填写这些信息。 默认模型是 **gpt-4o**，但你可以将其更改为你账户中可用的任意模型。
+将提供程序选择为 **OpenAI**，然后输入你的 API 密钥。 如果你的 OpenAI 账户使用组织 ID 和项目 ID，也可以选择填写这些信息。 默认模型为 **gpt-5.5**，但你可以将其更改为你账号下可用的任意模型。
 
 ![AI 助手 OpenAI 配置](~/content/assets/images/ai-assistant/ai-assistant-openai-config.png)
 
diff --git a/localizedContent/zh/content/features/table-groups.md b/localizedContent/zh/content/features/table-groups.md
index 961a53ccf..47f3ca181 100644
--- a/localizedContent/zh/content/features/table-groups.md
+++ b/localizedContent/zh/content/features/table-groups.md
@@ -2,7 +2,7 @@
 uid: table-groups
 title: 表格组
 author: Daniel Otykier
-updated: 2023-03-08
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -25,6 +25,8 @@ applies_to:
 
 你可以通过两种方式创建表格组：在表格上右键并选择 **创建 > 表格组** 菜单选项；或者在选中一个或多个表格时，在 **属性视图** 中为表格组指定名称。
 
+你也可以在选中一个或多个表后，通过右键菜单中的 **移至组** 子菜单进行操作。 该子菜单会列出现有的表格组、用于根据所选表创建新组并打开组名编辑器的 **(新建...)** 项，以及用于取消表格组归属的 **(无)** 项。
+
 你可以在 TOM Explorer 中通过拖放，将表格在不同表格组之间移动。 注意：与度量值、列和层次结构的显示文件夹不同，表格组不能嵌套。
 
 在 TOM Explorer 中右键点击某个表格组，会显示与你选中该表格组内表格(s)时相同的上下文菜单选项。
diff --git a/localizedContent/zh/content/features/te-cli/includes/te-cli-preview-notice.md b/localizedContent/zh/content/features/te-cli/includes/te-cli-preview-notice.md
index f77a5378b..df39c7c39 100644
--- a/localizedContent/zh/content/features/te-cli/includes/te-cli-preview-notice.md
+++ b/localizedContent/zh/content/features/te-cli/includes/te-cli-preview-notice.md
@@ -1,2 +1,2 @@
 > [!IMPORTANT]
-> Tabular Editor CLI 目前为 **有限公开预览版**。 可使用 Tabular Editor 账户进行评估；预览期间无需许可证。 在正式发布之前，命令、标志位和输出都可能会发生变化。 **该预览版本将在 2026-09-30 后停止运行。** 我们不建议在预览期间将该 CLI 用于生产环境的 CI/CD 流水线。 请查看我们的许可协议。
+> Tabular Editor CLI 目前为 **有限公开预览版**。 可使用 Tabular Editor 账户进行评估；预览期间无需许可证。 在正式发布之前，命令、标志位和输出都可能会发生变化。 **该预览版本将在 2026-09-30 后停止运行。** 我们不建议在预览期间将该 CLI 用于生产环境的 CI/CD 流水线。
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-automation.md b/localizedContent/zh/content/features/te-cli/te-cli-automation.md
index 0497af602..da2d6ea5f 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-automation.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-automation.md
@@ -28,11 +28,11 @@ Tabular Editor CLI 具备可组合性；每个命令都支持结构化输出，
 | `text`（默认）       | 人工阅读                                                                                                                                 | 无论是连接到 TTY 还是通过管道传输，stdout 都输出纯文本。                                           |
 | `json`           | 机器可读                                                                                                                                 | 始终向 stdout 输出有效的 JSON。 如果还需要在 stderr 上输出机器可读的错误信息，请使用 `--error-format json`。 |
 | `csv`            | 表格结果（`query`、`bpa run`、`bpa rules`、`vertipaq`、`validate`、`test`、`refresh`、`profile list`、`session list`、`find`、`replace`、`get`、`ls`） | 采用 RFC 4180 转义。                                                              |
-| `tmsl`（别名 `bim`） | 整个对象的 TMSL/BIM 序列化                                                                                                                   | `te get` 和 `te ls` 接受此格式。                                                    |
+| `tmsl`（别名 `bim`） | 整个对象的 TMSL/BIM 序列化                                                                                                                   | 此格式被 `te get` 和 `te list` 支持。                                                |
 | `tmdl`           | 整个对象的 TMDL 序列化                                                                                                                       | 仅 `te get` 支持（单个对象）。                                                         |
 
 ```bash
-te ls --output-format json
+te list --output-format json
 te query -q "EVALUATE VALUES('Date'[Year])" --output-format csv
 te bpa run --output-format json
 ```
@@ -52,11 +52,11 @@ te deploy ./model --non-interactive --force --ci github
 
 每个 `te` 命令都会使用可预测的状态代码退出，因此调用方无需解析 stdout，就能根据成功或失败执行分支逻辑。
 
-| 退出代码 | 含义                                                                                             |
-| ---- | ---------------------------------------------------------------------------------------------- |
-| `0`  | 成功。                                                                                            |
-| `1`  | 通用失败：参数无效、命令失败、验证错误、身份验证失败，或 BPA 门禁在严重级别 ≥ error 时未通过。 针对 `te diff`：发现差异（遵循 `diff`/`cmp` 的惯例）。 |
-| `2`  | 仅适用于 `te diff`：比较过程中出错，因此差异状态未知。                                                               |
+| 退出代码 | 含义                                                                                              |
+| ---- | ----------------------------------------------------------------------------------------------- |
+| `0`  | 成功。                                                                                             |
+| `1`  | 通用失败：参数无效、命令失败、验证错误、身份验证失败，或 BPA 检查在严重级别 >= error 时未通过。 针对 `te diff`：发现差异（遵循 `diff`/`cmp` 的惯例）。 |
+| `2`  | 仅适用于 `te diff`：比较过程中出错，因此差异状态未知。                                                                |
 
 将退出代码与 `--ci <vsts\|github>` 注释以及 `--trx <file>` 结合使用，可在 CI 中展示更丰富的失败信息——请参阅 @te-cli-cicd。
 
@@ -65,7 +65,7 @@ te deploy ./model --non-interactive --force --ci github
 错误、警告和预览横幅会写入 **stderr**；结构化数据会写入 **stdout**。 这意味着你可以安全地通过管道传递 JSON，而不用担心其中混入进度指示或诊断信息：
 
 ```bash
-te ls --output-format json | jq '.[] | .name'
+te list --output-format json | jq '.[] | .name'
 te vertipaq --output-format json > stats.json
 ```
 
@@ -152,7 +152,7 @@ te deploy ./model `
 
 ```bash
 # Count measures per table
-te ls --type measure --output-format json \
+te list --type measure --output-format json \
   | jq -r '.[] | .table' \
   | sort | uniq -c | sort -rn
 ```
@@ -179,10 +179,10 @@ cat refresh.tmsl
 
 下面这些小技巧，是在脚本或管道中组合 `te` 命令时经常会用到的：
 
-- **幂等的创建与删除。** `te add Sales/Marker -t Measure -i "0" --if-not-exists --save` 用于创建度量值，`te rm Sales/OldMeasure --if-exists --save` 用于删除度量值；无论对象是否存在，两者都会以 `0` 退出——可在 CI 中安全地重复运行。
+- **幂等的创建与删除。** `te add Sales/Marker -t Measure -i "0" --if-not-exists --save` 和 `te remove Sales/OldMeasure --if-exists --save` 无论对象是否存在，都会以 `0` 退出——可在 CI 中安全地重复运行。
 - **试运行查看差异。** `te replace` 默认会先试运行；只有在你对预览结果满意时才添加 `--save`。
 - **输出供审查的 TMSL。** `te deploy ./model --xmla deploy.tmsl` 会生成部署脚本，而不会更改服务器——适合 DBA 审查或手动应用。
-- **仅输出路径。** `te ls --paths-only` 和 `te find --paths-only` 每行输出一个对象路径，非常适合通过管道传给 `xargs`、`te get` 或 `te set`。 模型级容器（`te ls Measures`、`te ls Columns`）与此配合良好，适合对整个模型进行一次全面扫描。
+- **仅输出路径。** `te list --paths-only` 和 `te find --paths-only` 每行输出一个对象路径，非常适合通过管道传给 `xargs`、`te get` 或 `te set`。 模型级容器（`te list Measures`、`te list Columns`）与此配合良好，可用于对整个模型进行全面扫描。
 - **查询基准测试。** `te query --trace --cold --runs 5` 会在冷缓存下运行 DAX 查询，迭代五次，并捕获 FE/SE 跟踪事件。
 - **CI 日志中的步骤耗时。** 长时间运行的命令（`te deploy`、`te refresh`、`te script`、`te validate`）会在 JSON 输出中包含 `durationMs` 字段——便于在管道摘要中展示各步骤耗时。
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-cicd.md b/localizedContent/zh/content/features/te-cli/te-cli-cicd.md
index f78df6d02..4152c73b6 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-cicd.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-cicd.md
@@ -167,7 +167,7 @@ steps:
 
 默认情况下，`te deploy` 和 `te save` 会先运行 Best Practice Analyzer 作为预检门禁。 有三种行为值得提前确定：
 
-- **强制执行**——默认行为。 如果 BPA 发现严重级别 ≥ error 的违规项，管道将失败。 如果你也希望警告导致失败，可在独立的 `te bpa run` 步骤中配合 `--fail-on warning` 使用。
+- **强制执行**——默认行为。 如果 BPA 发现严重级别 >= error 的违规项，流水线将失败。 如果你也希望警告导致失败，可在独立的 `te bpa run` 步骤中配合 `--fail-on warning` 使用。
 - **自动修复**——`--fix-bpa` 会在内存中对部署产物应用 `fixExpression`。 不会修改源文件。 当模型是唯一可信来源，而你希望部署在无需开发者干预的情况下规范化样式时，这很有用。
 - **绕过**——`--skip-bpa` 会为单个命令禁用该门禁。 适合紧急热修复；不建议作为默认做法。
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-commands.md b/localizedContent/zh/content/features/te-cli/te-cli-commands.md
index 38270a6fc..84294035f 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-commands.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-commands.md
@@ -31,8 +31,8 @@ te bpa run --help           # Help for a command with subcommands
 
 CLI 中的对象定位在所有命令中都采用同一套语法。 以下参考中会出现两种路径形式：
 
-- **`<path>`** - 解析为**恰好一个**对象或容器。 用于对单个目标执行操作的命令：`te get`、`te set`、`te add`、`te rm`、`te mv`、`te format -p`、`te deps`、`te macro run --on`。
-- **`<path-filter>`** - 解析为**零个或多个**对象，并支持通配符。 用于对一组对象执行操作的命令：`te ls`、`te bpa run --path` 以及其他用于检查的命令。
+- **`<path>`** - 解析为**恰好一个**对象或容器。 用于对单个目标执行操作的命令：`te get`、`te set`、`te add`、`te remove`、`te move`、`te format -p`、`te deps`、`te macro run --on`。
+- **`<path-filter>`** - 解析为**零个或多个**对象，并支持通配符。 用于对一组目标执行操作的命令：`te list`、`te bpa run --path` 以及其他检查类命令。
 
 两种路径形式共用同一套语法规则；仅有两处不同：
 
@@ -101,22 +101,42 @@ te get "Measures/Revenue/KPI"              # KPI sub-object of a measure
 
 ### 筛选路径中的通配符
 
-筛选路径引入了一个通配符字符 `*`，用于匹配单个分段内任意长度的字符序列（贪婪匹配，且仅限单个分段）。 通配符是 `te ls` 和类似命令用来缩小结果范围的方式。
+筛选路径引入了一个通配符字符 `*`，用于匹配单个分段内任意长度的字符序列（贪婪匹配，且仅限单个分段）。 通配符用于缩小 `te list` 和类似命令的结果范围。
 
 ```bash
-te ls 'Sa*'                          # Tables whose name starts with Sa
-te ls 'Sales/*Amount'                # Children of Sales whose name ends with Amount
-te ls '*/Amount'                     # An Amount column/measure across every table
-te ls 'Roles/Re*/Members'            # Members of every role matching Re*
+te list 'Sa*'                          # Tables whose name starts with Sa
+te list 'Sales/*Amount'                # Children of Sales whose name ends with Amount
+te list '*/Amount'                     # An Amount column/measure across every table
+te list 'Roles/Re*/Members'            # Members of every role matching Re*
 ```
 
-包含 **N 个分段** 的筛选路径会返回 **N 层深度** 的结果——通配符不会自动多展开一层，结果深度不会超过你输入的层级。 单分段快捷写法 `te ls Sales` 是个例外：未限定且不含通配符的表名会展开为该表的直接子项，以符合“让我看看 Sales 里有什么”的意图。 相比之下，`te ls Sa*` 只返回匹配的表，不会展开。
+包含 **N 个分段** 的筛选路径会返回 **N 层深度** 的结果——通配符不会自动多展开一层，结果深度不会超过你输入的层级。 单分段快捷写法 `te list Sales` 是个例外：未限定且不带通配符的表名会展开为该表的直接子对象，以符合“让我看看 Sales 里有什么”的意图。 相比之下，`te list Sa*` 只返回匹配的表，不会展开。
 
 筛选路径中不支持 DAX 的方括号后缀；如需按字面匹配包含 `[` 和 `]` 的名称，请给名称加引号。
 
 ### 错误和提示
 
-分段拼写错误时会给出一条与上下文相关的错误；如果 CLI 能猜到你的意图，还会附带“你是不是想输入……”的提示。 缺少父级的路径会在检查叶节点之前失败，因此信息会指向真正出错的分段。 空容器（例如，在没有层次结构的模型上运行 `te ls Hierarchies`）会给出简单的“这里没有内容”提示，而不是错误。
+分段拼写错误时会给出一条与上下文相关的错误；如果 CLI 能猜到你的意图，还会附带“你是不是想输入……”的提示。 缺少父级的路径会在检查叶节点之前失败，因此信息会指向真正出错的分段。 空容器（例如，在没有层次结构的模型上运行 `te list Hierarchies`）会给出简单的“这里没有内容”提示，而不是报错。
+
+## 命令别名
+
+大多数长格式命令也有对应的简短别名。 每行显示规范命令及其可用的等效短格式别名。
+
+| 规范命令                            | 别名形式(s)  |
+| ------------------------------- | --------------------------- |
+| `te list`                       | `te ls`                     |
+| `te remove`                     | `te rm`                     |
+| `te move`                       | `te mv`, `te rename`        |
+| `te bpa rules list`             | `te bpa rules ls`           |
+| `te bpa rules remove`           | `te bpa rules rm`           |
+| `te config list`                | `te config ls`              |
+| `te 宏 list`                     | `te 宏 ls`                   |
+| `te 宏 remove`                   | `te 宏 rm`                   |
+| `te incremental-refresh remove` | `te incremental-refresh rm` |
+| `te profile list`               | `te profile ls`             |
+| `te profile remove`             | `te profile rm`             |
+| `te session list`               | `te session ls`             |
+| `te test list`                  | `te test ls`                |
 
 ## 全局选项
 
@@ -124,12 +144,12 @@ te ls 'Roles/Re*/Members'            # Members of every role matching Re*
 
 | 选项                         | 说明                                                                                                                                                                                 |
 | -------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `-m, --model <path>`       | 语义模型的路径（TMDL 文件夹、`.bim` 文件或 TE 文件夹）。                                                                                                                                               |
+| `-m, --model <path>`       | 语义模型的路径（TMDL 文件夹、`.bim` 文件、`Database.json` 文件夹或 `.SemanticModel` 文件夹）。                                                                                                             |
 | `-s, --server <endpoint>`  | Workspace 名称或终结点（例如 `MyWorkspace`、`powerbi://...`、`asazure://...`、`localhost`）。                                                                                                    |
 | `-d, --database <name>`    | Workspace 上的语义模型名称。                                                                                                                                                                |
 | `--local`                  | 连接到本地运行的 Power BI Desktop 实例（仅限 Windows）。                                                                                                                                          |
 | `--auth <method>`          | 身份验证方法：`auto`、`interactive`、`spn`、`env`、`managed-identity`（默认值：`auto`）。                                                                                                            |
-| `--output-format <format>` | 标准输出格式：`text` (默认)、`json`、`csv`、`tmsl` (别名 `bim`)、`tmdl`。 `csv` 会被输出表格数据的命令采用；`tmsl`/`tmdl` 仅在 `te get` 和 `te ls` 中用于整个对象的序列化。 命令会拒绝其不支持的格式。 |
+| `--output-format <format>` | 标准输出格式：`text` (默认)、`json`、`csv`、`tmsl` (别名 `bim`)、`tmdl`。 输出表格数据的命令会识别 `csv`；`tmsl`/`tmdl` 仅由 `te get` 和 `te list` 用于整个对象的序列化。 命令会拒绝其不支持的格式。 |
 | `--error-format <format>`  | 用于错误、警告和提示的 stderr 格式：`text`（默认）或 `json`。 其他值将回退为 `text`。 它独立于 `--output-format`，因此你可以将 JSON 格式的 stdout 与纯文本错误配合使用（反之亦然）。                                                          |
 | `--recent [N]`             | 使用最近使用过的模型。 未提供值 = 进入交互式选择器；`N` = 最近使用列表中的第 N 个（1 = 最近一次使用）。                                                                                                                       |
 | `--non-interactive`        | 禁用所有交互式提示。 如果缺少必需输入，将给出可操作的错误提示并失败退出。                                                                                                                                              |
@@ -141,6 +161,12 @@ te ls 'Roles/Re*/Members'            # Members of every role matching Re*
 
 位置参数 `<model>` → 全局选项 `--model` → `--server`/`--database`（远程）→ `te connect` 的当前活动连接 → `--recent`。
 
+> [!NOTE]
+> **拼写错误的选项会被立即拒绝。** 如果你传入了当前命令无法识别的 `--flag`，CLI 会直接退出并给出可操作的错误信息，而不是悄悄把该标记当作位置参数吞掉。 这可以捕获 CI 脚本中把 `--force ` 误写成 `--forec` 之类的拼写错误。
+
+> [!NOTE]
+> **带点号的服务器名称。** `-s`/`--server` 会将带点号的名称（例如 `Sales.2026`）视为 Analysis Services 服务器主机名，而不是 Power BI Workspace。 当 CLI 需要这样判断时，会发出警告，并提示：如果你指的是 Power BI Workspace，请在末尾追加 `.Workspace`（例如 `Sales.2026.Workspace`），或使用完整的 `powerbi://` URL。 适用于 `te connect`、`te deploy`、`te refresh`、`te query`、`te vertipaq` 和 `te test run`。
+
 ## 模型 I/O
 
 ### load
@@ -159,8 +185,8 @@ te load -s MyWorkspace -d MyModel          # Remote workspace
 
 `te save` 接受：
 
-- `-o, --output-path <path>` - 目标文件或文件夹。 **可选** - 若省略，`te save` 会写回源位置，保留原始格式。
-- `--serialization <fmt>` - `tmdl`, `bim`, `te-folder`, `pbip`, `database.json`。 默认会从已加载的模型中推断（BIM 源 → BIM；TMDL `SemanticModel/` → `definition/` 下的 TMDL）。
+- `-o, --output-path <path>` - 目标文件或文件夹。 **可选** - 若省略，`te save` 会写回源位置，保留原始格式。 文件扩展名也会用于推断格式：`.bim` 会写出单个 BIM 文件，`.json` 会写出 `Database.json` 文件夹，而不带扩展名的路径会写出 TMDL 文件夹。
+- `--serialization <fmt>` - `tmdl`、`bim`（别名 `tmsl`）、`database.json`、`pbip`。 省略时，格式会从 `-o` 路径的扩展名推断（如果完全省略 `-o`，则从已加载的模型推断）。
 - `--force` - 跳过验证并覆盖现有输出。 某些拒绝情况（例如容器不明确、项目根目录中存在多个 `SemanticModel`）即使使用 `--force` 也会触发。
 - `--skip-bpa` - 完全绕过 BPA 检查。
 - `--fix-bpa` - 当规则定义了修复表达式时，自动修复 BPA 违规项。
@@ -180,10 +206,12 @@ te save -o ./out -s my-workspace -d my-model --skip-validation   # Fast download
 
 ### open
 
-在 Tabular Editor 3 桌面版中打开模型。 **仅限 Windows**（需要先安装 TE3）。
+在 Tabular Editor 3 桌面版中打开模型。 **仅限 Windows**（需要先安装 TE3）。 不带参数时，会启动 TE3 并打开一个空白的 Workspace。
 
 ```bash
-te open ./my-model
+te open                  # Launch TE3 with a blank workspace
+te open ./my-model       # Open a TMDL folder in TE3
+te open ./model.bim      # Open a BIM file in TE3
 ```
 
 ### init
@@ -196,7 +224,7 @@ te open ./my-model
 - `--compatibility-mode <mode>` - `PowerBI`（默认）或 `AnalysisServices`。
 - `--compatibility-level <N>`（别名 `--compat`）- 兼容级别。 当模式为 `PowerBI` 时，默认值为 `1702`；否则为 `1500`。 参见 @update-compatibility-level。
 - `--name <name>` - 模型/数据库名称（默认：目录名称）。
-- `--serialization <fmt>` - `tmdl`（默认）、`bim`、`te-folder`、`pbip`。
+- `--serialization <fmt>` - `tmdl`（默认）、`bim`（别名 `tmsl`）、`database.json`、`pbip`。
 - `--force` - 覆盖目标路径下任何现有文件或目录。
 
 ```bash
@@ -214,14 +242,18 @@ te init ./existing-dir --force                            # Overwrite non-empty
 
 `te set` 接受以下参数：
 
-- `-q <property>` - 属性名称（例如 `expression`、`formatString`、`description`、`isHidden`）。
-- `-i <value>` - 值（使用 `-` 可从 stdin 读取）。
+- `-q <property>` - 属性名称（例如 `expression`、`formatString`、`description`、`isHidden`）。 **可重复** - 将每个 `-q` 与其后紧跟的 `-i` 配对，即可在一条命令中设置多个属性。
+- `-i <value>` - 值（使用 `-` 可从 stdin 读取）。 每个 `-q` 对应一个 `-i`。
+- `-t, --type <kind>` - 用于在同一路径可能解析为多种对象类型时消除歧义（`度量值`、`Column`、`CalculatedColumn`、`Hierarchy`、`Calendar`、`分区`、`CalculationItem`）。
 - `--save` / `--save-to <path>` - 保存更改。
+- `--serialization <fmt>` - 保存时覆盖序列化格式（`tmdl`、`bim`（别名 `tmsl`）、`database.json`）。
+- `--force` - 即使修改引入 DAX 验证错误，也会保存。
 
 ```bash
 te set Sales/Amount -q expression -i "SUM(Sales[Amt])" --save
 te set "'Net Sales'[Sales Amount]" -q formatString -i "#,0" --save   # DAX form with spaced names
 te set Sales -q isHidden -i true --save
+te set Sales/Amount -q formatString -i "#,0" -q description -i "Net sales" --save   # Multi-property
 ```
 
 ### add
@@ -231,7 +263,15 @@ te set Sales -q isHidden -i true --save
 `te add` 支持以下选项：
 
 - `-t, --type <type>` - 指定对象类型。 常用值：`Table`、`Measure`、`Column`、`CalculatedColumn`、`Hierarchy`、`Role`、`Perspective`、`Culture`、`CalculationGroup`、`CalculationItem`。 支持 Tab 自动补全；可通过运行 `te add --help` 获取完整列表。
+- `-i <value>` - 要赋给新对象的表达式或值（度量值/计算列使用 DAX，分区使用 M，等等）。 与 `-q` 搭配使用，可在同一条命令中为新对象设置其他属性。
+- `-q <property>` - 要在新对象上设置的其他属性（可重复；与 `-i` 搭配使用）。
+- `--file <path>` - 从文件读取 `-i` 的表达式，而不是直接写在命令里。
+- `--mode <mode>` - 新表的存储模式：`import`（默认）、`directQuery`、`dual`、`directLake`。
 - `--if-not-exists` - 如果对象已存在，则直接以 `0` 退出且不报错。 可用于幂等的 CI/CD 管道。
+- `--save` / `--save-to <path>` - 保存更改。
+- `--serialization <fmt>` - 保存时覆盖序列化格式（`tmdl`、`bim`（别名 `tmsl`）、`database.json`）。
+- `--source-type <kind>` - 新表的初始分区源类型：`m`、`query` 或 `calculated`。 这会覆盖启发式检测结果。 `calculated` 仅在与 `-t CalculatedTable` 搭配使用时有效。
+- `--force` - 即使修改引入 DAX 验证错误，也会保存。
 
 ```bash
 te add Sales/Revenue -t Measure -i "SUM(Sales[Amount])" --save
@@ -244,32 +284,42 @@ te add Roles/Reader -t Role --save                                         # New
 
 对于数据绑定表，`te add` 还支持从 SQL、Lakehouse 或 Warehouse 源推断架构。 有关 `--source`、`--endpoint`、`--source-table`、`--columns` 等参数，可查看 `te add --help`。
 
-### rm
+### 删除
 
-删除对象。 默认会检查依赖对象，以避免破坏现有引用。
+删除对象。 默认会检查依赖对象，以避免破坏现有引用。 （别名：`rm`。）
 
-`te rm` 接受：
+`te remove` 支持以下参数：
 
-- `<path>` — 位置参数：要删除的对象。
-- `--force` — 跳过依赖对象检查。
-- `--if-exists` — 如果对象不存在，则直接以 `0` 退出且不报错。 可用于幂等的 CI/CD 管道。
-- `--dry-run` — 预览删除操作而不实际执行。
-- `--save` — 将更改保存到已加载的模型。
+- `<path>` - 位置参数：要删除的对象。
+- `-t, --type <kind>` - 当路径匹配到表下的多个子对象时，用于消除歧义（例如同名的列和层次结构）。
+- `--force` - 跳过依赖对象检查。
+- `--if-exists` - 如果对象不存在，则直接以 `0` 退出且不报错。 可用于幂等的 CI/CD 管道。
+- `--dry-run` - 预览删除操作而不实际执行。
+- `--save` / `--save-to <path>` - 保存更改。
+- `--serialization <fmt>` - 保存时覆盖序列化格式（`tmdl`、`bim`（别名 `tmsl`）、`database.json`）。
 
 ```bash
-te rm Sales/Revenue --save
-te rm "'Sales'[Revenue]" --save              # DAX form
-te rm Sales/Revenue --dry-run                # Preview only
-te rm Sales/OldMeasure --if-exists --save    # Idempotent
+te remove Sales/Revenue --save
+te remove "'Sales'[Revenue]" --save              # DAX form
+te remove Sales/Revenue --dry-run                # Preview only
+te remove Sales/OldMeasure --if-exists --save    # Idempotent
 ```
 
-### mv
+### 移动
 
-移动或重命名模型对象。 源和目标都是 `<path>` 参数。
+移动或重命名模型对象。 源和目标都是 `<path>` 参数。 （别名：`mv`、`rename`。）
+
+`te move` 支持以下参数：
+
+- `-t, --type <kind>` - 当源路径匹配到多种对象类型时，用于消除歧义（例如同名的列和层次结构）。
+- `--save` / `--save-to <path>` - 保存更改。
+- `--serialization <fmt>` - 保存时覆盖序列化格式（`tmdl`、`bim`（别名 `tmsl`）或 `database.json`）。
+- `--force` - 即使该变更会引入 DAX 验证错误，也仍会保存。
 
 ```bash
-te mv Sales/Revenue Finance/Revenue --save    # Move measure to another table
-te mv Sales/Revenue Sales/TotalRevenue --save # Rename measure
+te move Sales/Revenue Finance/Revenue --save                # Move measure to another table
+te move Sales/Revenue Sales/TotalRevenue --save             # Rename measure
+te move Sales/Date Sales/CalendarDate -t Hierarchy --save   # Disambiguate hierarchy from column
 ```
 
 ### replace
@@ -284,7 +334,7 @@ te mv Sales/Revenue Sales/TotalRevenue --save # Rename measure
 - `--dry-run` - 仅预览更改，不会实际应用。 默认行为。
 - `--save` - 将变更保存回源位置。 与 `--revert` 和 `--stage` 互斥。
 - `--save-to <path>` - 保存到不同的路径（意味着 `--save`）。
-- `--serialization <fmt>` - 模型序列化格式：`tmdl`、`bim`、`te-folder`。
+- `--serialization <fmt>` - 模型序列化: `tmdl`、`bim` (别名 `tmsl`)、`database.json`。
 - `--force` - 即使替换引入 DAX 验证错误，也会保存。
 
 `--in expressions` 会遍历所有包含表达式的属性：
@@ -305,31 +355,31 @@ te replace "SUM" "SUMX" --regex --in expressions --save
 
 ## 检查
 
-### ls
+### list
 
-以类似文件系统的导航方式列出对象。 接受一个支持通配符的 `<path-filter>` 参数。 同时支持模型级容器（`Tables`, `Measures`, `Columns`, `Hierarchies`, `Relationships`, `Roles`, `Perspectives`, `Cultures`）以及表范围容器（`Sales/Measures`, `Sales/Columns`, …） 均受支持。
+以类似文件系统的导航方式列出对象。 接受一个支持通配符的 `<path-filter>` 参数。 支持模型级容器和表作用域容器——完整列表见上方的[容器关键字表](#containers-and-keywords)。 （别名：`ls`。）
 
-`te ls` 支持：
+`te list` 支持：
 
 - `--type <kind>` - 限定为一种对象类型（`table`, `measure`, `column`, `hierarchy`, `partition`, `relationship`, `role`, `perspective`, `culture`）。 如果不提供 `<path-filter>`，这等同于输入匹配的容器关键字。
 - `--paths-only` - 每行输出一个对象路径，适合通过管道传给 `xargs`、`te get` 或 `te set`。
 - `--no-multiline` - 将多行单元格（通常是 DAX 或 M 表达式）折叠为单行并截断，让宽表中的各行仍便于浏览。 仅影响文本输出；JSON/CSV/TMSL 输出不受影响。
-- `--output-format tmsl`（别名 `bim`）- 将匹配的对象输出为 TMSL/BIM 脚本。 例如可用于 `te ls Tables --output-format bim > tables.json`。 `ls` 不支持 `--output-format tmdl`（TMDL 仅支持单对象输出——请使用 `te get`）。
+- `--output-format tmsl`（别名 `bim`）- 将匹配的对象输出为 TMSL/BIM 脚本。 适用于 `te list Tables --output-format bim > tables.json`。 `ls` 不支持 `--output-format tmdl`（TMDL 仅支持单对象输出——请使用 `te get`）。
 
 ```bash
-te ls                                     # All tables in the model
-te ls Sales                               # All children of Sales (columns + measures + hierarchies + partitions)
-te ls Sales/Measures                      # Just Sales's measures
-te ls 'Sales/*Amount'                     # Children of Sales whose name ends with Amount
-te ls 'Sa*'                               # Tables whose name starts with Sa (no auto-expansion)
-te ls '*/Amount'                          # An Amount column/measure across every table
-te ls 'Roles/Re*/Members'                 # Members of every role matching Re*
-te ls Sales/Geography/Levels              # All levels of the Geography hierarchy
-te ls "'Net Sales'/'Sales Amount'"        # Quote names containing spaces
-te ls Measures --paths-only               # One Table/Measure per line for piping
-te ls --type measure                      # Same as `te ls Measures`
-te ls Measures --no-multiline             # Wide table with column dividers, single-line DAX
-te ls Tables --output-format bim > tables.json   # All tables emitted as TMSL/BIM
+te list                                     # All tables in the model
+te list Sales                               # All children of Sales (columns + measures + hierarchies + partitions)
+te list Sales/Measures                      # Just Sales's measures
+te list 'Sales/*Amount'                     # Children of Sales whose name ends with Amount
+te list 'Sa*'                               # Tables whose name starts with Sa (no auto-expansion)
+te list '*/Amount'                          # An Amount column/measure across every table
+te list 'Roles/Re*/Members'                 # Members of every role matching Re*
+te list Sales/Geography/Levels              # All levels of the Geography hierarchy
+te list "'Net Sales'/'Sales Amount'"        # Quote names containing spaces
+te list Measures --paths-only               # One Table/Measure per line for piping
+te list --type measure                      # Same as `te list Measures`
+te list Measures --no-multiline             # Wide table with column dividers, single-line DAX
+te list Tables --output-format bim > tables.json   # All tables emitted as TMSL/BIM
 ```
 
 ### get
@@ -343,7 +393,7 @@ te ls Tables --output-format bim > tables.json   # All tables emitted as TMSL/BI
 - `--output-format tmsl`（别名 `bim`）- 将解析后的对象输出为 TMSL/BIM JSON。
 - `--output-format tmdl` - 将解析后的对象输出为 TMDL（仅限命名对象）。
 
-`te get` 和 `te ls` 共用同一个描述符目录，因此无论输出为哪种格式，属性的呈现方式都一致：文本表格、JSON 和 CSV 显示的都是同一组属性；给模型新增属性后，也会在所有格式中自动可见。
+`te get` 和 `te list` 共用同一个描述符目录，因此无论输出为哪种格式，属性的呈现方式都一致：文本表格、JSON 和 CSV 显示的都是同一组属性；给模型新增属性后，也会在所有格式中自动可见。
 
 ```bash
 te get Sales/Amount -q expression                # Print DAX
@@ -381,6 +431,12 @@ te find "CALCULATE" --in expressions --paths-only | xargs -I{} te get {} -q expr
 ```bash
 te diff ./model-v1 ./model-v2
 te diff old.bim new.bim
+
+# Branch on exit code (POSIX sh):
+te diff ./a ./b; case $? in 0) echo same;; 1) echo different;; *) echo error;; esac
+
+# Branch on exit code (PowerShell):
+te diff ./a ./b; switch ($LASTEXITCODE) { 0 { 'same' } 1 { 'different' } default { 'error' } }
 ```
 
 ### deps
@@ -427,6 +483,9 @@ te validate --ci github --trx results.trx
 te validate --errors-only                 # Hide warnings and anti-pattern hints
 ```
 
+> [!NOTE]
+> `te validate` 不支持 `--output-format csv`——CSV 会在一开始就被拒绝，并给出可操作的错误提示，而不是生成不完整的结果。 验证输出使用 `text` 或 `json`。
+
 ### bpa run
 
 针对模型运行 Best Practice Analyzer 规则。
@@ -445,8 +504,8 @@ te validate --errors-only                 # Hide warnings and anti-pattern hints
 - `--fix` - 应用修复表达式，在可能的情况下自动修复违规项。
 - `--save` - 应用修复后，将模型保存回原始位置。
 - `--save-to <path>` - 应用修复后，将模型保存到其他路径。
-- `--serialization <fmt>` - 模型序列化格式：`tmdl`、`bim`、`te-folder`。
-- `--fail-on <severity>` - 失败阈值：`error`（默认）或 `warning`。 当违规项达到该阈值时，将以退出代码 `1` 退出。
+- `--serialization <fmt>` - 模型序列化: `tmdl`、`bim` (别名 `tmsl`)、`database.json`。
+- `--fail-on <severity>` - 失败阈值：`error`（默认）或 `warning`。 当违规项达到该阈值时，将以退出代码 `1` 退出。 无论 `--fail-on` 如何设置，规则加载或求值错误（表达式无效、规则文件无法读取）也会导致命令以非零状态退出。
 - `--ci <fmt>` - 向 stderr 输出 CI 日志命令：`vsts`（Azure DevOps）、`github`（GitHub Actions）。
 - `--trx <path>` - 将结果作为 VSTEST `.trx` 文件写入指定路径。
 - `--no-multiline` - 将违规表中的多行单元格内容折叠为单行。 仅文本输出。
@@ -485,17 +544,17 @@ Rules loaded: 41 from 1 file(s) from bpa.rules config + built-in defaults + mode
 
 子命令：
 
-| 子命令                             | 用途                           |
-| ------------------------------- | ---------------------------- |
-| `add <id> [model]`              | 添加新的 BPA 规则。                 |
-| [`disable`](#bpa-rules-disable) | 为当前用户禁用一条内置 BPA 规则。          |
-| [`enable`](#bpa-rules-enable)   | 重新启用先前已禁用的内置 BPA 规则。         |
-| `ignore <rule-id> [model]`      | 将规则添加到模型的忽略列表。               |
-| [`init`](#bpa-rules-init)       | 在解析后的 PATH 下创建一个空的 BPA 规则文件。 |
-| [`list`](#bpa-rules-list)       | 列出来自所有来源的 BPA 规则及其状态。        |
-| `rm <rule-id> [model]`          | 删除一条 BPA 规则。                 |
-| `set <rule-id> [model]`         | 更新 BPA 规则的属性。                |
-| `unignore <rule-id> [model]`    | 从模型的忽略列表中移除一条规则。             |
+| 子命令                                 | 用途                           |
+| ----------------------------------- | ---------------------------- |
+| `add <id> [model]`                  | 添加新的 BPA 规则。                 |
+| [`disable`](#bpa-rules-disable)     | 为当前用户禁用一条内置 BPA 规则。          |
+| [`enable`](#bpa-rules-enable)       | 重新启用先前已禁用的内置 BPA 规则。         |
+| `ignore <rule-id> [model]`          | 将规则添加到模型的忽略列表。               |
+| [`init`](#bpa-rules-init)           | 在解析后的 PATH 下创建一个空的 BPA 规则文件。 |
+| [`list`](#bpa-rules-list)（别名 `ls`）  | 列出来自所有来源的 BPA 规则及其状态。        |
+| `remove <rule-id> [model]`（别名 `rm`） | 删除一条 BPA 规则。                 |
+| `set <rule-id> [model]`             | 更新 BPA 规则的属性。                |
+| `unignore <rule-id> [model]`        | 从模型的忽略列表中移除一条规则。             |
 
 `te bpa rules` 的所有子命令都接受以下选项：
 
@@ -503,7 +562,7 @@ Rules loaded: 41 from 1 file(s) from bpa.rules config + built-in defaults + mode
 - `--model-rules` - 操作嵌入在模型注释中的规则，而非文件中的规则。
 
 > [!IMPORTANT]
-> `te bpa rules set` 和 `te bpa rules rm` 会拒绝修改内置规则 ID。 如果尝试这样做，命令将以退出码 `1` 退出，并提示改用 `te bpa rules disable`。 要自定义内置规则的行为，先禁用该内置规则，再添加一个使用不同 ID 的自定义副本：
+> `te bpa rules set` 和 `te bpa rules remove` 会拒绝修改内置规则 ID。 如果尝试这样做，命令将以退出码 `1` 退出，并提示改用 `te bpa rules disable`。 要自定义内置规则的行为，先禁用该内置规则，再添加一个使用不同 ID 的自定义副本：
 >
 > ```bash
 > te bpa rules disable TE3_BUILT_IN_DATE_TABLE_EXISTS
@@ -512,7 +571,7 @@ Rules loaded: 41 from 1 file(s) from bpa.rules config + built-in defaults + mode
 
 #### bpa rules list
 
-列出来自所有来源的规则（内置、用户、模型）。
+列出来自所有来源的规则（内置、用户、模型）。 （别名：`ls`。）
 
 `te bpa rules list` 接受以下选项：
 
@@ -532,7 +591,7 @@ te bpa rules list --ignored
 
 #### bpa rules init
 
-在配置的 PATH 处创建一个空的 BPA 规则文件（`[]`）。 在对尚不存在的路径执行 `te bpa rules set` / `te bpa rules rm` 之前，请先执行一次此命令。
+在配置的 PATH 处创建一个空的 BPA 规则文件（`[]`）。 在对尚不存在的路径执行 `te bpa rules set` / `te bpa rules remove` 之前，先运行一次这个命令。
 
 `te bpa rules init` 接受以下选项：
 
@@ -547,11 +606,44 @@ te bpa rules init --rules-file ./MyRules.json
 te bpa rules init --force
 ```
 
+#### bpa rules add / set / remove / ignore / unignore
+
+修改规则文件（`add`、`set`、`remove`（别名 `rm`））或模型内嵌的忽略列表（`ignore`、`unignore`）。 这三个修改型子命令都针对 `--rules-file <path>` 或 `--model-rules` 操作，并且会拒绝修改内置规则 ID。
+
+- `te bpa rules add <id>` - 创建新规则。 将每个属性作为命名选项传入：
+  - `--name <text>` - 便于阅读的规则名称（必填）。
+  - `--scope <list>` - 规则适用的对象类型（以逗号分隔）：`度量值`、`Column`、`Table`、`Hierarchy`、`分区`、`Relationship`、`Role`、`Perspective`、`Culture` 等 (必填)。
+  - `--expression <text>` - Dynamic LINQ 谓词。 对于违反规则的对象，返回 `true`（必需）。
+  - `--category <text>` - 分组标签（例如 `Performance`、`Naming`、`DAX Expressions`）。
+  - `--severity <1|2|3>` - `1`（信息）、`2`（警告，默认）、`3`（错误）。
+  - `--description <text>` - 规则触发时向用户显示的说明。
+  - `--fix-expression <text>` - `te bpa run --fix` 用于自动修复的 Dynamic LINQ 表达式。
+- `te bpa rules set <id>` - 更新现有规则的属性。 使用 `-q <property> -i <value>` 参数对（可重复）。 属性名称：`name`、`expression`、`scope`、`category`、`severity`、`description`、`fixExpression`。
+- `te bpa rules remove <id>` - 删除规则。
+- `te bpa rules ignore <id>` - 将规则 ID 添加到模型的 `BestPracticeAnalyzer_IgnoreRules` 注解中。
+- `te bpa rules unignore <id>` - 从模型的忽略列表中移除规则 ID。
+
+```bash
+# Add a rule: measures that are not hidden and have no description
+te bpa rules add MEASURE_NEEDS_DESCRIPTION \
+    --name "Measures should have a description" \
+    --scope Measure \
+    --expression "not IsHidden and string.IsNullOrEmpty(Description)" \
+    --severity 2 \
+    --category Metadata
+
+# Update severity on an existing rule
+te bpa rules set MEASURE_NEEDS_DESCRIPTION -q severity -i 3
+
+# Remove the rule
+te bpa rules remove MEASURE_NEEDS_DESCRIPTION
+```
+
 #### bpa rules disable
 
 禁用单个内置 BPA 规则。 该规则 ID 会添加到 CLI 配置中的 `bpa.disabledBuiltInRuleIds`。 后续的门禁执行（deploy、save、mutation）以及 `te bpa run` 都会跳过已禁用的规则。
 
-该命令是幂等的——对已禁用的规则再次运行 `disable` 会成功，但不会修改配置。 如果 `<rule-id>` 不是内置规则，命令会以退出代码 `1` 结束；可使用 `te bpa rules list` 查看有效的内置 ID。
+该命令是幂等的——对已禁用的规则再次运行 `disable` 也会成功，且不会修改配置。 如果 `<rule-id>` 不是内置规则，命令会以退出代码 `1` 结束；可使用 `te bpa rules list` 查看有效的内置 ID。
 
 ```bash
 te bpa rules disable TE3_BUILT_IN_DATE_TABLE_EXISTS
@@ -571,6 +663,7 @@ te bpa rules enable TE3_BUILT_IN_DATE_TABLE_EXISTS
 
 `te vertipaq` 支持：
 
+- `<path>` - 可选的位置参数：表名，用于将分析范围限定在单个表上。
 - `--columns`, `--relationships`, `--partitions`, `--all`。
 - `--detail` - 显示扩展列（数据/字典/层次结构大小明细、编码、分段）。
 - `--fields <list>` - 要显示的字段，以逗号分隔（例如：`--fields name,card,size,%tbl,%db,bar`）。 可用字段因视图而异。
@@ -578,10 +671,12 @@ te bpa rules enable TE3_BUILT_IN_DATE_TABLE_EXISTS
 - `--import <file.vpax>` - 加载之前导出的 `.vpax` 文件并进行离线分析。
 - `--obfuscate` - 对导出的 VPAX 中的名称和表达式进行混淆处理。
 - `--top <N>`、`--stats`、`--annotate`、`--save`。
+- `--auth <method>` - 连接到远程模型时，用于覆盖默认的身份验证方法。
 
 ```bash
-te vertipaq                    # Columns by size (default)
-te vertipaq --all              # Tables, columns, relationships, partitions
+te vertipaq                      # Columns by size (default)
+te vertipaq Sales                # Stats limited to the Sales table
+te vertipaq --all                # Tables, columns, relationships, partitions
 te vertipaq --export stats.vpax
 te vertipaq --import stats.vpax  # Analyze offline
 ```
@@ -616,7 +711,8 @@ te format --lang m --save                                  # Format M
 
 `te query` 支持以下选项：
 
-- `-q, --query <dax>` - 内联查询。
+- `<dax>` - 位置参数：要执行的 DAX 查询。 等同于传入 `-q`。 选择你觉得更易读的写法即可；如果两者都提供，以显式的 `-q` 为准。
+- `-q, --query <dax>` - 内联查询（即上述位置参数的命名参数形式）。
 - `--file <file.dax>` - 从文件读取查询。
 - `--limit <N>` - 默认为 100。
 - `-o, --output-file <path>` - 将结果写入文件（`.csv`、`.tsv`、`.json`、`.dax`）。
@@ -624,7 +720,8 @@ te format --lang m --save                                  # Format M
 - `--no-validate` - 跳过执行前的 DAX 语义验证。
 
 ```bash
-te query -q "EVALUATE TOPN(5, 'Sales')" -s my-ws -d my-model
+te query "EVALUATE TOPN(5, 'Sales')" -s my-ws -d my-model           # Positional DAX
+te query -q "EVALUATE TOPN(5, 'Sales')" -s my-ws -d my-model        # Named-flag form
 te query --file query.dax --output-format json
 ```
 
@@ -681,14 +778,28 @@ echo "Info(Model.Name);" | te script -e -
 
 | 子命令                                | 用途                  |
 | ---------------------------------- | ------------------- |
-| `list`                             | 列出宏。                |
+| `list`（别名 `ls`）                    | 列出宏。                |
 | 宏：[`run <name-or-id>`](#macro-run) | 运行宏。                |
 | `add <name>`                       | 添加宏。                |
 | `set <name-or-id>`                 | 更新宏属性。              |
-| `rm <name-or-id>`                  | 删除宏。                |
+| `remove <name-or-id>`（别名 `rm`）     | 删除宏。                |
 | `sort`                             | 排序并重新分配 ID。         |
 | 宏：[`init`](#macro-init)            | 在解析得到的路径处创建一个空的宏文件。 |
 
+#### 宏：add / set / remove
+
+修改宏文件 (`add`、`set`、`remove` (别名 `rm`))。 这三个命令都操作 `--macros <path>`（或解析得到的宏文件）。
+
+- `te macro add <name>` - 创建新宏。 使用 `-e "<code>"`（内联）或 `-s <file.cs>`（脚本文件）提供脚本主体。 可选：`--tooltip <text>`、`--contexts <list>`（宏适用的上下文，例如 `Table,Measure`，即“表、度量值”）、`--enabled true|false`。
+- `te macro set <name-or-id>` - 更新宏属性。 使用成对的 `-q <property> -i <value>` 参数（可重复）。 属性名称：`name`、`execute`、`enabled`、`tooltip`、`validContexts`。
+- `te macro remove <name-or-id>` - 删除宏。
+
+```bash
+te macro add MyMacro -e "Info(Selected.Measure.Name);" --tooltip "Print measure name" --contexts Measure
+te macro set MyMacro -q tooltip -i "Updated tooltip"
+te macro remove MyMacro
+```
+
 #### macro init
 
 在配置的路径下创建一个空的宏文件（`{\"Actions\":[]}`）。 当解析后的宏文件尚不存在时，只需运行一次该命令。
@@ -742,7 +853,7 @@ te macro run "Format DAX" --on "'Net Sales'[Sales Amount]" --save   # DAX form w
 - `--bpa-rules <PATH>` - 可重复指定；仅针对本次部署覆盖 CLI 配置中的 `bpa.rules`。 除非 `bpa.builtInRules` 为 `false`，否则内置规则仍会生效。
 - `--force` - 跳过交互式确认（CI 必需）。
 - `--ci <fmt>` - `vsts` 或 `github`。
-- `--profile <name>` - 一次性使用已保存的 @te-cli-auth 配置文件。
+- `-p, --profile <name>` - 一次性使用已保存的 @te-cli-auth 配置文件。
 
 ```bash
 te deploy ./model -s my-workspace -d my-model --force --ci github
@@ -753,18 +864,21 @@ te deploy ./model --profile staging --force
 > [!IMPORTANT]
 > `te deploy` 会在执行前运行 Best Practice Analyzer 作为门控检查。 在交互模式下，会显示摘要和确认提示，且 **默认安全选项为 `n`**。 在 CI 中，传入 `--force` 可跳过该提示。 BPA 门控配置请参见 @te-cli-config。
 
+> [!NOTE]
+> 当设置 `--output-format json` 时，`te deploy` 的 JSON 输出始终包含解析后的 `server` 和 `database`，即使它们是从活动连接或配置文件中解析得到的，而不是显式传入的。 管道可使用这些字段来确认部署目标，而无需重新解析命令行。 在使用 `--output-format json` 时，`te deploy` 和 `te format` 失败时也会以非零退出码退出，这与其文本模式下的行为一致——JSON 输出记录的是失败信息，而不是成功信号。
+
 ### refresh
 
 在已部署的模型上触发数据刷新。
 
 `te refresh` 支持：
 
-- `--type <type>` - `full`、`dataonly`、`automatic`、`calculate`、`clearvalues`、`defragment`、`add`（默认值：`automatic`）。
+- `--type <type>` - `full`、`dataonly`（别名 `data-only`、`data`）、`automatic`（别名 `auto`）、`calculate`（别名 `calc`）、`clearvalues`（别名 `clear`）、`defragment`（别名 `defrag`）、`add`（默认值：`automatic`）。
 - `--table <name>` - 刷新特定表(可为多个)；可重复指定。
 - `--partition <Table.Partition>` - 刷新特定分区(可为多个)。
 - `--apply-refresh-policy` - 应用增量刷新的刷新策略，以确定要刷新的分区。
 - `--effective-date <yyyy-MM-dd>` - 设置刷新策略使用的生效日期。
-- `--max-parallelism <N>` - 设置可并行刷新的最大分区数。
+- `--max-parallelism <N>` - 设置可并行刷新的最大分区数。 将刷新封装在 TMSL `sequence` 命令中。
 - `--dry-run` - 输出 TMSL 脚本而不执行。
 - `--no-progress`, `--trace [path]`。
 
@@ -782,7 +896,7 @@ te refresh --type full --dry-run > refresh.tmsl         # Emit TMSL only
 te incremental-refresh show <table>
 ```
 
-其他子命令（`set`、`rm`、`apply`）可通过 `te incremental-refresh --help` 查看说明。
+其他子命令（`set`、`remove`（别名 `rm`）、`apply`）可通过 `te incremental-refresh --help` 查看说明。
 
 ## 测试
 
@@ -804,6 +918,8 @@ te test run --tag revenue
 
 ### test init / spec / use / list / snapshot / compare
 
+`te test list` 也支持使用 `ls` 作为别名。
+
 其他子命令可用于搭建测试脚手架、打印断言规范格式、切换当前活动套件、列出套件、捕获快照以及比较模型。 查看 `te test --help` 了解详情。
 
 ```bash
@@ -819,12 +935,14 @@ te test init --from-model --model ./my-model  # Generate stubs from your measure
 设置（或显示）当前终端会话的活动连接。 查看 @te-cli-auth。
 
 ```bash
-te connect                         # Show current active connection
-te connect my-workspace my-model   # Remote
-te connect ./model                 # Local
-te connect --local                 # Power BI Desktop (Windows)
-te connect --profile prod          # Activate a saved profile
-te connect --clear                 # Clear the active connection (and any workspace mirror)
+te connect                                # Show current active connection
+te connect my-workspace my-model          # Remote (positional)
+te connect -s my-workspace -d my-model    # Remote (named-flag form)
+te connect ./model                        # Local
+te connect --local                        # Power BI Desktop (Windows)
+te connect --local my-report              # Filter by report name (multiple PBI Desktop instances)
+te connect --profile prod                 # Activate a saved profile
+te connect --clear                        # Clear the active connection (and any workspace mirror)
 ```
 
 #### 工作区模式（`-w` / `--workspace`）
@@ -833,11 +951,11 @@ te connect --clear                 # Clear the active connection (and any worksp
 
 - `te connect <ws> <model> -w ./src` - 主源为远程；`./src` 会接收初始 TMDL 导出，并在每次保存时保持镜像同步。
 - `te connect ./src -w <ws> <model>` - 主源为本地；首次部署会将模型推送到 Workspace，后续保存会自动重新部署。
-- `--workspace-format <bim|tmdl>` - 在镜像到文件夹/文件时选择磁盘上的格式（例如，`-w ./model.bim` 会推断为 BIM）。
+- `--workspace-format <fmt>` - 将内容镜像到文件夹/文件时，选择磁盘上的格式：`tmdl`、`bim`（别名 `tmsl`）或 `database.json`。 若省略，则会根据 Workspace 目标路径推断格式（例如，`-w ./model.bim` 会推断为 BIM）。
 - `--workspace-auth <method>` - 当主目标为本地时，为远程 Workspace 目标指定身份验证方式。 若设置了 `--auth`，则默认与其一致；否则默认为 `auto`。
 - `--force` - 当目标已存在（例如文件夹非空或数据库已存在）时必须使用。 如果不使用它，`te connect` 会显示交互式 `y/n` 提示，并以 `n` 作为安全的默认选项。
 
-启用后，`te set --save`、`te rm --save`、`te script --save` 等都会透明地同时保存到本地和远程。 保存顺序始终是 **先本地，后远程**，因此即使推送到服务器失败，磁盘上的副本也会反映最新的用户更改。 使用 `te connect --clear` 清除镜像。
+启用后，`te set --save`、`te remove --save`、`te script --save` 等都会透明地进行双重保存。 保存顺序始终是 **先本地，后远程**，因此即使推送到服务器失败，磁盘上的副本也会反映最新的用户更改。 使用 `te connect --clear` 清除镜像。
 
 ```bash
 te connect Finance "Revenue Model" -w ./revenue-model    # Mirror remote → local TMDL
@@ -850,25 +968,21 @@ te connect ./revenue-model -w Finance "Revenue Model"    # Mirror local → remo
 
 ### profile list / show / set / remove
 
-管理命名连接配置文件。 参见 @te-cli-auth。
+管理命名连接配置文件。 （`te profile list` 的别名：`ls`；`te profile remove` 的别名：`rm`。） 参见 @te-cli-auth。
 
 ## 配置
 
-### config show / paths / init / set
+### config list / paths / init / set
 
-查看和管理 CLI 配置以及 TE3 PATH 覆盖设置。 参见 @te-cli-config。
+查看和管理 CLI 配置以及 TE3 PATH 覆盖设置。 （`te config list` 的别名是 `ls`。） 参见 @te-cli-config。
 
 ```bash
-te config show                          # Display all settings
+te config list                          # Display all settings
 te config paths                         # Resolved TE3 file paths
 te config init                          # Create default config
 te config set autoFormat true
 ```
 
-### license
-
-`te license` 保留用于正式发布 GA 版，在此预览版本中不可用。 这个命令仍会被解析器识别——所以调用它的现有脚本不会在解析阶段报错——但所有子命令都会以状态 `1` 退出，并显示“此预览版本中不可用”的信息。 关于更全面的许可说明，请参见概述页面上的[预览说明](xref:te-cli#preview-notice)。
-
 ### migrate
 
 说明旧版 Tabular Editor 2 CLI 参数如何映射到新 CLI 的参考指南。 在迁移基于 TE2 的管道时，可作为实时速查参考。 完整迁移指南参见 @te-cli-migrate。
@@ -885,10 +999,22 @@ te migrate --output-format json     # Machine-readable mapping
 
 使用具备模型感知能力的提示词启动引导式 REPL 会话。 参见 @te-cli-interactive。
 
+> [!TIP]
+> 在终端中直接运行不带任何参数的 `te`，默认也会进入 REPL（就像运行 `te interactive` 一样）。 此行为由 `launchInteractiveMode` 配置项控制，参见 @te-cli-interactive#auto-launch-on-empty-invocation。
+
+`te interactive` 接受以下选项：
+
+- `<model>` - 可选位置参数：启动会话时加载本地模型、`.bim` 文件或 `.SemanticModel` 文件夹。
+- `--no-banner` - 启动时跳过欢迎横幅。 从脚本驱动 REPL 时很有用。
+- `--echo` - 在输出结果之前，将每条已执行命令回显到 stdout。 当通过 stdin 管道传入命令时很有帮助，这样日志会显示实际运行了什么。
+- `--batch` - 非交互式批处理模式：逐行从 stdin 读取命令，执行每条命令，并在 EOF 时退出。 当 stdin 被重定向时会自动启用。
+- `--no-batch` - 即使 stdin 被重定向，也强制使用交互式 TTY 模式（与 `--batch` 互斥）。
+
 ```bash
 te interactive                                # Connect later
 te interactive ./model                        # Start with a local model
 te interactive -s MyWorkspace -d MyModel      # Start with a remote model
+printf "list Measures\nexit\n" | te interactive ./model   # Pipe commands via stdin
 ```
 
 引号和 DAX 风格的引用在会话内外的用法一致——有关 REPL 中支持括号感知的 argv 拆分的详细信息，请参见上文的[对象路径](#object-paths)一节以及 @te-cli-interactive。
@@ -899,12 +1025,12 @@ te interactive -s MyWorkspace -d MyModel      # Start with a remote model
 
 子命令：
 
-| 子命令     | 用途                                       |
-| ------- | ---------------------------------------- |
-| `show`  | 显示当前会话的详细信息（ID、文件路径、活动状态）。 未提供子命令时的默认行为。 |
-| `list`  | 列出所有会话文件。                                |
-| `clear` | 清除当前会话的活动状态。                             |
-| `prune` | 删除其 shell 进程已停止运行的会话文件。                  |
+| 子命令             | 用途                                       |
+| --------------- | ---------------------------------------- |
+| `show`          | 显示当前会话的详细信息（ID、文件路径、活动状态）。 未提供子命令时的默认行为。 |
+| `list`（别名 `ls`） | 列出所有会话文件。                                |
+| `clear`         | 清除当前会话的活动状态。                             |
+| `prune`         | 删除其 shell 进程已停止运行的会话文件。                  |
 
 `te session prune` 支持以下选项：
 
@@ -932,11 +1058,11 @@ te completion fish
 
 ## 退出代码
 
-| 退出代码 | 含义                                                                         |
-| ---- | -------------------------------------------------------------------------- |
-| `0`  | 成功。                                                                        |
-| `1`  | 通用失败（参数无效、命令执行失败、校验错误、身份验证失败、BPA 门禁在严重级别 ≥ error 时未通过）。 用于 `te diff`：发现差异。 |
-| `2`  | 仅适用于 `te diff`：比较时发生错误，因此差异状态未知。                                           |
+| 退出代码 | 含义                                                                             |
+| ---- | ------------------------------------------------------------------------------ |
+| `0`  | 成功。                                                                            |
+| `1`  | 通用失败（参数无效、命令执行失败、验证错误、身份验证失败，或 BPA 关卡在严重性级别 >= error 时未通过）。 用于 `te diff`：发现差异。 |
+| `2`  | 仅适用于 `te diff`：比较时发生错误，因此差异状态未知。                                               |
 
 如需在 CI 管道中进行更细致的控制，可将退出代码与 `--ci <vsts/github>` 注释以及 `--trx` 结果文件结合使用——参见 @te-cli-cicd。
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-config.md b/localizedContent/zh/content/features/te-cli/te-cli-config.md
index 29c8744da..06d0743a3 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-config.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-config.md
@@ -19,13 +19,13 @@ applies_to:
 
 Tabular Editor CLI 可从 JSON 文件读取可选配置。 配置控制三类内容：
 
-- **文件路径** — CLI 在何处读取宏、BPA 规则和 (可选) TE3 Desktop 可执行文件，以及在何处写入查询日志。
-- **行为默认值** — BPA 门控、自动格式化、验证。
-- **已保存的连接配置文件** — 可在不同命名配置文件之间切换的列表。
+- **文件路径** — CLI 在何处读取宏、BPA 规则和（可选）TE3 Desktop 可执行文件，以及在何处写入查询日志。
+- **行为默认设置** — BPA 门禁、自动格式化、校验。
+- **已保存的连接配置文件** — 你可切换的已命名配置文件列表。
 
 CLI 是自包含的 - 它不会从任何 Tabular Editor 3 桌面版安装路径读取或写入任何内容。 BPA 规则和宏文件必须通过此配置显式设置（或按需使用 `te bpa rules init` / `te macro init` 进行初始化）。
 
-大多数用户无需直接编辑配置文件；`te config show`、`te config set <key> <value>` 和 `te profile set` 已涵盖常见操作。
+大多数用户无需直接编辑配置文件；`te config list`、`te config set <key> <value>` 和 `te profile set` 已涵盖常见操作。
 
 ## 配置文件位置
 
@@ -35,7 +35,7 @@ CLI 是自包含的 - 它不会从任何 Tabular Editor 3 桌面版安装路径
 2. `~/.config/te/config.json`（在 Windows 上为 `%USERPROFILE%\.config\te\config.json`）。
 3. 如果没有配置文件，CLI 将使用内置默认值。
 
-`TE_CONFIG` 在所有配置文件相关操作中都会被一致地遵循；`te config show`、`te config set`、`te config init` 和 `te config paths` 都会在解析后的 PATH 上进行读写。 这主要用于测试、脚本化安装以及按环境进行配置。
+所有配置文件相关操作都会一致地遵循 `TE_CONFIG`；`te config list`、`te config set`、`te config init` 和 `te config paths` 都会在解析后的路径上进行读写。 这主要用于测试、脚本化安装以及按环境进行配置。
 
 要创建默认配置：
 
@@ -47,15 +47,15 @@ te config init --force     # Overwrite existing config
 ## 查看配置
 
 ```bash
-te config show                         # Display all settings
-te config show --output-format json    # Machine-readable
+te config list                         # Display all settings
+te config list --output-format json    # Machine-readable
 te config paths                        # Show resolved macros and BPA rule paths
 ```
 
 使用 `te config paths` 查看 CLI 实际会为宏和 BPA 规则使用哪些文件。 这在调试缺失的数据文件时很有用。 输出会显示两行：`macros` (解析后的宏文件路径或 `[not set]`) 和 `bpa.rules` (由路径解析器解析出的第一个存在的 BPA 规则文件，或 `[not set]`)。
 
 > [!NOTE]
-> 在 `--output-format json` 模式下，`te config paths` 会显式输出值为 `null` 的字段 (例如 `{"macros": null, "bpa": {"rules": null}}`)。 报告解析结果本来就是此命令的全部用途，因此 `null` 表示“尝试过，但未解析到任何内容”，这是一个有意义的结果。 `te config show --output-format json` 默认会剔除值为 `null` 的字段，因此使用方应以容错方式解析。
+> 在 `--output-format json` 模式下，`te config paths` 会显式输出值为 `null` 的字段 (例如 `{"macros": null, "bpa": {"rules": null}}`)。 报告解析结果本来就是此命令的全部用途，因此 `null` 表示“尝试过，但未解析到任何内容”，这是一个有意义的结果。 `te config list --output-format json` 默认会去掉值为 null 的字段，因此使用方在解析时应采用宽松策略。
 
 ## 设置值
 
@@ -79,7 +79,7 @@ te config set macros null              # Clear a path override
 
 ```json
 {
-  "formatVersion": 1,
+  "formatVersion": 2,
   "macros": null,
   "autoFormat": false,
   "validateOnMutation": true,
@@ -95,6 +95,7 @@ te config set macros null              # Clear a path override
   },
 
   "interactiveEditMode": "stage",
+  "launchInteractiveMode": "auto",
 
   "formatOptions": {
     "useSemicolons": false,
@@ -142,18 +143,19 @@ CLI 不会自动检测 TE3 的任何安装位置——请显式配置这些项
 
 所有与 BPA 相关的设置都位于 `bpa` 对象下，并可在 `te config set` 中使用点号分隔的键进行设置。
 
-| 键名                           | 默认值     | 说明                                                                                                                                                                                                                                      |
-| ---------------------------- | ------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `autoFormat`                 | `false` | 在执行 `te add` / `te set` / `te mv` / `te macro run` 之后，对修改过的表达式运行 DAX Formatter。 默认使用内置格式化程序；可通过 `formatOptions.useSqlBiDaxFormatter` 改用 SQL BI Web 服务。                                                                                  |
-| `validateOnMutation`         | `true`  | 在执行更改命令（`add`、`set`、`mv`、`replace --save`、`macro run`）后，检查模型中的每个 `Table[Column]` 引用是否仍可解析。 可在部署前捕获因重命名或删除而引入的悬空引用。                                                                                                                      |
-| `bpa.onMutation`             | `false` | 在每次更改命令（`set`、`add`、`mv`、`rm`、`macro run`）后，运行一次限定范围的 BPA 分析。 只检查受影响表中的对象，而不是整个模型——这对于迭代编辑时获得快速反馈很有用。                                                                                                                                   |
-| `bpa.onDeploy`               | `true`  | 在执行 `te deploy` 之前运行 BPA 关卡检查。 如果有任一规则触发且严重级别 ≥ error，则中止部署。 可通过 `--skip-bpa` 在单次调用中跳过，或通过 `--fix-bpa` 自动修复。                                                                                                                            |
-| `bpa.onSave`                 | `true`  | 在 `te save -o` 写入磁盘之前运行 BPA 关卡检查。 可通过 `--skip-bpa` 或 `--force` 在单次调用中跳过。                                                                                                                                                                |
-| `bpa.builtInRules`           | `true`  | 每次运行关卡检查时，都包含精选的内置 BPA 规则集。 设为 `false` 可完全忽略内置规则；此时关卡检查只运行通过 `bpa.rules` 配置的规则以及嵌入模型中的规则。                                                                                                                                               |
-| `bpa.disabledBuiltInRuleIds` | `null`  | 要从门禁中排除的各个内置规则的 ID。 可通过 `te bpa rules disable <id>` / `te bpa rules enable <id>` 修改——优先使用这些命令，而不是直接编辑该数组。                                                                                                                               |
-| `vertipaqOnRefresh`          | `false` | 成功刷新后（`full`、`dataonly`、`automatic` 或 `add`），自动运行 VertiPaq 分析，以显示已刷新表的存储统计信息。 有助于立即发现意外的基数变化或内存回归。                                                                                                                                      |
-| `interactiveEditMode`        | `stage` | 在 `te interactive` 中对内存中变更的默认处理方式。 `stage` 会将变更保留在内存中，直到调用 `save`（最安全）；`save` 会在每次产生变更的命令后写回源（对远程源请谨慎使用——每次 `set` 都会触发一次 XMLA 写入）；`revert` 会在每条命令后丢弃变更，除非传入了 `--save` 或 `--stage`。 每个命令上的 `--save` / `--revert` / `--stage` 标志始终会覆盖此设置。 |
-| `disableTelemetry`           | `false` | 选择不参与匿名使用遥测数据收集。 CLI 会收集粗粒度的命令使用数据（命令名称、退出代码、持续时间），用于确定功能优先级。 CLI 绝不会收集模型内容、PATH 或查询文本。                                                                                                                                                 |
+| 键名                           | 默认值     | 说明                                                                                                                                                                                                                                                                                                    |
+| ---------------------------- | ------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `autoFormat`                 | `false` | 在执行 `te add` / `te set` / `te move` / `te macro run` 之后，对修改过的表达式运行 DAX Formatter。 默认使用内置格式化程序；可通过 `formatOptions.useSqlBiDaxFormatter` 改用 SQL BI Web 服务。                                                                                                                                              |
+| `validateOnMutation`         | `true`  | 在执行更改命令（`add`、`set`、`mv`、`replace --save`、`macro run`）后，检查模型中的每个 `Table[Column]` 引用是否仍可解析。 可在部署前捕获因重命名或删除而引入的悬空引用。                                                                                                                                                                                    |
+| `bpa.onMutation`             | `false` | 在每次更改命令（`set`、`add`、`mv`、`rm`、`macro run`）后，运行一次限定范围的 BPA 分析。 只检查受影响表中的对象，而不是整个模型——这对于迭代编辑时获得快速反馈很有用。                                                                                                                                                                                                 |
+| `bpa.onDeploy`               | `true`  | 在执行 `te deploy` 之前运行 BPA 关卡检查。 如果有任何规则以严重级别 >= error 触发，部署将中止。 可通过 `--skip-bpa` 在单次调用中跳过，或通过 `--fix-bpa` 自动修复。                                                                                                                                                                                        |
+| `bpa.onSave`                 | `true`  | 在 `te save -o` 写入磁盘之前运行 BPA 关卡检查。 可通过 `--skip-bpa` 或 `--force` 在单次调用中跳过。                                                                                                                                                                                                                              |
+| `bpa.builtInRules`           | `true`  | 每次运行关卡检查时，都包含精选的内置 BPA 规则集。 设为 `false` 可完全忽略内置规则；此时关卡检查只运行通过 `bpa.rules` 配置的规则以及嵌入模型中的规则。                                                                                                                                                                                                             |
+| `bpa.disabledBuiltInRuleIds` | `null`  | 要从门禁中排除的各个内置规则的 ID。 可通过 `te bpa rules disable <id>` / `te bpa rules enable <id>` 修改——优先使用这些命令，而不是直接编辑该数组。                                                                                                                                                                                             |
+| `vertipaqOnRefresh`          | `false` | 成功刷新后（`full`、`dataonly`、`automatic` 或 `add`），自动运行 VertiPaq 分析，以显示已刷新表的存储统计信息。 有助于立即发现意外的基数变化或内存回归。                                                                                                                                                                                                    |
+| `interactiveEditMode`        | `stage` | 在 `te interactive` 中对内存中变更的默认处理方式。 `stage` 会将变更保留在内存中，直到调用 `save`（最安全）；`save` 会在每次产生变更的命令后写回源（对远程源请谨慎使用——每次 `set` 都会触发一次 XMLA 写入）；`revert` 会在每条命令后丢弃变更，除非传入了 `--save` 或 `--stage`。 每个命令上的 `--save` / `--revert` / `--stage` 标志始终会覆盖此设置。                                                               |
+| `launchInteractiveMode`      | `auto`  | 控制在终端中不带任何参数运行 `te` 时，是否启动交互式 REPL。 `auto` (默认) 仅在三个流（stdin、stdout、stderr）都连接到 TTY 时才会启动 REPL，因此脚本和 CI 流水线会按常规方式解析，不会进入 REPL。 `always` 会在无论是否重定向的情况下都启动 REPL。 `never` 会完全禁用自动启动，恢复传统的空参数显示帮助行为。 全局 `--non-interactive` 标志会在单次调用中强制设为 `never`。 也可通过 `TE_INTERACTIVE` 环境变量为单次调用设置该值。 |
+| `disableTelemetry`           | `false` | 选择不参与匿名使用遥测数据收集。 CLI 会收集粗粒度的命令使用数据（命令名称、退出代码、持续时间），用于确定功能优先级。 CLI 绝不会收集模型内容、PATH 或查询文本。                                                                                                                                                                                                               |
 
 ```bash
 te config set bpa.rules "/etc/te/team.json,/etc/te/strict.json"
@@ -200,11 +202,11 @@ BPA 闸门是一道安全防线，用于防止存在规则违规的模型被保
 
 - `te deploy` 会触发闸门检查，除非传入 `--skip-bpa` 或 `bpa.onDeploy` 为 `false`。
 - `te save` 会触发闸门检查，除非传入 `--skip-bpa`（或 `--force`）或 `bpa.onSave` 为 `false`。
-- `te add`、`te set`、`te mv`、`te macro run` 仅在 `bpa.onMutation` 为 `true` 时才会运行闸门。
+- `te add`、`te set`、`te move`、`te macro run` 仅在 `bpa.onMutation` 为 `true` 时才会运行门禁检查。
 
 闸门检查会从 `bpa.rules` 加载 BPA 规则，并且默认还会加载内置规则集（由 `bpa.builtInRules` 控制）。 可通过 `bpa.disabledBuiltInRuleIds` 单独排除内置规则——可使用 `te bpa rules disable <id>` / `te bpa rules enable <id>` 管理。
 
-当闸门检查触发并发现严重性 ≥ `error` 的违规项时，命令会失败，退出代码为 `1`，并输出违规摘要。 处理选项：
+当门禁检查触发并发现严重级别 >= `error` 的违规项时，命令会失败，退出代码为 `1`，并输出违规摘要。 处理选项：
 
 - `--fix-bpa` - 在内存中将规则的 `fixExpression` 应用于部署/保存产物；不会修改源文件。
 - `--skip-bpa` - 仅对本次命令禁用闸门检查。
@@ -219,13 +221,13 @@ te bpa run ./model --fix --save     # Apply fixes to the source
 
 ### 内置 BPA 规则
 
-CLI 随附一套权威的内置 BPA 规则集，并以 JSON 资源的形式嵌入其中。 内置规则是只读的：`te bpa rules set` 和 `te bpa rules rm` 拒绝修改内置 ID，并引导用户改用 `te bpa rules disable`。 如果想自定义内置规则的行为，可以把它复制到本地规则文件中，作为一个使用不同 ID 的新规则，然后再禁用内置规则。
+CLI 随附一套权威的内置 BPA 规则集，并以 JSON 资源的形式嵌入其中。 内置规则是只读的；`te bpa rules set` 和 `te bpa rules remove` 会拒绝修改内置 ID，并提示你改用 `te bpa rules disable`。 如果想自定义内置规则的行为，可以把它复制到本地规则文件中，作为一个使用不同 ID 的新规则，然后再禁用内置规则。
 
 `bpa.builtInRules` 和 `bpa.disabledBuiltInRuleIds` 会一致地应用于部署/保存/变更的门控检查 **以及** 手动执行的 `te bpa run` 命令——通过 `te bpa rules disable` 禁用一次后，该规则将在所有场景中被排除。
 
 ## 变更后行为
 
-运行会产生变更的命令（`te add`、`te set`、`te mv`、`te replace --save`、`te macro run`）时，CLI 会自动执行以下检查：
+运行会产生变更的命令（`te add`、`te set`、`te move`、`te replace --save`、`te macro run`）时，CLI 会自动执行以下检查：
 
 1. **TOM 错误**始终会被提示。 度量值、列、分区或计算项中的无效 DAX 或 M 始终会导致命令失败。
 2. **架构验证** (`validateOnMutation`，默认值为 `true`) 会验证 DAX 中的 `Table[Column]` 引用是否仍可解析，并交叉检查元数据一致性。
@@ -238,18 +240,19 @@ CLI 随附一套权威的内置 BPA 规则集，并以 JSON 资源的形式嵌
 
 使用以下 CLI 专用环境变量来设置路径、行为和诊断。 有关 Azure 身份验证变量（`AZURE_CLIENT_ID`、`AZURE_TENANT_ID`、`AZURE_CLIENT_CERTIFICATE_PATH` 等），见 @te-cli-auth。
 
-| 变量               | 用途                                                                                                                              |
-| ---------------- | ------------------------------------------------------------------------------------------------------------------------------- |
-| `TE_CONFIG`      | 替代配置文件的路径。 所有 `te config` 操作（`show`、`set`、`init`、`paths`）都会遵循该变量的设置。                                                            |
-| `TE_MACROS_PATH` | 覆盖宏文件路径（在解析顺序中排第二，见上文）。 由 `te macro` 命令读取。                                                                                      |
-| `TE_BPA_RULES`   | 覆盖 `te bpa run` 和 `te bpa rules` 子命令使用的 BPA 规则文件/URL 列表。                                                                        |
-| `TE_BPA_CONFIG`  | 覆盖 deploy/save 门禁读取的 BPA 门禁配置 (`.te-bpa.json`) 的路径。                                                          |
-| `TE3_EXE_PATH`   | Tabular Editor 3 桌面版二进制文件的路径。 此项 **仅** 用于 `te open`；在 Linux/macOS 上或不使用 `te open` 时，可安全留空。 会回退到 `PATH` 查找。                      |
-| `TE_DEBUG`       | 设为 `1` 可全局启用调试日志（等同于 `--debug` 或配置中的 `debug: true`）。                                                                            |
-| `NO_SPINNER`     | 设为 `1` 或 `true` 可禁用动画进度指示器（可替代配置中的 `spinner: false`）。                                                                           |
-| `CI`             | 自动检测。 当设为 `1` 或 `true` 时，CLI 会禁用动画进度指示器，并切换为纯文本输出。 大多数 CI 运行器都会自动设置此项。                                                          |
-| `TE_SESSION`     | 覆盖用于活动连接状态的按终端划分的会话 ID。 适用于在同一个 shell 中运行多个相互隔离的 CLI 会话，例如并行的 CI 矩阵作业。 使用 [`te session`](xref:te-cli-commands#session) 查看并管理会话。 |
-| `TE_COMPAT`      | 设为 `te2` 可强制启用 TE2 兼容模式；参见 @te-cli-migrate。                                                                        |
+| 变量               | 用途                                                                                                                                                                          |
+| ---------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `TE_CONFIG`      | 替代配置文件的路径。 所有 `te config` 操作（`show`、`set`、`init`、`paths`）都会遵循该变量的设置。                                                                                                        |
+| `TE_MACROS_PATH` | 覆盖宏文件路径（在解析顺序中排第二，见上文）。 由 `te macro` 命令读取。                                                                                                                                  |
+| `TE_BPA_RULES`   | 覆盖 `te bpa run` 和 `te bpa rules` 子命令使用的 BPA 规则文件/URL 列表。                                                                                                                    |
+| `TE_BPA_CONFIG`  | 覆盖 deploy/save 门禁读取的 BPA 门禁配置 (`.te-bpa.json`) 的路径。                                                                                                      |
+| `TE3_EXE_PATH`   | Tabular Editor 3 桌面版二进制文件的路径。 此项 **仅** 用于 `te open`；在 Linux/macOS 上或不使用 `te open` 时，可安全留空。 会回退到 `PATH` 查找。                                                                  |
+| `TE_DEBUG`       | 设为 `1` 可全局启用调试日志（等同于 `--debug` 或配置中的 `debug: true`）。                                                                                                                        |
+| `NO_SPINNER`     | 设为 `1` 或 `true` 可禁用动画进度指示器（可替代配置中的 `spinner: false`）。                                                                                                                       |
+| `CI`             | 自动检测。 当设为 `1` 或 `true` 时，CLI 会禁用动画进度指示器，并切换为纯文本输出。 大多数 CI 运行器都会自动设置此项。                                                                                                      |
+| `TE_SESSION`     | 覆盖用于活动连接状态的按终端划分的会话 ID。 适用于在同一个 shell 中运行多个相互隔离的 CLI 会话，例如并行的 CI 矩阵作业。 使用 [`te session`](xref:te-cli-commands#session) 查看并管理会话。                                             |
+| `TE_INTERACTIVE` | 为单次调用临时覆盖 `launchInteractiveMode` 设置。 接受 `auto`、`always` 或 `never`。 适合一次性脚本：既可以在不改动配置文件的情况下启用交互式 REPL（`TE_INTERACTIVE=always`），也可以强制使用经典的空参数显示帮助行为（`TE_INTERACTIVE=never`）。 |
+| `TE_COMPAT`      | 设为 `te2` 可强制启用 TE2 兼容模式；参见 @te-cli-migrate。                                                                                                                    |
 
 ## 相关页面
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-install.md b/localizedContent/zh/content/features/te-cli/te-cli-install.md
index 896b9e6bc..4f7b7e06e 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-install.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-install.md
@@ -132,7 +132,7 @@ te config set hidePreviewNotice true
 
 ## Shell 自动补全
 
-CLI 提供适用于 **Bash**、**Zsh**、**PowerShell** 和 **Fish** 的 Tab 自动补全脚本。 选择与你使用的 shell 对应的代码块——每个代码块都会将自动补全设置为持久生效，在新的 shell 会话中也能使用。
+CLI 提供适用于 **Bash**、**Zsh**、**PowerShell** 和 **Fish** 的 Tab 自动补全脚本。 选择与你所用的 shell 相匹配的代码块——每个代码块都会为后续的新 shell 会话持久安装自动补全。
 
 ### Bash（macOS/Linux）
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-interactive.md b/localizedContent/zh/content/features/te-cli/te-cli-interactive.md
index 1510e5943..bdde16e8b 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-interactive.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-interactive.md
@@ -2,7 +2,7 @@
 uid: te-cli-interactive
 title: 交互模式
 author: Peer Grønnerup
-updated: 2026-05-12
+updated: 2026-06-26
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -29,6 +29,13 @@ te interactive ./model                      # Start with a local model
 te interactive -s MyWorkspace -d MyModel    # Start with a remote model
 ```
 
+`te interactive` 提供一些用于调整会话的标志：
+
+- `--no-banner` - 启动时跳过欢迎横幅。
+- `--echo` - 在输出结果之前，先将每条执行的命令回显到 stdout。 在用脚本驱动 REPL 时，便于记录日志。
+- `--batch` - 非交互式批处理模式：从 stdin 逐行读取命令，依次执行，并在遇到 EOF 时退出。 当 stdin 被重定向时会自动启用。
+- `--no-batch` - 即使 stdin 被重定向，也强制使用交互式 TTY 模式（与 `--batch` 互斥）。
+
 会话会打印欢迎横幅，显示当前活动模型，并将你带到一个具备模型上下文的提示符下：
 
 ![Tabular Editor CLI 交互模式会话](~/content/assets/images/features/cli/cli-interactive-mode.png)
@@ -84,6 +91,85 @@ ls 'Net Sales'/'Sales Amount'        # Quoted segments with a slash separator
 
 如果想在当前会话中为单个命令禁用提示，传入 `--non-interactive`。
 
+## 管道与重定向输入
+
+交互模式也支持通过管道传入或重定向的 stdin，因此你可以用脚本驱动同一个 REPL，而不必手动逐条输入。 每一行输入都会作为一条命令执行，就像你在提示符处输入它一样；当输入耗尽时，会话将退出（或者在读到 `exit` 这一行时退出）。
+
+```bash
+printf "ls\nexit\n" | te interactive ./model        # bash / git-bash
+te interactive ./model < script.te                  # redirected file
+```
+
+```bat
+(echo ls & echo exit) | te interactive .\model      :: Windows cmd.exe
+```
+
+以 `#` 开头的行会被视为注释并跳过，因此你可以为脚本文件添加注释：
+
+```
+# script.te - inspect the model, then exit
+ls tables
+ls measures
+exit
+```
+
+### 批处理模式和退出代码
+
+当 stdin 通过管道传入时，`--batch` 是 **默认**：会话会在第一条失败的命令处停止，并以非零退出代码退出，因此可以安全地将管道运行用作构建或 CI 步骤。 使用 `--no-batch` 即可在某条命令失败后继续运行剩余各行。 运行成功时，进程退出代码为 `0`；在批处理模式下如果命令失败，则为非零。
+
+```bash
+# Default when piped: stop at the first failing command, exit non-zero
+printf "bpa run --fail-on error\ndeploy --force\nexit\n" | te interactive ./model
+
+# Run every line regardless of failures
+printf "bpa run --fail-on error\ndeploy --force\nexit\n" | te interactive ./model --no-batch
+```
+
+### 便于阅读的执行记录
+
+`--echo` 会在对应输出之前将每一行输入写入 stdout，这在捕获管道运行的执行记录时很方便。 注释行不会被回显。
+
+```bash
+printf "ls tables\nexit\n" | te interactive ./model --echo
+```
+
+### 选项
+
+| 选项            | 说明                                        |
+| ------------- | ----------------------------------------- |
+| `--no-banner` | 不显示欢迎横幅。                                  |
+| `--echo`      | 将每一行输入回显到 stdout（便于生成管道运行的执行记录）。          |
+| `--batch`     | 在第一个命令失败时即以非零状态码退出（当 stdin 通过管道输入时为默认行为）。 |
+| `--no-batch`  | 即使 stdin 通过管道传入，出错后也继续执行。                 |
+
+### 欢迎横幅与预览提示
+
+会话开始时可能会出现两条不同的信息——不要把它们混为一谈：
+
+- **欢迎横幅** 是在 [启动会话](#starting-a-session) 中介绍的交互式欢迎界面。 可使用 `--no-banner` 隐藏它。 当 stdin 通过管道传入时，本来就不会输出欢迎横幅，因此 `--no-banner` 只有在真正的交互式（TTY）会话中才会产生可见效果。
+- **预览到期通知**（`This is an early preview release ...`）则是另一条信息。 它始终写入 **stderr**，并且**不受** `--no-banner` 影响。 可使用 `te config set hidePreviewNotice true` 隐藏它。
+
+## 无参数调用时自动启动
+
+在终端中不带任何参数运行 `te`，会直接进入交互式 REPL，因此探索模型就像打开 shell 后输入 `te` 一样快。 当 stdin、stdout 或 stderr 被重定向时（如管道输出、CI 流水线或脚本中），CLI 会转入常规解析流程并改为输出帮助——因此，不带子命令调用 `te` 的 shell 脚本仍会保持原有行为。
+
+此行为由 `launchInteractiveMode` 配置项控制，提供三个取值：
+
+| 值          | 效果                                                                            |
+| ---------- | ----------------------------------------------------------------------------- |
+| `auto`（默认） | 仅当三个流都连接到 TTY 时才启动 REPL。 否则回退到常规解析流程。                                         |
+| `always`   | 无论流是否被重定向，都启动 REPL。 适合始终需要交互式会话的情况。                                           |
+| `never`    | 从不自动启动 REPL。 单独运行 `te` 会打印帮助，与 0.6.0 之前的行为一致。 |
+
+可通过以下方式全局更改：
+
+```bash
+te config set launchInteractiveMode never    # keep the classic help-on-empty behavior
+te config set launchInteractiveMode auto     # restore the default
+```
+
+你也可以通过 `TE_INTERACTIVE` 环境变量仅对单次调用进行覆盖（取值相同），或在命令行中传入 `--non-interactive`——这两种方式都会在该次调用中强制设为 `never`，因此 `te --non-interactive` 会输出帮助信息，而不是启动 REPL。
+
 ## 何时使用交互模式与非交互模式
 
 - **交互模式** 最适合探索、学习 CLI、针对单个模型执行一次性批量编辑，以及演示。
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-limitations.md b/localizedContent/zh/content/features/te-cli/te-cli-limitations.md
index c92afb796..eeae28785 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-limitations.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-limitations.md
@@ -41,12 +41,12 @@ CLI 会针对你在 Tabular Editor 2 和 3 中使用的同一个 `Model` 对象
 
 ## Best Practice Analyzer
 
-| 限制                                           | 说明 / 变通方法                                                                                                                                                                                                                                                              |
-| -------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **BPA 规则源必须是 HTTPS URL 或本地文件路径**             | 只接受 `https://` URL 和不带协议的本地文件路径。 系统能识别 `http://`，但会在加载时故意拒绝，并给出清晰的错误信息——BPA 规则是可执行的规则表达式，通过未经过身份验证的通道获取会有被篡改的风险。 其他 URL 方案（`file://`、`ftp://`、…） 不受支持。 这同时适用于 `te bpa run --rules`，以及通过 [`te config set`](xref:te-cli-commands#config-show--paths--init--set) 配置的规则列表。 |
-| **规则 URL 的验证在运行阶段进行，而不是在 `te config set` 时** | 像 `http://` 这样的拼写错误会被 `te config set` 接受，只有在 BPA 实际运行时才会暴露出来。 编辑已配置的规则源后，运行一次 `te bpa run`（或 `te validate`），以验证每个 URL 都能成功加载。                                                                                                                                          |
-| **`--rules` 不会禁用内置规则**                       | 传入 `te bpa run --rules <path-or-url>` 时，提供的规则会在本次调用中替换 [`bpa.rules`](xref:te-cli-commands#config-show--paths--init--set) 和 `TE_BPA_RULES` 中的条目，但内置默认规则仍会一并加载。 若只想运行显式指定的规则文件，还需传入 `--no-defaults`。                                                                     |
-| **没有可在单次调用中跳过 `bpa.rules` 配置的标志**            | 配置了 `bpa.rules` 后，每次执行 `te bpa run` 都会在加载内置规则的同时加载这些规则。 目前没有可在单次运行中跳过已配置规则文件的标志。 变通方法：显式传入 `--rules <path-or-url>`——该标志会在本次调用中完全替换 `bpa.rules` 和 `TE_BPA_RULES`。                                                                                                       |
+| 限制                                           | 说明 / 变通方法                                                                                                                                                                                                                                                               |
+| -------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **BPA 规则源必须是 HTTPS URL 或本地文件路径**             | 只接受 `https://` URL 和不带协议的本地文件路径。 系统能识别 `http://`，但会在加载时故意拒绝，并给出清晰的错误信息——BPA 规则是可执行的规则表达式，通过未经过身份验证的通道获取会有被篡改的风险。 其他 URL 方案（`file://`、`ftp://`、…） 不受支持。 这既适用于 `te bpa run --rules`，也适用于通过 [`te config set`](xref:te-cli-commands#config-list--paths--init--set) 配置的规则列表。 |
+| **规则 URL 的验证在运行阶段进行，而不是在 `te config set` 时** | 像 `http://` 这样的拼写错误会被 `te config set` 接受，只有在 BPA 实际运行时才会暴露出来。 编辑已配置的规则源后，运行一次 `te bpa run`（或 `te validate`），以验证每个 URL 都能成功加载。                                                                                                                                           |
+| **`--rules` 不会禁用内置规则**                       | 当传入 `te bpa run --rules <path-or-url>` 时，本次运行将使用提供的规则覆盖 [`bpa.rules`](xref:te-cli-commands#config-list--paths--init--set) 和 `TE_BPA_RULES` 中的条目，但仍会同时加载内置默认规则。 若只想运行显式指定的规则文件，还需传入 `--no-defaults`。                                                                     |
+| **没有可在单次调用中跳过 `bpa.rules` 配置的标志**            | 配置了 `bpa.rules` 后，每次执行 `te bpa run` 都会在加载内置规则的同时加载这些规则。 目前没有可在单次运行中跳过已配置规则文件的标志。 变通方法：显式传入 `--rules <path-or-url>`——该标志会在本次调用中完全替换 `bpa.rules` 和 `TE_BPA_RULES`。                                                                                                        |
 
 ## 验证
 
@@ -56,9 +56,9 @@ CLI 会针对你在 Tabular Editor 2 和 3 中使用的同一个 `Model` 对象
 
 ## 模型 I/O
 
-| 限制                                          | 说明 / 变通方法                                                                                                                                                                                                        |
-| ------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| **`--serialization` 不能将序列化格式与 PBIP 容器组合使用** | [`te save`](xref:te-cli-commands#save) 的 `--serialization` 选项将 `bim`、`tmdl`、`te-folder` 和 `pbip` 视为互斥选项，因此目前无法为采用 TMSL 序列化 (`.bim`) 的模型生成 PBIP 容器。 将 TMDL 保存到 PBIP 中，或将 `.bim` 保存在 PBIP 容器之外。 |
+| 限制                                          | 说明 / 变通方法                                                                                                                                                                                          |
+| ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| **`--serialization` 不能将序列化格式与 PBIP 容器组合使用** | 在 [`te save`](xref:te-cli-commands#save) 中，`--serialization` 选项会将 `bim`、`tmdl`、`Database.json` 和 `pbip` 视为互斥，因此目前无法将采用 TMSL 序列化（`.bim`）的模型打包生成 PBIP 容器。 将 TMDL 保存到 PBIP 中，或将 `.bim` 保存在 PBIP 容器之外。 |
 
 ## 身份验证
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli-migrate.md b/localizedContent/zh/content/features/te-cli/te-cli-migrate.md
index 939e1e9e5..77506c23b 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli-migrate.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli-migrate.md
@@ -55,34 +55,34 @@ te migrate --output-format json     # Machine-readable mapping
 
 以下是最常用标志的简要汇总，并非完整列表。 运行 `te migrate` 查看完整列表。
 
-| TE2 标志                                    | 新 CLI 等效参数                                                        | 说明                                                                     |
-| ----------------------------------------- | ----------------------------------------------------------------- | ---------------------------------------------------------------------- |
-| `file`（位置参数）                              | `te <command> <path>` 或使用全局参数 `--model`                           | 在大多数命令中，这是第一个位置参数。                                                     |
-| `server`、`database`                       | `te connect <server>` 或 `te deploy <server> <database>`           | Server 参数不再是全局位置参数。                                                    |
-| `-L` / `-LOCAL`                           | `te connect --local`                                              | 仅限 Windows。                                                            |
-| `-S` / `-SCRIPT`                          | `te script -S <file.csx>` 或 `-e "code"`                           | 支持多个脚本、内联代码和 stdin。 注意：请使用大写 `-S`；小写 `-s` 是全局 `--server` 选项。           |
-| `-A` / `-ANALYZE`                         | `te bpa run --rules <file-or-url>`                                | 支持 `--fail-on`、`--fix` 和多个规则文件。                                        |
-| `-AX` / `-ANALYZEX`                       | `te bpa run --rules <file>`（不带 `--model-rules`）                   | 现在默认会排除嵌入模型的规则。                                                        |
-| `-B` / `-BIM`                             | `te save <model> -o <file.bim> --serialization bim`               |                                                                        |
-| `-F` / `-FOLDER`                          | `te save <model> -o <dir> --serialization te-folder`              | 在 `-D` 之后，TE2 的 `-F` 表示 `-FULL`；参见 `--deploy-full`。                    |
-| `-TMDL`                                   | `te save <model> -o <dir> --serialization tmdl`                   | TMDL 是默认保存格式。                                                          |
-| `-D` / `-DEPLOY`                          | `te deploy <server> <database> <model>`                           | 这是一个独立的命令，使用具名选项。                                                      |
-| `-O` / `-OVERWRITE`                       | （默认）或使用 `--create-only` 选择不覆盖                                     | 在新的 CLI 中，覆盖是默认行为。                                                     |
-| `-C` / `-CONNECTIONS`                     | `te deploy --deploy-connections`                                  |                                                                        |
-| `-P` / `-PARTITIONS` 分区                   | `te deploy --deploy-partitions` 部署分区                              |                                                                        |
-| `-Y` / `-SKIPPOLICY`                      | `te deploy --deploy-partitions --skip-refresh-policy` 部署分区并跳过刷新策略 | 需要 `--deploy-partitions`。                                              |
-| `-SHARED`                                 | `te deploy --deploy-shared-expressions`                           | 在 `-D` 之后，TE2 的 `-S` 表示 `-SHARED`。                                     |
-| `-R` / `-ROLES` 角色                        | `te deploy --deploy-roles`                                        |                                                                        |
-| `-M` / `-MEMBERS`                         | `te deploy --deploy-role-members`                                 |                                                                        |
-| `-FULL`（在 `-D` 之后）                        | `te deploy --deploy-full`                                         | 等同于：覆盖 + 连接 + 分区 + 共享 + 角色 + 角色成员。                                     |
-| `-X` / `-XMLA <file>`                     | `te deploy ... --xmla <file>`                                     | 输出到 stdout 时使用 `-`。                                                    |
-| `-V` / `-VSTS`                            | 在 `validate`、`bpa run` 和 `deploy` 命令中使用 `--ci vsts`               | 会向 stderr 输出 `##vso[...]` 注释。                                          |
-| `-G` / `-GITHUB`                          | `--ci github`                                                     | 会输出 `::error::` / `::warning::` 注释。                                    |
-| `-T` / `-TRX <file>`                      | 在 `validate`、`bpa run` 和 `test run` 命令中使用 `--trx <file>`          | 用于 Azure DevOps 测试发布的 VSTEST `.trx` 文件。                                |
-| `-W` / `-WARN`                            | （默认）                                                              | 部署结果中始终会 Report 警告。                                                    |
-| `-E` / `-ERR`                             | （默认）                                                              | 出现 DAX 错误时，部署会返回非零退出代码。                                                |
-| `-SC` / `-SCHEMACHECK`                    | _尚未实现。_                                                           | TE2 架构检查会连接到真实的数据源。 这不同于 `te validate`（DAX 语义验证，不连接数据源）。               |
-| `-L` / `-LOGIN <user> <pass>`（位于 `-D` 之后） | `te auth login -u <id> -p <secret> -t <tenant>`                   | 使用服务主体或基于环境变量的凭据。 登录状态会被缓存，因此后续命令会静默获取令牌——见 @te-cli-auth。 |
+| TE2 标志                                    | 新 CLI 等效参数                                                                       | 说明                                                                                  |
+| ----------------------------------------- | -------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------- |
+| `file`（位置参数）                              | `te <command> <path>` 或使用全局参数 `--model`                                          | 在大多数命令中，这是第一个位置参数。                                                                  |
+| `server`、`database`                       | `te connect <server> <database>` 或 `te deploy <model> -s <server> -d <database>` | `server` 不再是全局位置参数；`te deploy` 仅将 `<model>` 作为位置参数，`server` 和 `database` 需通过命名标志指定。 |
+| `-L` / `-LOCAL`                           | `te connect --local`                                                             | 仅限 Windows。                                                                         |
+| `-S` / `-SCRIPT`                          | `te script -S <file.csx>` 或 `-e "code"`                                          | 支持多个脚本、内联代码和 stdin。 注意：请使用大写 `-S`；小写 `-s` 是全局 `--server` 选项。                        |
+| `-A` / `-ANALYZE`                         | `te bpa run --rules <file-or-url>`                                               | 支持 `--fail-on`、`--fix` 和多个规则文件。                                                     |
+| `-AX` / `-ANALYZEX`                       | `te bpa run --rules <file>`（不带 `--model-rules`）                                  | 现在默认会排除嵌入模型的规则。                                                                     |
+| `-B` / `-BIM`                             | `te save <model> -o <file.bim> --serialization bim`                              |                                                                                     |
+| `-F` / `-FOLDER`                          | `te save <model> -o <dir> --serialization Database.json`                         | 在 `-D` 之后，TE2 的 `-F` 表示 `-FULL`；参见 `--deploy-full`。                                 |
+| `-TMDL`                                   | `te save <model> -o <dir> --serialization tmdl`                                  | TMDL 是默认保存格式。                                                                       |
+| `-D` / `-DEPLOY`                          | `te deploy <model> -s <server> -d <database>`                                    | 已拆分为带命名选项的独立命令；只有 `<model>` 作为位置参数。                                                 |
+| `-O` / `-OVERWRITE`                       | （默认）或使用 `--create-only` 选择不覆盖                                                    | 在新的 CLI 中，覆盖是默认行为。                                                                  |
+| `-C` / `-CONNECTIONS`                     | `te deploy --deploy-connections`                                                 |                                                                                     |
+| `-P` / `-PARTITIONS` 分区                   | `te deploy --deploy-partitions` 部署分区                                             |                                                                                     |
+| `-Y` / `-SKIPPOLICY`                      | `te deploy --deploy-partitions --skip-refresh-policy` 部署分区并跳过刷新策略                | 需要 `--deploy-partitions`。                                                           |
+| `-SHARED`                                 | `te deploy --deploy-shared-expressions`                                          | 在 `-D` 之后，TE2 的 `-S` 表示 `-SHARED`。                                                  |
+| `-R` / `-ROLES` 角色                        | `te deploy --deploy-roles`                                                       |                                                                                     |
+| `-M` / `-MEMBERS`                         | `te deploy --deploy-role-members`                                                |                                                                                     |
+| `-FULL`（在 `-D` 之后）                        | `te deploy --deploy-full`                                                        | 等同于：覆盖 + 连接 + 分区 + 共享 + 角色 + 角色成员。                                                  |
+| `-X` / `-XMLA <file>`                     | `te deploy ... --xmla <file>`                                                    | 输出到 stdout 时使用 `-`。                                                                 |
+| `-V` / `-VSTS`                            | 在 `validate`、`bpa run` 和 `deploy` 命令中使用 `--ci vsts`                              | 会向 stderr 输出 `##vso[...]` 注释。                                                       |
+| `-G` / `-GITHUB`                          | `--ci github`                                                                    | 会输出 `::error::` / `::warning::` 注释。                                                 |
+| `-T` / `-TRX <file>`                      | 在 `validate`、`bpa run` 和 `test run` 命令中使用 `--trx <file>`                         | 用于 Azure DevOps 测试发布的 VSTEST `.trx` 文件。                                             |
+| `-W` / `-WARN`                            | （默认）                                                                             | 部署结果中始终会 Report 警告。                                                                 |
+| `-E` / `-ERR`                             | （默认）                                                                             | 出现 DAX 错误时，部署会返回非零退出代码。                                                             |
+| `-SC` / `-SCHEMACHECK`                    | _尚未实现。_                                                                          | TE2 架构检查会连接到真实的数据源。 这不同于 `te validate`（DAX 语义验证，不连接数据源）。                            |
+| `-L` / `-LOGIN <user> <pass>`（位于 `-D` 之后） | `te auth login -u <id> -p <secret> -t <tenant>`                                  | 使用服务主体或基于环境变量的凭据。 登录状态会被缓存，因此后续命令会静默获取令牌——见 @te-cli-auth。              |
 
 ## 迁移指南
 
diff --git a/localizedContent/zh/content/features/te-cli/te-cli.md b/localizedContent/zh/content/features/te-cli/te-cli.md
index e7fbceae3..0de2d21d2 100644
--- a/localizedContent/zh/content/features/te-cli/te-cli.md
+++ b/localizedContent/zh/content/features/te-cli/te-cli.md
@@ -27,9 +27,9 @@ Tabular Editor CLI (`te`) 是适用于 Power BI 和 Analysis Services 语义模
 
 每个命令都围绕三大设计支柱构建：
 
-- **结构化输出** — 除默认的可读文本外，还支持 JSON、CSV、TMDL 和 TMSL。
-- **非交互模式** — 全局 `--non-interactive` 标志可禁用提示并快速失败。
-- **清晰的错误信息** — 写入 stderr，并使用可预测的退出代码。
+- **结构化输出** — 除默认的易读文本外，还可输出 JSON、CSV、TMDL 和 TMSL。
+- **非交互模式** — 全局 `--non-interactive` 标志会禁用交互提示，并在出错时快速失败。
+- **清晰的错误信息** — 写入 stderr，并返回可预测的退出码。
 
 这三者结合起来，让同一个二进制文件能够很好地服务于三类截然不同的用户：
 
@@ -49,31 +49,34 @@ CLI 将 50 多个命令划分为 10 个类别。 每个命令族都对应语义
 | 命令族                                                           | 功能                        | 示例命令                                                                                                                                                                                  |
 | ------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
 | [模型 I/O](xref:te-cli-commands#model-io)                       | 加载、保存、转换和初始化模型            | [`te load`](xref:te-cli-commands#load)、[`te save`](xref:te-cli-commands#save)、[`te init`](xref:te-cli-commands#init)                                                                  |
-| [模型编辑](xref:te-cli-commands#model-editing)                    | 获取/设置属性，添加/删除/移动对象        | [`te set`](xref:te-cli-commands#set)、[`te add`](xref:te-cli-commands#add)、[`te rm`](xref:te-cli-commands#rm)、[`te mv`](xref:te-cli-commands#mv)                                       |
-| [检视](xref:te-cli-commands#inspection)                         | 列出对象、搜索、比较差异、分析依赖关系       | [`te ls`](xref:te-cli-commands#ls)、[`te find`](xref:te-cli-commands#find)、[`te diff`](xref:te-cli-commands#diff)、[`te deps`](xref:te-cli-commands#deps)                               |
+| [模型编辑](xref:te-cli-commands#model-editing)                    | 获取/设置属性，添加/删除/移动对象        | [`te set`](xref:te-cli-commands#set)、[`te add`](xref:te-cli-commands#add)、[`te remove`](xref:te-cli-commands#remove)、[`te move`](xref:te-cli-commands#move)                           |
+| [检视](xref:te-cli-commands#inspection)                         | 列出对象、搜索、比较差异、分析依赖关系       | [`te list`](xref:te-cli-commands#list)、[`te find`](xref:te-cli-commands#find)、[`te diff`](xref:te-cli-commands#diff)、[`te deps`](xref:te-cli-commands#deps)                           |
 | [分析与质量](xref:te-cli-commands#analysis-and-quality)            | 验证、运行 BPA、格式化 DAX、分析存储    | [`te validate`](xref:te-cli-commands#validate)、[`te bpa run`](xref:te-cli-commands#bpa-run)、[`te format`](xref:te-cli-commands#format)、[`te vertipaq`](xref:te-cli-commands#vertipaq) |
 | [执行](xref:te-cli-commands#execution)                          | 运行 DAX 查询、C# Script 和宏    | [`te query`](xref:te-cli-commands#query), [`te script`](xref:te-cli-commands#script), [`te 宏`](xref:te-cli-commands#macro)                                                            |
 | [部署与刷新](xref:te-cli-commands#deployment-and-refresh)          | 部署到 Workspace、触发刷新、执行增量刷新 | [`te deploy`](xref:te-cli-commands#deploy)、[`te refresh`](xref:te-cli-commands#refresh)、[`te incremental-refresh`](xref:te-cli-commands#incremental-refresh)                          |
 | [测试](xref:te-cli-commands#testing)                            | 断言测试、快照、A/B 比较            | [`te test run`](xref:te-cli-commands#test-run)                                                                                                                                        |
 | [连接与身份验证](xref:te-cli-commands#connection-and-authentication) | 连接到 Workspace，管理身份验证和配置文件 | [`te connect`](xref:te-cli-commands#connect), [`te auth`](xref:te-cli-commands#auth-login--status--logout), [`te profile`](xref:te-cli-commands#profile-list--show--set--remove)      |
-| [配置](xref:te-cli-commands#configuration)                      | 设置与许可                     | [`te config`](xref:te-cli-commands#config-show--paths--init--set)                                                                                                                     |
+| [配置](xref:te-cli-commands#configuration)                      | 设置与许可                     | [`te config`](xref:te-cli-commands#config-list--paths--init--set)                                                                                                                     |
 | [Shell](xref:te-cli-commands#shell)                           | 交互模式、会话状态、Shell 自动补全      | [`te interactive`](xref:te-cli-commands#interactive), [`te session`](xref:te-cli-commands#session), [`te completion`](xref:te-cli-commands#completion)                                |
 
+> [!TIP]
+> 文档中使用规范的长形式动词（`list`、`remove`、`move`），但传统的短形式仍可作为别名使用（`ls`、`rm`、`mv`、`rename`）。 这既适用于顶层命令，也适用于 `te bpa rules`、`te macro`、`te config`、`te profile`、`te session` 和 `te test` 等命令组下的 `remove` / `list` 子命令。 完整映射请参见 @te-cli-commands#command-aliases。
+
 ## 开始使用
 
 1. **注册或登录**：前往 [tabulareditor.com](https://tabulareditor.com/download-tabular-editor-cli) 注册 Tabular Editor 帐户或登录。
 2. **下载并安装**：Windows、macOS 和 Linux 的说明见 @te-cli-install。
 3. **进行身份验证**：运行 `te auth login`，即可连接到 Power BI 或 Fabric。 见 @te-cli-auth。
-4. **运行第一个命令**：`te --help` 会列出所有命令；`te <command> --help` 会显示详细选项。
+4. **运行第一个命令**：`te --help` 会列出所有命令；`te <command> --help` 会显示详细选项。 提示：在终端中单独运行 `te` 会进入交互式 REPL，这是探索模型的一种更友好的方式。 参见 @te-cli-interactive。
 
 初次查看实时模型只需两条命令：
 
 ```bash
 te auth login
-te ls -s MyWorkspace -d MyModel
+te list -s MyWorkspace -d MyModel
 ```
 
-![Tabular Editor CLI te ls 示例输出](~/content/assets/images/features/cli/cli-command-ls.png)
+![Tabular Editor CLI te list 命令示例输出](~/content/assets/images/features/cli/cli-command-ls.png)
 
 ## 预览提示
 
diff --git a/localizedContent/zh/content/features/views/tom-explorer-view.md b/localizedContent/zh/content/features/views/tom-explorer-view.md
index b3133e8bd..bd77b6a4a 100644
--- a/localizedContent/zh/content/features/views/tom-explorer-view.md
+++ b/localizedContent/zh/content/features/views/tom-explorer-view.md
@@ -2,7 +2,7 @@
 uid: tom-explorer-view
 title: TOM Explorer 视图
 author: Morten Lønskov
-updated: 2026-03-19
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -51,8 +51,8 @@ TOM Explorer 由两个主要区域组成：第一部分是 Data model 对象，
 - **创建**：
   展开为子菜单，可在所选对象下创建新的度量值、列、层次结构、显示文件夹或计算项。 可用选项取决于所选的对象类型。
 
-- **移至组**：
-  可将该表归入 TOM Explorer 中的表格组，便于浏览模型。 此选项仅适用于表。
+- **移至组**:
+  展开为子菜单，用于将所选表整理到表格组中，方便在模型中导航。 该子菜单会列出现有的表格组、用于根据所选表创建新组并打开其名称编辑器的 **(New...)** 条目，以及用于移除表格组分配的 **(None)** 条目。 此选项仅适用于表。
 
 - **设为不可见**：
   将对象标记为在客户端工具中不可见。 该表仍是模型的一部分，但会对 Report 作者隐藏。 也可以使用快捷键 **Ctrl+I** 隐藏该对象。
diff --git a/localizedContent/zh/content/getting-started/github-flow.md b/localizedContent/zh/content/getting-started/github-flow.md
new file mode 100644
index 000000000..978522983
--- /dev/null
+++ b/localizedContent/zh/content/getting-started/github-flow.md
@@ -0,0 +1,310 @@
+---
+uid: github-flow
+title: GitHub Flow 与 Octopus Merge 合并模式
+author: Just Blindbæk
+updated: 2026-07-03
+applies_to:
+  products:
+    - product: Tabular Editor 2
+      full: true
+    - product: Tabular Editor 3
+      editions:
+        - edition: Desktop
+          none: true
+        - edition: Business
+          full: true
+        - edition: Enterprise
+          full: true
+---
+
+# GitHub Flow 与 Octopus Merge 合并模式
+
+本文介绍在[使用 Git 和保存到文件夹启用并行开发](xref:parallel-development)中推荐的日常 **GitHub Flow** 工作流，以及支持该流程的 **Octopus Merge** 模式：用于让共享测试环境持续与当前所有进行中的工作保持同步。 本文后半部分将逐步介绍一个实现这一点的完整参考管道——正如你将看到的，它涵盖的内容远不止合并步骤本身。
+
+## GitHub Flow 的日常实践
+
+GitHub Flow 的规则很简单——`main` 始终可部署，所有工作都在从 `main` 分出的短期分支上进行——但对语义模型团队来说，有几个细节值得明确说明。
+
+**创建功能分支：**
+
+```cmd
+git checkout main
+git pull
+git checkout -b feature/add-tax-calculation
+```
+
+**本地开发。** 开发者在 Tabular Editor 3 中进行开发。 开发者每次按下 **Ctrl+S** 时，都会发生两件事：
+
+- 模型元数据会以 [保存到文件夹 (Database.json) 格式](xref:parallel-development#what-is-save-to-folder) 保存到磁盘，可直接在 Git 中暂存并提交到功能分支。
+- 如果启用了 [工作区模式](xref:workspace-mode)，模型会同时同步到共享开发 Workspace 中你个人的 Workspace 数据库——这样你既可以在 Tabular Editor 中进行实时测试，也可以让 Power BI Desktop [直接连接到 Workspace 数据库](xref:workspace-mode#advantages-of-workspace-mode) 进行 Report 端验证。
+
+```cmd
+git add .
+git commit -m "Add tax calculation measure and supporting columns"
+git push
+```
+
+> [!WARNING]
+> 不要在托管 Workspace 数据库的 Fabric Workspace 上启用 Fabric Git 集成。 Tabular Editor 通过 XMLA endpoint 直接写入 Workspace 数据库，这些写入与 Git 分支没有任何关系——在同一个 Workspace 中启用 Git 集成，会对同一个数据库产生相互冲突、绕过流程的更改。 这一点也在[工作区模式文档](xref:workspace-mode)中有所说明。
+
+**发起拉取请求。** 当开发者准备好进行更广泛的测试时，会创建一个以 `main` 为目标分支的拉取请求。 这也是 GitHub Flow 单独使用时给 BI 团队留下的一个问题：当多个开发者同时都提交了尚未关闭的拉取请求时，共享测试环境到底应该反映什么状态？ 这正是 Octopus Merge 要回答的问题——见下文。
+
+**批准并合并。** 一旦技术和业务审核人员都基于共享测试环境完成签核，功能分支就会合并到 `main` 并删除。
+
+**部署到 UAT / 生产环境。** 要么每次合并到 `main` 都自动触发部署，要么累积若干次合并后按固定节奏部署（例如每周一次）。 两种方式都与 GitHub Flow 兼容——无论采用哪种方式，分支结构都相同，区别只在于发布触发方式。
+
+## Octopus Merge：让测试环境保持实时更新
+
+##### 注：命名消歧
+
+“Octopus merge” 在 Git 生态中用来指代三个彼此相关但又不同的概念。 这里有必要明确我们指的是哪一种：
+
+1. **Git 原生的 octopus merge 策略**——当你运行 `git merge branch-a branch-b branch-c` 时，Git 会自动使用这种合并策略，将两个以上的分支头合并为一个合并提交，_前提是没有冲突_。 只要有任一分支与当前合并发生冲突，整个命令就会失败——Git 不会尝试在两个以上分支之间解决或隔离冲突。 这是 Git 的底层机制，不是工作流。
+2. **`lesfurets/git-octopus`**——一个现已归档的开源命令行工具，它将这种原生策略封装成了“持续合并”工作流：按命名模式匹配出一组分支，将它们合并，把结果推送到一个临时分支，并在每次推送时重复这一过程。 它还包含了逐个遍历分支的工具，用来精确找出是哪一个分支导致了冲突。 这个工具本身已不再维护，也不是我们建议直接采用的方案；但它开创的工作流，正是下文要介绍的模式。
+3. **本文所说的 Octopus Merge 模式**——一个自定义 CI/CD 管道，用于发现当前所有目标分支为 `main`、处于打开状态（非草稿）的拉取请求，使用 (1) 中 Git 原生的 octopus 策略将它们的源分支合并在一起，把结果推送到一个临时分支，并将该分支部署到共享测试环境。 这个模式与 (2) 的思路相同，但它被重新实现为由你自己掌控的管道脚本——例如 GitHub Actions 工作流，或调用 Azure DevOps REST API 的 Azure Pipelines 脚本——而不是一个独立的第三方工具。
+
+本文提到“Octopus Merge”时，指的是 (3)。 注意，(3) _使用_ (1) 中的原生策略作为实际的合并机制——它增加的价值在于围绕这次合并的自动化和分支生命周期管理，而不是提供另一种合并方式。
+
+简而言之，这个模式就是：**你的测试环境始终反映当前所有进行中工作的组合**——而不是只单独反映某一个功能。 每当开发者向任一打开的、非草稿的拉取请求推送代码时，管道都会从头重新构建这个组合分支，并重新部署它。
+
+```mermaid
+flowchart LR
+    main(["main"]) -.->|"deleted + recreated"| temp
+    prA["feature/A<br/>(open PR)"] --> temp
+    prB["feature/B<br/>(open PR)"] --> temp
+    prC["feature/C<br/>(draft PR — excluded)"]:::draft
+    temp[["♻️ octopus/temp<br/>deleted + recreated from main<br/>on every run"]] --> test(["Test workspace"])
+
+    classDef draft stroke-dasharray: 5 5,opacity:0.55;
+```
+
+> [!NOTE]
+> Tabular Editor 现已提供跨平台 CLI（`te`），目前处于有限公开预览阶段，专为 CI/CD 场景打造——支持非交互模式、原生 GitHub Actions/Azure DevOps 注解、VSTEST 输出，以及用于在管道中运行回归测试的 `te test run` 命令。 它与下文描述的这类管道天然契合，值得关注。 在撰写本文时，Tabular Editor 自身的文档仍建议不要在预览期间将其用于生产管道（文档说明该预览版本会于 2026-09-30 过期），因此本文中的参考实现改用已成熟的 `TabularEditor.exe` CLI。 有关这个新 CLI 当前具备的能力和示例，可以查看 [CI/CD 集成](xref:te-cli-cicd)。
+
+<!-- FUTURE SPLIT POINT: everything from "Reference implementation" onward is a candidate to become its own page once it grows further (e.g. once release/production deployment past the test environment is added). -->
+
+## 参考实现
+
+下面给出的是一个完整且可运行的管道，实现了 Octopus Merge——但需要先说明，它做的事情远不止合并这一步。 一次完整运行还会下载 Tabular Editor，并在把合并后的模型部署到共享测试工作区之前，按你的最佳实践规则和线上数据源架构对其进行验证。 Octopus Merge 是 5 个作业中的第 1 个；其余部分是一个通用的语义模型 CI/CD 管道，只是恰好以 Octopus Merge 的输出作为输入。 至于在该模型之上部署报表——这是另一个议题，且会因组织而异——文末会简要说明。
+
+下面的示例分别展示了用于合并作业的 **Azure Pipelines**（调用 Azure DevOps REST API）和 **GitHub Actions**（调用 GitHub REST API），因为这两个平台的主要差异在于它们如何进行身份验证以及如何查询拉取请求——无论使用哪一种，底层的 Git 操作和 Tabular Editor CLI 调用都是相同的。
+
+### 管道概览
+
+一次完整运行由多个作业组成，每个作业都明确依赖于前面的作业：
+
+```mermaid
+flowchart TD
+    merge["Octopus merge"] --> dl["Download Tabular Editor"]
+    dl --> bpa["BPA verification"]
+    dl --> schema["Schema validation"]
+    bpa --> deploy["Model deployment"]
+    schema --> deploy
+```
+
+把每个阶段作为独立作业运行，而不是写成一段很长的脚本——这样就能为每个关注点提供独立的通过/失败信号（合并冲突、BPA 违规、架构漂移、部署失败等），从而在运行失败时更快定位究竟哪里出了问题。
+
+##### 注意：管道代理要求
+
+由于 `TabularEditor.exe` 只能在 Windows 上运行，因此每个调用它的作业都需要基于 Windows 的代理/运行器，这包括 BPA 验证、架构验证和模型部署作业。 只要云托管的 Windows 代理能通过网络访问你的测试 Workspace 和数据源，就没问题；只有当这些端点无法从外网访问时（例如本地数据源），才需要自托管代理。 Octopus 合并作业本身没有这个限制，因为它只需要 Git。
+
+### 触发管道
+
+该管道不会由常规的 Git 推送触发器触发。 由于它需要合并当前 _所有_ 打开的拉取请求——而不只是发生变更的那一个——因此通常不配置自动分支触发器，而是通过以下两种方式之一调用：
+
+- **通过拉取请求管道或分支策略**，这样每当创建指向 `main` 的拉取请求时，或向任何存在打开拉取请求的分支推送新提交时，它都会运行。
+- **按计划运行**（例如每隔几分钟一次），如果你的 CI/CD 平台不便直接配置“在任意打开的拉取请求分支更新时运行”，这会是一个更简单的替代方案。
+
+两种方式的效果相同：只要向任何存在打开拉取请求的分支推送，组合测试环境就会重新构建。
+
+### 作业 1：Octopus 合并
+
+这个作业负责发现当前所有打开的拉取请求，将它们合并在一起，并将结果发布到一个临时分支。
+
+**具体步骤如下：**
+
+1. **进行身份验证并查询拉取请求。** 该作业会调用源代码管理平台的 REST API，获取所有以 `main` 为目标的打开拉取请求，并使用具有列出拉取请求权限的令牌进行身份验证（包括草稿拉取请求——过滤会在下一步进行，而不是在 API 层完成）。
+2. **筛选出非草稿拉取请求。** 草稿拉取请求会被排除——这样开发者就可以推送尚在开发中的提交，而不会将其纳入共享测试构建。 只有当 PR 被标记为“准备好评审”时，才会参与合并。
+3. **全新克隆 repository。** 该作业不会复用之前的检出结果，而是在每次运行时都从头克隆 repository，并使用管道自身的访问令牌进行身份验证。 这可确保合并始终从干净、已知的状态开始。
+4. **删除并重新创建临时分支。** 临时输出分支（例如 `octopus/temp`）的远程和本地副本如果存在，都会被强制删除，然后再从 `main` 全新创建。 这个分支绝不会在不同运行之间快进或复用——每次都会从头重建。
+5. **用一条命令合并所有符合条件的拉取请求分支。** 向 `git merge` 传入两个以上的分支时，会自动调用 Git 的原生 octopus 合并策略——这正是这种模式使用上文所述底层 Git 机制的地方。
+6. **推送结果**，如果合并成功。
+
+**Azure Pipelines**，调用 Azure DevOps REST API：
+
+```yaml
+- task: PowerShell@2
+  displayName: Git octopus merge
+  inputs:
+    targetType: 'inline'
+    script: |
+      $prs = Invoke-RestMethod -Uri "https://dev.azure.com/$(Org)/$(Project)/_apis/git/repositories/$(Repo)/pullrequests?api-version=7.0" `
+        -Headers @{ Authorization = "Bearer $(System.AccessToken)" }
+      $branches = $prs.value | Where-Object { $_.isDraft -eq $false -and $_.targetRefName -eq "refs/heads/main" } |
+        ForEach-Object { $_.sourceRefName -replace 'refs/heads', 'origin' }
+
+      git clone $(Build.Repository.Uri) repo --quiet
+      cd repo
+      git checkout main --quiet
+      git push origin --delete octopus/temp --quiet 2>$null
+      git checkout -b octopus/temp --quiet
+      if ($branches.Count -gt 0) {
+        git merge --quiet $branches
+      }
+      git push --set-upstream origin octopus/temp --quiet
+```
+
+**GitHub Actions**，通过 `gh` CLI 调用 GitHub REST API：
+
+```yaml
+- name: Git octopus merge
+  env:
+    GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+  run: |
+    branches=$(gh pr list --base main --state open --json isDraft,headRefName \
+      --jq '.[] | select(.isDraft == false) | .headRefName')
+
+    git clone "$GITHUB_SERVER_URL/$GITHUB_REPOSITORY" repo --quiet
+    cd repo
+    git checkout main --quiet
+    git push origin --delete octopus/temp --quiet || true
+    git checkout -b octopus/temp --quiet
+    if [ -n "$branches" ]; then
+      git merge --quiet $(echo "$branches" | sed 's/^/origin\//')
+    fi
+    git push --set-upstream origin octopus/temp --quiet
+```
+
+两个版本做的都是同一件事：列出所有面向 `main` 的开放且非草稿 PR，将它们解析为分支引用，然后把它们合并到一个重新创建的 `octopus/temp` 分支中。
+
+**处理合并失败：**
+
+如果合并失败——最可能的原因是两个或多个开放的拉取请求之间发生冲突——不要只是记录错误然后停止。 更稳妥的实现方式应当先重置工作目录，并在这个临时分支上推送一个**空占位提交**，然后再让流水线运行失败：
+
+```
+git reset --hard --quiet
+git checkout main --quiet
+git branch -D octopus/temp --quiet
+git checkout -b octopus/temp --quiet
+git config user.email "octopus-merge@users.noreply.github.com"
+git config user.name "Octopus Merge"
+git commit --allow-empty -m "init" --quiet
+git push origin octopus/temp --quiet
+```
+
+这一步很重要，因为下游作业（BPA 验证、架构验证、部署）可能依赖这个临时分支以某种明确定义的状态存在。 如果没有这一步，合并失败可能会导致该分支缺失，或处于合并到一半的状态，从而让后续作业出现令人困惑的连带故障，而不是在合并步骤中报出一个明确的错误。
+
+##### 注意——如何诊断是哪个分支引发了冲突
+
+这种模式的直接实现方式不会自动识别到底是哪一个拉取请求导致了合并冲突——它只会 Report：合并失败。 与已归档的 `lesfurets/git-octopus` 工具相比，这是一个真实存在的限制；后者内置了逐个遍历分支以定位问题来源的工具。 在实践中，大多数团队都会手动处理：先暂时撤下你怀疑有问题的拉取请求（改回草稿状态，或直接关闭），然后反复运行流水线，直到合并再次成功，以缩小范围并找出是哪个分支导致了问题。 如果这种反复试错的过程成了团队的瓶颈，那就值得在你自己的流水线中加入一个自动逐个排查的步骤。
+
+### 作业 2：下载 Tabular Editor
+
+由于后续作业需要调用 Tabular Editor CLI，而又不能假定构建代理已预装它，因此会有一个单独的作业在每次运行开始时下载一份 Tabular Editor 便携版：
+
+- 直接获取最新发布版本（例如从 Tabular Editor 的 GitHub Releases）。
+- 将其解压，并删除下载的压缩包。
+- 让解压得到的 `TabularEditor.exe` 可供同一代理/运行器上的后续作业使用。
+
+每次运行都重新下载最新版本，可以让流水线自动保持最新，而不必跟踪并更新锁定的版本号——不过，如果你的团队更看重确定性和可复现的构建，那么将版本锁定到某个特定发布版，并有计划地进行更新，也值得作为替代方案考虑。
+
+### 作业 3：BPA 验证
+
+这个作业会对合并产出的每个语义模型运行 Tabular Editor 的 [Best Practices Analyzer](xref:best-practice-analyzer)，并根据团队统一的质量规则进行验证。
+
+如果你的 repository 中包含多个语义模型——这在服务多个业务领域的 BI 团队中很常见——那么每个模型通常都会位于各自的子文件夹中，而这个作业会依次遍历它们：
+
+```
+TabularEditor.exe "<path-to-model>" -A "<path-to-BPARules.json>" -V
+```
+
+- `-A` 会让 Tabular Editor 使用指定的 BPA 规则文件进行检查。
+- `-V` 会验证模型，并生成 Report 以输出结果。
+
+> [!NOTE]
+> 先决定好：BPA 违规是要让流水线 **失败**，还是只给出 **警告**。 当规则集仍在调优时，先从警告模式开始确实很诱人；但如果长期保持这样，违规项可能会在从未阻止部署的情况下悄然累积。 应将仅警告的 BPA 步骤视为过渡状态，后续要“升级”退出，而不是永久配置。
+
+### 作业 4：架构验证
+
+这个作业会将每个模型的预期架构与其真实在线的数据源进行比较——例如，它能在列被重命名或缺失导致测试环境刷新失败之前发现问题。
+
+```
+TabularEditor.exe "<path-to-model>" -S "<path-to-connection-script>.cs" -SC -V -W
+```
+
+- `-S` 会运行一个 C# Script 来设置模型的数据源连接字符串——通常从管道环境变量或机密中读取，从而无需将真实连接信息提交到源代码管理中。
+- `-SC` 会执行架构检查，将模型的元数据与实时数据源进行比较。
+- `-V -W` 用于验证结果并控制警告的处理方式。
+
+如果你的模型依赖于数据库对象，而这些对象本身也是作为管道的一部分部署的——例如从源代码管理发布的 SQL 视图——要确保该部署步骤在架构验证之前运行，这样检查针对的就是所有内容都部署到测试环境后模型实际会看到的那些对象。 如果这两个作业是彼此独立编写的，这种顺序依赖关系就很容易被忽略。
+
+> [!NOTE]
+> 部署上游数据对象（SQL 视图及其他数据库工件）的具体机制因组织的数据平台而异，也不属于 Octopus Merge 模式本身的一部分。 对这一模式来说，唯一重要的是：架构验证必须在你的数据源处于测试环境预期状态之后进行——至于由什么来让它达到这个状态，由你决定。
+
+### 作业 5：模型部署
+
+当 BPA 验证和架构验证都成功后，此作业会将合并后的模型部署到共享测试 Workspace，使用 Tabular Editor 的“保存到文件夹”（`Database.json`）格式，并通过 XMLA endpoint 直接部署：
+
+```
+TabularEditor.exe "<path-to-model>\database.json" -D "Provider=MSOLAP;Data Source=<XMLA-endpoint>;User ID=app:<app-id>@<tenant-id>;Password=<app-secret>;LocaleIdentifier=1033" "<model-name>" -O -P -R -W -V -E
+```
+
+有几点值得特别说明：
+
+- 身份验证通过 **服务主体**（Azure AD 应用注册）完成，而不是用户账户——这更适合无人值守的管道，也避免了必须在管道机密中保存真实用户凭据。
+- 传递给 Tabular Editor 的模型名称通常与文件夹名称一致，因此包含多个模型的 repository 会将每个模型部署到名称对应的 Dataset。
+- `-O -P -R -W -V -E` 标志分别涵盖覆盖、处理、角色、警告、验证和错误处理——如果你需要根据自己的设置调整其中任何一项，请参阅 [Tabular Editor CLI 参考](xref:command-line-options) 获取完整的标志列表。
+
+> [!NOTE]
+> 业务评审人员在共享测试环境中签署确认时，验证的是 Report，而不是原始的 XMLA 连接——实际上，在他们签署之前，仍需要有步骤部署 Power BI Report 并将其绑定到刚部署的测试模型上（并可选择更新任何已发布的 Power BI Apps）。 每次运行是重新部署所有 Report，还是只部署受本次更改影响的 Report，这类决策因组织而异，本文不作展开——该部分管道请参阅 @powerbi-cicd。
+
+### 完整工作流图
+
+```mermaid
+flowchart TB
+    subgraph dev["Developer"]
+        direction LR
+        d1["Create feature branch"] --> d2["Local commits"] --> d3["Open PR<br/>(ready for review)"]
+    end
+
+    subgraph ci["CI Pipeline"]
+        direction LR
+        c1["Octopus merge"] -->|"success"| c2["Download Tabular Editor"]
+        c1 -.->|"conflict"| c1f["Empty placeholder commit"]
+        c2 --> c3["BPA verification"]
+        c2 --> c4["Schema validation"]
+        c3 --> c5["Model deployment"]
+        c4 --> c5
+    end
+
+    subgraph review["Review"]
+        direction LR
+        r1["Technical sign-off"] --> r2["Business sign-off"]
+    end
+
+    subgraph release["Release"]
+        direction LR
+        rel1["Merge to main"] --> rel2["Deploy to UAT / production"]
+    end
+
+    d3 --> c1
+    c5 --> r1
+    r2 --> rel1
+    c1f -.->|"developer resolves conflict, pushes fix"| d2
+    r1 -.->|"changes requested, developer pushes fix"| d2
+```
+
+## 关键原则
+
+- `main` 始终处于可部署状态；功能分支生命周期短，且彼此独立。
+- 一次性分支会在每次运行时删除，并基于 `main` 重新创建——绝不会 fast-forward，也不会复用。
+- 合并失败后，一次性分支应保持在明确的状态中（即使是空的），而不是处于缺失或半合并状态。
+- 每个验证阶段（BPA、架构）都应是管道中独立的作业，拥有各自的通过/失败信号，而不是揉进一个脚本里。
+- 组织特定的步骤（例如部署 SQL 视图）应与通用模式清晰区分开，无论在管道代码中还是在内部文档里都应如此——这样即使需要将该模式应用到其他项目，它也仍然便于移植。
+
+## 后续步骤
+
+- [借助 Git 和“保存到文件夹”实现并行开发](xref:parallel-development)——本管道所支持的分支策略。
+- [CI/CD 集成](xref:te-cli-cicd)——新版 Tabular Editor CLI 的 CI/CD 模式，目前处于有限公开预览阶段。
+- @powerbi-cicd
+- @as-cicd
diff --git a/localizedContent/zh/content/getting-started/parallel-development.md b/localizedContent/zh/content/getting-started/parallel-development.md
index 36d00368e..89c7d7a66 100644
--- a/localizedContent/zh/content/getting-started/parallel-development.md
+++ b/localizedContent/zh/content/getting-started/parallel-development.md
@@ -2,7 +2,7 @@
 uid: parallel-development
 title: 通过 Git 和“保存到文件夹”实现并行开发
 author: Daniel Otykier
-updated: 2026-06-11
+updated: 2026-07-03
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -127,26 +127,66 @@ Git 是一个免费开源的分布式版本控制系统，旨在以高速高效
 
 分支策略会决定日常开发工作流的具体方式；很多时候，分支还会与团队采用的项目管理方法直接对应。 例如，在 Azure DevOps 中使用[敏捷过程](https://docs.microsoft.com/en-us/azure/devops/boards/work-items/guidance/agile-process-workflow?view=azure-devops)时，你的待办项通常由 **史诗**、**功能**、**用户故事**、**任务** 和 **缺陷** 组成。
 
-在敏捷术语中，**用户故事** 是一项可交付、可测试的工作成果。 一个用户故事可能由多个 **任务** 组成，这些是更小的工作单元，通常由开发人员在用户故事交付之前完成。 在理想情况下，所有用户故事都已拆分为易于管理的任务，每个任务只需几个小时即可完成，整个用户故事累计也不超过几天。 这样，用户故事就非常适合作为所谓的主题分支，开发人员可以针对用户故事中的每个任务进行一次或多次提交。 当所有任务完成后，你就可以把用户故事交付给客户。这时，你会把主题分支合并到交付分支（例如“Test”分支），并将代码部署到测试环境。
+在敏捷术语中，**用户故事** 是一项可交付、可测试的工作成果。 一个用户故事可能由多个**任务**组成——这些是开发人员在交付用户故事之前需要完成的较小工作项。 理想情况下，所有用户故事都会被拆分为可管理的任务，每个任务只需几小时即可完成，整个用户故事合计也不超过几天。 因此，用户故事非常适合使用短生命周期的功能分支：开发人员可以针对每个任务进行一次或多次提交，然后再合并分支并将代码部署到测试环境。
 
-选择合适的分支策略取决于很多因素。 通常，Microsoft 推荐采用 [Trunk-based Development](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops)（[视频](https://youtu.be/t_4lLR6F_yk?t=232)）策略，以敏捷方式持续交付小步增量。 其核心思路是：每新增一个功能或修复一个缺陷，都从“Main”分支拉出一个分支（见下图）。 通过从功能分支向 Main 发起拉取请求来强制执行代码评审流程；并利用 Azure DevOps 的分支策略功能，我们可以配置规则，要求代码在拉取请求完成前必须成功通过构建且无错误。
+合适的分支策略取决于许多不同因素：团队规模、发布节奏、监管约束、你维护的语义模型数量，以及现有 CI/CD 设置的成熟度。 本文介绍三种策略：
 
-![主干开发](~/content/assets/images/trunk-based-development.png)
+- **[GitHub Flow + Octopus Merge](#github-flow--octopus-merge)**——我们为大多数语义模型团队推荐的方法，也是本文重点介绍的方案。
+- **[GitFlow](#gitflow-branching-and-deployment-environments)**——这是一个可行的替代方案，尤其适合有正式且不频繁的发布周期，或有监管签核要求的团队。
+- **[纯主干开发](#trunk-based-development)**——这是最简单的方法。即使大多数 BI 团队最终会需要 GitHub Flow 提供的额外结构，也值得先将其作为基线来理解。
+
+> [!NOTE]
+> Tabular Editor 不依赖任何分支策略。 无论你选择下面哪种策略，“保存到文件夹”和“工作区模式 Workspace”的工作方式都完全相同——本文的建议基于我们在企业项目中看到的成功模式，而不是工具本身施加的限制。
+
+## GitHub Flow + Octopus Merge
+
+对于使用 Tabular Editor 和 Power BI 构建语义模型的团队，我们建议采用 **[GitHub Flow](https://docs.github.com/en/get-started/using-github/github-flow)**，并结合 **Octopus Merge** 模式来进行持续集成测试。
+
+GitHub Flow 是一种轻量级分支模型，只有一条硬性规则：**`main` 始终可部署。** 所有工作都在从 `main` 创建的短生命周期功能分支上进行；没有人直接向 `main` 提交；在审查和自动检查通过后，通过拉取请求将分支合并回 `main`。 与 GitFlow 不同，它没有 `develop` 分支，也不会为每个环境单独设分支——环境推进（dev → test → UAT → production）由部署管道处理，而不是依赖长期存在的分支。
+
+```mermaid
+gitGraph
+    commit id: "初始提交"
+    branch "feature/add-tax-calculation"
+    commit id: "新增度量值"
+    commit id: "新增列"
+    checkout main
+    merge "feature/add-tax-calculation" id: "PR 已合并：税额计算"
+    branch "feature/fix-rls"
+    commit id: "修复角色"
+    checkout main
+    merge "feature/fix-rls" id: "PR 已合并：修复 RLS"
+    branch "feature/new-report-page"
+    commit id: "进行中"
+    checkout main
+    commit id: "热修复"
+    merge "feature/new-report-page" id: "PR 已合并：新 Report 页面"
+```
 
-### 主干开发
+`main` 始终保持为单一主线，并且随时可部署；短生命周期的功能分支从它分出，再通过拉取请求直接合并回来。 对比本页后面的 GitFlow 图示，后者有五条并行的长期分支线。
 
-不过，出于多种原因，这种策略在商业智能开发团队中可能并不现实：
+仅靠 GitHub Flow 本身，还无法回答一个 BI 团队特有的问题：当多个开发人员各自都有未合并的拉取请求时，共享测试环境在任意时刻反映的到底是什么？ **Octopus Merge** 给出了答案：CI 管道会持续将当前所有尚未合并的拉取请求合并到一个临时分支中，并将结果部署到共享测试环境——这样业务用户始终验证的是所有进行中工作的组合结果，而不是彼此隔离的单个功能。 有关这一模式如何工作以及如何构建，请参阅 [GitHub Flow and the Octopus Merge pattern](xref:github-flow)。
 
-- 新功能往往需要业务用户进行较长时间的测试与验证，可能需要数周才能完成。 因此，你很可能需要一个面向用户的测试环境。
-- BI 解决方案通常采用多层架构，一般包括带 ETL 的 Data Warehouse 层、主数据管理层、语义层以及 Report。 这些层之间存在依赖关系，进一步增加了测试和部署的复杂度。
-- BI 团队可能需要负责开发和维护多个不同的语义模型，分别服务于不同的业务领域（销售、库存、物流、财务、人力资源等），其成熟度各不相同，开发节奏也不一致。
-- BI 解决方案最重要的部分是数据！ 作为 BI 开发人员，你无法像传统软件开发那样：从源代码管理中签出代码，按下 F5，然后在几分钟的编译时间内就让完整解决方案跑起来。 你的解决方案离不开数据，而这些数据必须经过多层的加载、ETL 或处理，才能交付给最终用户。 把数据纳入 DevOps 工作流，可能会把构建和部署时间从几分钟拉长到几小时，甚至几天。 在某些场景下，由于资源或成本限制，甚至可能根本做不到。
+这种组合尤其适合语义模型开发，原因包括：
 
-毫无疑问，BI 团队会受益于一种分支策略：支持在完整 BI 解决方案的任意层上并行开发，并且可以把已准备好测试的功能自由组合起来。 但尤其是由于上面最后一个要点，我们需要认真考虑该如何处理数据。 例如，我们给某个维度新增一个属性时，是否希望在构建和部署流水线中自动加载该维度？ 如果加载这个维度只需要几分钟，那可能没问题；但如果我们是在一个数十亿行的事实表里新增一列呢？ 此外，如果开发人员在并行开发新功能，每位开发者是否都应该拥有自己的开发数据库？否则，如何避免他们在共享数据库中相互干扰？
+- **心智模型更简单。** 只需要理解两种分支概念，而不是 GitFlow 的五种，因此上手成本更低，尤其适合既有 Report 作者和业务分析师，也有模型开发人员的团队。
+- **`main` 始终可部署。** 如果你需要快速发布一个紧急修复——比如出错的度量值，或与安全相关的 RLS 变更——你不必再去判断多个长期存在的分支中，哪一个当前反映的是生产环境。
+- **环境推进由管道负责，而不是由分支结构承担。** 新增一个环境，只需修改管道；不需要再新增一个永久分支，让每位开发人员都得记住要合并进去。
+- **短生命周期分支可减少合并冲突**——这对 Octopus Merge 很重要，因为它会将所有当前开放的分支一并合并，用于集成测试。 每个分支存续时间越短，发生冲突的范围就越小。
+- **比 GitFlow 的版本化发布列车模型更适合数据产品的持续交付**，因为语义模型往往是逐步演进的，而不是按一个个独立版本发布。
 
-上述问题没有简单答案——尤其是当你要考虑 BI 解决方案的所有层级，以及全球各地 BI 团队不同的组织形态和偏好的工作流程时。 另外，当我们深入到实际的构建、部署和测试自动化时，会主要聚焦在 Analysis Services。 从 DevOps 的透视来看，ETL 和数据库层也有各自的挑战，但不在本文讨论范围内。 不过在继续之前，我们先看看另一种分支策略，以及它可能如何应用到 BI 工作流中。
+这并不意味着 GitFlow 就错了——想了解它在哪些情况下仍然适用，可以看看下文的 [GitFlow 分支与部署环境](#gitflow-branching-and-deployment-environments)。
 
-### GitFlow 分支与部署环境
+### 关键原则
+
+- `main` 始终处于可部署状态。
+- 功能分支生命周期短，且彼此独立。
+- 测试环境始终反映当前所有进行中工作的组合——而不只是某一个孤立的功能。 具体怎么做，可以看看 [GitHub Flow 与 Octopus Merge 模式](xref:github-flow)。
+- 任何用于 Tabular Editor Workspace 数据库的 Workspace 都不应启用 Fabric Git 集成——Tabular Editor 会通过 XMLA endpoint 直接写入 Workspace 数据库，而这些写入与 Git 分支毫无关系。 这一点在适用于 Workspace 的 [工作区模式文档](xref:workspace-mode) 中也有专门说明。
+
+## GitFlow 分支与部署环境
+
+对于确实需要 GitFlow 所提供结构的团队来说，GitFlow 仍然是一个稳妥的选择——例如：需要正式的版本化发布、与特定分支绑定的合规/监管签核关口，或发布频率较低（如每月或每季度一次），在这类流程中，长期存在的 `develop` 分支和发布分支与流程能够自然对应。 如果这正符合你的团队情况，那么下面的方法非常值得采用。
 
 下面介绍的策略基于 [Vincent Driessen 的 GitFlow](https://nvie.com/posts/a-successful-git-branching-model/)。
 
@@ -159,34 +199,59 @@ Git 是一个免费开源的分布式版本控制系统，旨在以高速高效
 - 一套或多套 **UAT** 环境，用于你和业务用户测试并验证新功能。 部署直接从包含待测代码的 feature 分支发起。 如果你希望并行测试多个新功能，就需要多个测试环境。 只要稍作协调，并仔细考虑各个 BI 层级之间的依赖关系，通常一个测试环境就足够了。
 - 一个或多个 **沙盒** 环境，你和团队可以在其中开发新功能，而不会影响上述任何环境。 和测试环境一样，通常只需要一个共享的沙盒环境就足够了。
 
-我们要强调：这些考量并不存在真正“放之四海皆准”的方案。 也许你并不是在云端构建解决方案，因此无法利用可扩展性或灵活性，在数秒或数分钟内快速创建新资源。 又或者你的数据量非常大，受限于资源/成本/时间，复制多套环境并不现实。 在继续之前，也请先问问自己：你是否真的需要支持并行开发与测试。 对于只有少数利益相关方的小团队，这种情况并不常见。在这种情况下，你依然可以从 CI/CD 中受益，但 GitFlow 分支策略可能有些“杀鸡用牛刀”。
+我们要强调：这些考量并不存在真正“放之四海皆准”的方案。 也许你并不是在云端构建解决方案，因此无法利用可扩展性或灵活性，在数秒或数分钟内快速创建新资源。 又或者你的数据量非常大，受限于资源/成本/时间，复制多套环境并不现实。
+
+即使你确实需要支持并行开发，你也可能会发现：多个开发者通常可以轻松共享同一个开发或沙盒环境，而不会遇到太多麻烦。 不过，针对表格模型，我们仍建议开发者使用各自独立的 [Workspace 数据库](xref:workspace-mode)，以免互相干扰。
+
+> [!NOTE]
+> 如果你考虑采用 GitFlow，主要是因为需要一个共享、始终反映进行中工作的测试环境，那么不妨考虑 [GitHub Flow + Octopus Merge](#github-flow--octopus-merge) 是否能以更低的分支管理开销实现同样的结果。 GitFlow 的 `develop`/金丝雀分支和 Octopus Merge 的临时测试分支，都是用不同方式来解决类似的问题。
+
+## 主干开发
+
+主干开发是最简单的分支模型：开发者要么直接向 `main` 提交小而频繁的更改，要么通过生命周期极短的功能分支提交，并在数小时内合并回去。 通常，Microsoft 推荐采用 [主干开发](https://docs.microsoft.com/en-us/azure/devops/repos/git/git-branching-guidance?view=azure-devops)（[视频](https://youtu.be/t_4lLR6F_yk?t=232)）策略，用于以敏捷方式持续交付小幅增量。
+
+![主干开发](~/content/assets/images/trunk-based-development.png)
 
-即使你确实需要支持并行开发，你也可能会发现：多个开发者通常可以轻松共享同一个开发或沙盒环境，而不会遇到太多麻烦。 不过，针对表格模型，我们仍建议开发者使用各自独立的 [Workspace 数据库](xref:workspace-mode)，以免相互“踩脚”。
+但在最纯粹的形式下，主干开发对于 BI 团队可能会带来一些实际阻力：
+
+- 新功能通常需要业务用户进行较长时间的测试与验证，可能持续数周——因此，你需要一个不是 `main` 本身的地方来验证进行中的工作。
+- BI 解决方案通常是多层的（Warehouse/ETL、主数据管理、语义层、Report），而层与层之间的依赖关系会让测试和部署更复杂。
+- 一个 BI 团队可能需要维护多个处于不同成熟阶段、演进节奏各异的语义模型。
+- 要让变更可供测试，不只是代码，数据也必须完成加载、ETL 和处理。 如果每次构建都包含完整的数据刷新，管道运行时间可能会从几分钟暴涨到几小时；而对于非常大的事实表，这种做法甚至根本不可行。
+
+**上文所述的 GitHub Flow + Octopus Merge，最好理解为对主干开发的一种改进，它直接解决了这些顾虑**——而不是对主干开发的背离。 它保留了主干开发的核心简洁性（一个长期存在的分支、短生命周期的功能分支、没有发布列车），同时补上了 BI 团队所缺失、但又真正需要的一环：一个共享测试环境，由管道而非长期分支来填充，并且始终反映所有进行中工作的当前合并状态。 如果你正在本页的三种策略中做选择，而你的团队喜欢主干开发的简洁性、但又遇到了上述限制，我们通常会推荐 GitHub Flow + Octopus Merge。
 
 ## 常见工作流
 
-假设你已经建好了 Git repository，并且与分支策略对齐，把表格模型“源代码”加入该 repository 其实很简单：用 Tabular Editor 将元数据保存到本地 repository 的新分支上。 然后，将新文件暂存并提交，把分支推送到远程 repository，并发起拉取请求，以便将你的分支合并到主分支。
+假设你已经建好了 Git repository，并且与分支策略对齐，把表格模型“源代码”加入该 repository 其实很简单：用 Tabular Editor 将元数据保存到本地 repository 的新分支上。 然后，暂存并提交新文件，将你的分支推送到远程 repository，并创建一个拉取请求，把你的分支合并到 main 分支。
+
+无论你选择上述哪种策略，具体命令都完全相同——不同之处在于打开拉取请&#x6C42;_&#x4E4B;&#x540E;_&#x4F1A;发生什么（GitHub Flow 的情况请参阅 [GitHub Flow 与 Octopus Merge 模式](xref:github-flow)，GitFlow 则请参考你的发布/金丝雀流程）。 总的来说，工作流如下：
 
-具体工作流取决于你的分支策略，以及你的 Git repository 是怎么配置的。 一般来说，工作流大致如下：
+1. 开始着手新功能之前，先在 Git 中创建一个新的功能分支：
 
-1. 在开始开发新功能之前，在 Git 中创建一个新的功能分支。 在基于主干的开发场景中，你需要使用以下 Git 命令来检出主分支、拉取最新代码，并以此为基础创建功能分支：
    ```cmd
    git checkout main
    git pull
-   git checkout -b "feature\AddTaxCalculation"
+   git checkout -b feature/add-tax-calculation
    ```
+
 2. 在 Tabular Editor 中从本地 Git repository 打开你的模型元数据。 理想情况下，使用 [Workspace 数据库](xref:workspace-mode)，以便更轻松地测试和调试 DAX 代码。
+
 3. 使用 Tabular Editor 对模型进行必要的更改。 及时保存更改（CTRL+S）。 每次保存后就定期把代码更改提交到 Git，避免丢失工作，并保留所有更改的完整历史记录：
+
    ```cmd
    git add .
    git commit -m "Description of what was changed and why since last commit"
    git push
    ```
+
 4. 如果你没有使用 Workspace 数据库，请使用 Tabular Editor 的 **Model > Deploy...** 选项部署到沙盒/开发环境，以便测试对模型元数据所做的更改。
+
 5. 完成后，当所有代码都已提交并推送到远程 repository 时，你需要提交一个拉取请求，以便将你的代码集成到主分支。 如果遇到合并冲突，你得在本地解决。比如可以使用 Visual Studio Team Explorer，或者直接用文本编辑器打开 .json 文件来解决冲突（Git 会插入冲突标记，用于指示代码中哪些部分存在冲突）。
-6. 解决所有冲突后，可能还需要进行代码审查，并根据分支策略执行自动化构建/测试等流程，才能完成拉取请求。 不过，这取决于你的分支策略和整体设置。
 
-在接下来的文章中，我们会介绍如何使用 Azure DevOps 配置 Git 分支策略、搭建自动化构建与部署管道等更多细节。 在其他自动化构建和 Git 托管环境中也可以使用类似技术，例如 TeamCity、GitHub 等。
+6. 在所有冲突解决后，在完成拉取请求之前，通常还需要经过代码审查和自动化构建/测试——如果你采用的是上面的 GitHub Flow 方法，还包括 Octopus Merge 的测试部署——等流程。
+
+在接下来的文章中，我们会进一步介绍如何使用 Azure DevOps 和 GitHub Actions 配置 Git 分支策略、搭建自动化构建与部署管道等细节。 在其他自动化构建和 Git 托管环境中也可以采用类似技术，例如 TeamCity、GitLab 等。
 
 ## 后续步骤
 
diff --git a/localizedContent/zh/content/getting-started/refresh-preview-query.md b/localizedContent/zh/content/getting-started/refresh-preview-query.md
index 7d02befd1..e73e4383d 100644
--- a/localizedContent/zh/content/getting-started/refresh-preview-query.md
+++ b/localizedContent/zh/content/getting-started/refresh-preview-query.md
@@ -2,7 +2,7 @@
 uid: refresh-preview-query
 title: 刷新、预览与查询数据
 author: Daniel Otykier
-updated: 2026-01-08
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -84,7 +84,15 @@ Tabular Editor 3 支持对不同对象类型执行刷新操作。 支持的刷
 
 ![预览数据](~/content/assets/images/preview-data-big.png)
 
-你可以打开多个此类表格预览，并在用户界面中按你的习惯随意排列。 此外，你还可以对单个列进行排序或筛选。 可预览的行数实际上没有限制。 Tabular Editor 只是在模型上执行一条 [`TOPNSKIP`](https://dax.guide/topnskip) DAX 查询，返回少量记录，用于填充当前视图。
+你可以打开多个此类表格预览，并在用户界面中按你的习惯随意排列。 此外，你还可以对单个列进行排序或筛选。 Tabular Editor 会针对模型执行 DAX 查询，只返回足以填充当前视图的一小部分记录，然后在你滚动时逐页加载更多行。
+
+分页的工作方式取决于存储模式和引擎：
+
+- 在支持 [`WINDOW`](https://dax.guide/window) 函数的引擎中，对于 Import 表，分页会基于表的主键使用 `WINDOW`，因此你可以滚动浏览整张表。
+- 如果引擎不支持 `WINDOW`，或者表没有主键，预览将显示前几行，并提示无法滚动。
+- DirectQuery 表只显示前几行——无法分页——并会显示一条信息。
+
+预览元数据会在当前会话中缓存，因此重新打开预览时不会再次查询服务器。 点击 **刷新** 以重新读取元数据，例如当模型已在 Tabular Editor 之外完成处理后。
 
 如果一个或多个计算列处于无效状态，这些列会显示文本 _(需要计算)_。 你可以通过右键单击该列并选择 **重新计算表格...** 选项来重新计算表格。
 
diff --git a/localizedContent/zh/content/references/downloads.md b/localizedContent/zh/content/references/downloads.md
index 8ad847ace..1229d97d6 100644
--- a/localizedContent/zh/content/references/downloads.md
+++ b/localizedContent/zh/content/references/downloads.md
@@ -2,7 +2,7 @@
 uid: downloads
 title: 全部下载
 author: Daniel Otykier
-updated: 2026-04-17
+updated: 2026-07-10
 ---
 
 # Tabular Editor 3 下载
@@ -11,14 +11,14 @@ updated: 2026-04-17
 
 ## 最新版本
 
-Tabular Editor 3.26.1 **.NET 8** 下载：
+Tabular Editor 3.26.3 **.NET 8** 下载：
 
-- 下载 [Tabular Editor 3.26.1（64 位）](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.x64.Net8.exe) _(推荐)_
-- 下载 [Tabular Editor 3.26.1 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.ARM64.Net8.exe)
-- 便携版：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.zip)
-- MSI 版本：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.msi)
+- 下载 [Tabular Editor 3.26.3 (64 位)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) _(推荐)_
+- 下载 [Tabular Editor 3.26.3 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+- 便携版：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+- MSI 版：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
 
-阅读 [最新发布说明](release-notes/3_26_1.md)。
+查看[最新发布说明](release-notes/3_26_3.md)。
 
 ## 安装说明
 
@@ -30,6 +30,14 @@ Tabular Editor 3.26.1 **.NET 8** 下载：
 
 ## 更新历史
 
+- 2026-07-10 **Tabular Editor 3.26.3** (_[发布说明](release-notes/3_26_3.md)_)
+  - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+  - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+  - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+- 2026-06-25 **Tabular Editor 3.26.2**（_[发布说明](release-notes/3_26_2.md)_）
+  - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
+  - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
+  - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
 - 2026-04-17 **Tabular Editor 3.26.1** (_[发布说明](release-notes/3_26_1.md)_)
   - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.ARM64.Net8.exe)
   - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.zip)
@@ -62,16 +70,5 @@ Tabular Editor 3.26.1 **.NET 8** 下载：
   - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.Installer.x64.Net8.exe)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.Installer.x86.Net8.exe)
   - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x64.Net8.zip)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x86.Net8.zip)
   - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x64.Net8.msi)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.22.1.x86.Net8.msi)
-- 2025-04-25 **Tabular Editor 3.21.0** (_[发布说明](release-notes/3_21_0.md)_)
-  - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.Installer.x64.Net8.exe)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.Installer.x86.Net8.exe)
-  - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x64.Net8.zip)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x86.Net8.zip)
-  - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x64.Net8.msi)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.21.0.x86.Net8.msi)
-- 2025-04-11 **Tabular Editor 3.20.1** (_[发布说明](release-notes/3_20_1.md)_)
-  - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x64.Net8.exe)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x86.Net8.exe)
-  - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.Net8.zip)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.Net8.zip)
-  - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.Net8.msi)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.Net8.msi)
-  - .NET 6 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x64.exe)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.Installer.x86.exe)
-  - .NET 6 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.zip)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.zip)
-  - .NET 6 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x64.msi)，[x86](https://cdn.tabulareditor.com/files/TabularEditor.3.20.1.x86.msi)
 
 如需更早版本，请参阅[完整发布历史](release-history.md)。
\ No newline at end of file
diff --git a/localizedContent/zh/content/references/release-history.md b/localizedContent/zh/content/references/release-history.md
index 09f1bd67b..890e0d892 100644
--- a/localizedContent/zh/content/references/release-history.md
+++ b/localizedContent/zh/content/references/release-history.md
@@ -5,6 +5,14 @@ title: 完整发布历史
 
 # 完整发布历史
 
+- 2026-07-10 **Tabular Editor 3.26.3** (_[发布说明](release-notes/3_26_3.md)_)
+  - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+  - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+  - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+- 2026-06-25 **Tabular Editor 3.26.2**（_[发行说明](release-notes/3_26_2.md)_）
+  - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
+  - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
+  - .NET 8 安装程序（.msi）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi)，[ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
 - 2026-04-17 **Tabular Editor 3.26.1** (_[发布说明](release-notes/3_26_1.md)_)
   - .NET 8 安装程序（.exe）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.x64.Net8.exe), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.Installer.ARM64.Net8.exe)
   - .NET 8 便携版（.zip）：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.1.ARM64.Net8.zip)
diff --git a/localizedContent/zh/content/references/release-notes/3_26_2.md b/localizedContent/zh/content/references/release-notes/3_26_2.md
new file mode 100644
index 000000000..035c5a0d5
--- /dev/null
+++ b/localizedContent/zh/content/references/release-notes/3_26_2.md
@@ -0,0 +1,120 @@
+---
+uid: release-3-26-2
+---
+
+# Tabular Editor 3.26.2
+
+# [**下载**](#tab/downloads)
+
+Tabular Editor 3.26.2 下载：
+
+- 下载 [Tabular Editor 3.26.2 (x64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe) _(推荐)_
+- 下载 [Tabular Editor 3.26.2 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe)
+- 便携版：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)
+- MSI 版：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)
+
+_如果您之前未使用过 Tabular Editor 3，则可获得 30 天试用期，安装后即可激活。 你也可以 [购买许可证](https://tabulareditor.com/licensing)。_
+
+# [**SHA-256 校验和**](#tab/checksums)
+
+| 文件                                                                                                                                                                                                                                                 | .NET 运行时 | 平台    | SHA-256                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ----- | ------------------------------------------------------------------ |
+| [TabularEditor.3.26.2.Installer.x64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.x64.Net8.exe)     | .NET 8   | x64   | `CDCEEF571902E58E3368F5A60BBF6926C310B34B2CC4ABA2F3D28B9A5C1C98AC` |
+| [TabularEditor.3.26.2.x64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.msi)                                         | .NET 8   | x64   | `D3C0FA8184855C57D16D78CD9D2A44A7622E3C67CD07CFDC7B6D0EA59FB30E09` |
+| [TabularEditor.3.26.2.x64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.x64.Net8.zip)                                         | .NET 8   | x64   | `B4A2B836E6DA359E798D7546934F1A477C2F4C74D653995D77D2F182A57A8725` |
+| [TabularEditor.3.26.2.Installer.ARM64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.Installer.ARM64.Net8.exe) | .NET 8   | ARM64 | `7CC1E25D51EA665787500DC460BB533F457E26FF7AE5A4B9F44480F980F1998F` |
+| [TabularEditor.3.26.2.ARM64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.msi)                                     | .NET 8   | ARM64 | `A8A6E324D38E80140B171B5D7F84C5EBADD6AFE2810529504F332091ECF7E682` |
+| [TabularEditor.3.26.2.ARM64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.2.ARM64.Net8.zip)                                     | .NET 8   | ARM64 | `B265579D384A6586B7599CBC0A54032C5F477D3A485FC1F773F79D4B31D128C6` |
+
+***
+
+查看我们的[发布博客](https://tabulareditor.com/blog/tabular-editor-3-june-2026-release)，简要了解本次发布中最重要的更新。
+
+## 3.26.2 版本改进
+
+- 已在 TOM Explorer 中为表添加 **移到组** 右键子菜单。 该子菜单会列出现有表格组、一个 **(New...)** 条目（使用所选表创建新组并打开名称编辑器），以及一个 **(None)** 条目（移除表格组分配）。
+
+- 已用最新版本更新 AI Assistant 偏好设置中的模型预设，用户无需输入自定义模型 ID 即可选择当前模型。 已添加 Anthropic 的 `claude-fable-5` 和 `claude-opus-4-8`，以及 OpenAI 的 `gpt-5.5`/`gpt-5.5-pro` 和其他当前的 GPT-5 变体。 已移除弃用条目（例如较旧的 Codex 变体），默认 OpenAI 模型现为 `gpt-5.5`。
+
+- **Semantic Analyzer 改进**
+  - 新增对 DAX UDF 中带默认表达式的可选参数的支持。
+  - 当调用 UDF 时传入的参数与其声明类型不匹配（例如向 `TABLEREF` 参数传递标量值等），Semantic Analyzer 现在会发出合适的警告 / 错误信息
+  - Semantic Analyzer 现在会在 `IGNORE` 未直接用作 `SUMMARIZECOLUMNS` 的表达式参数、而被用于其他位置时报告错误，与引擎行为一致。
+  - Semantic Analyzer 现已支持 Power BI Desktop 2026 年四月版为 `NAMEOF` 函数引入的新可选 component 参数和 escaping 参数。 有效的 component 关键字为 `TABLE`、`COLUMN`、`MEASURE`、`CALENDAR`、`FULL`、`SELF`、`PARENT`；有效的 escaping 关键字为 `ESCAPED`、`UNESCAPED`、`MINIMALLYESCAPED`。 返回类型保持不变（标量字符串）。 例如，`EVALUATE { NAMEOF([MyMeasure], TABLE, MINIMALLYESCAPED) }` 会返回完全限定度量值引用中的表名部分。 <br/><br/>
+
+- **Semantic Bridge 改进**
+  - 现在，导入 Databricks Metric View 时会将该视图的元数据一并带入语义模型。
+    - `comment` 会成为模型、维度和度量值的描述。
+    - `display_name` 会成为 TOM 模型中面向用户显示的名称；如果未定义 `display_name`，则回退到 `name`。
+    - 度量值和维度的 `format` 会转换为 TOM 的 FormatString，并根据该格式推断生成的列或度量值的 DataType（货币、百分比、日期等）。
+      对于没有明确 TOM 对应项的格式规范，会回退到合理的默认值，并显示警告。
+  - SQL 到 DAX 的翻译已改进：行计数 (`COUNT(*)`)、`MEASURE(name)` 引用、二元运算、字面量（包括 `NULL` -> `BLANK()`）、将 `/` 映射为可安全处理空白值的 `DIVIDE`，以及括号优先级现在都能更准确地转换。
+    - 不在已识别集合内的表达式仍会回退为原样 SQL，并附带警告。
+    - 翻译后的 DAX 仅为尽力而为的结果——部署前先审核并验证。
+  - 已添加对带嵌套联接的雪花架构的支持。
+  - YAML 反序列化现同时接受顶层的 `fields:` 和 `dimensions:`：Databricks v1.1 规范将它们视为别名。
+    往返转换会保留源 YAML 中使用的关键字。 在 TE3 中创建的视图（没有源 YAML）在 v1.1 及更早版本中默认使用 `dimensions:`：`fields:` 别名是在 v1.1 规范发布后才引入的，因此我们保持与面向原始 1.1 规范的工具兼容。
+    当 v1.1+ 视图使用 `dimensions:` 时，会显示反序列化警告（规范在 v1.1+ 中将 `fields:` 标记为首选）；同样，当 v1.1 之前的视图使用 `fields:` 时，也会显示对应警告。
+    - C# 脚本界面将 `Dimension` 重命名为 `Field`（`view.Fields`, `view.AddField`, `Dimension` -> `Field`, `MakeValidationRuleForDimension` -> `MakeValidationRuleForField`, `ctx.DimensionNames` -> `ctx.FieldNames`）。
+    - 旧名称仍作为已弃用的转发别名保留，依然可以编译和运行，但会显示弃用警告，因此现有脚本以及诸如 `Model.Dimensions["x"]` 这样的已存储路径仍然可用。
+  - 窗口度量值（包括 v1.1 的 `offset:` 字段）在进行 YAML 反序列化/序列化往返时会被保留。 对于规范标记为实验性的功能，我们暂不进行转换；YAML 往返会保留它们，以免丢失。
+  - 根据更新后的 v1.1 规范，联接现已支持两个新属性：
+    - 支持 `rely:` 映射
+    - `cardinality:` 字段可往返保留两种规范值（`many_to_one`、`one_to_many`）以及省略该字段的形式。
+      遇到未知值时，会回退为 `many_to_one` 并发出警告。
+      - 声明为 `cardinality: one_to_many` 的联接仍会导入，但会有意跳过与源的关系——v1.1 规范将这类联接视为独立的事实源，并在源粒度上分别聚合。
+        仍会创建联接表，使其出现在生成的 TOM 模型中，但不会定义任何关系。
+        每个受影响的联接都会显示一条警告，说明这一差异。
+
+## 3.26.2 中的缺陷修复
+
+- 修复了 AI 聊天在 Anthropic Claude Opus 4.7+ 和 Fable 5 上因不再支持 temperature 采样参数而报 `BadRequest` 错误（“temperature is deprecated for this model”）的问题。 这套重试逻辑现在除了此前已处理的情况外，也能识别该提供商的这类措辞，并在不显式指定 temperature 的情况下透明地重新发送请求。
+
+- 在 `NAMEOF` 和 `TABLEOF` 函数的自动完成建议中，现在也会提供日历，与表、列和度量值一起显示。 这也包括尚未配置时间单位列的日历（例如刚添加、还未配置的日历），它们此前会被遗漏。 现在，输入带引号的前缀（例如 `'My Cal`）时，也会像表一样，把建议范围缩小到匹配的日历。
+
+- 表格 **Data Preview** 中的排序和分页现在在各种存储模式下都更加可靠：
+
+- 按没有属性层次结构的列排序时，不会再返回顺序错误的行。 在可能的情况下，分页现在会使用 `WINDOW` 函数（适用于支持该函数的引擎，以及具有主键的表）；否则，预览将显示前几行，并提示已禁用滚动。
+
+- 属性层次结构的可用性现在直接从服务器读取，因此即使模型在 Tabular Editor 之外被处理后，信息仍然准确。
+
+- DirectQuery 表现在会正确显示前几行（DirectQuery 不支持分页），并附带一条信息。
+
+- 预览元数据会在当前会话中缓存，并且仅在你单击 **刷新** 时更新，从而避免多余的服务器往返（包括重复的行计数查询）。
+
+- 当无法根据模型解析所属表时，DAX 格式化程序不再从 `DEFINE MEASURE` 块中移除表限定符。 此前，这可能会把有效的 `MEASURE 'Sales'[Amount] = ...` 变成无效的 `MEASURE [Amount] = ...`，从而导致语句无效。
+
+- 当将筛选器移除函数（`ALL`、`ALLSELECTED`、`REMOVEFILTERS` 或 `ALLCROSSFILTERED`）用作 DAX 用户定义函数的顶层主体表达式时，语义分析器不再误报错误，例如 `FUNCTION F = () => REMOVEFILTERS('Sales')`。 此类 UDF 在作为 `CALCULATE` 的 FILTER 参数调用时是有效的。 无效用法仍会在调用处被报告；关系修饰符（`CROSSFILTER` / `USERELATIONSHIP`）以及 `KEEPFILTERS` 作为 UDF 函数体时仍然无效，与引擎行为一致。
+
+- 在重命名被 NAMEOF 函数调用引用的表时，公式修复现在会正确更新该表引用。
+
+- 当将 `TABLEOF(...)` 作为表引用参数传递给 `ALL`、`ALLEXCEPT`、`ALLSELECTED`、`ALLNOBLANKROW`、`ALLCROSSFILTERED` 或 `REMOVEFILTERS` 时，语义分析器不再误报错误。
+
+- **更新表架构** 操作现在在对混合对象类型执行或在表格组上执行时，行为都能正确。
+
+---
+
+## 从 Tabular Editor 2.x 迁移过来？
+
+观看 [此视频](https://youtu.be/O4ATwdzCvWc)，快速了解 Tabular Editor 3 的主要功能。 另外，也请务必查看我们的[上手指南](https://docs.tabulareditor.com/onboarding/index.html)。
+
+**Tabular Editor 3 主要功能概览：**
+
+- 完全可自定义的 IDE，支持多显示器、Hi-DPI 和主题切换
+- 全新的强大 DAX 代码编辑器，具备自动完成、语法检查、代码折叠等众多功能
+- \*工作区模式，可将更改保存到磁盘，并同时将模型元数据同步到 Analysis Services
+- \*通过无限滚动预览表数据，创建 PivotGrid，或编写 DAX 查询来浏览模型或测试计算逻辑
+- \*设置数据定时刷新
+- 同时更新 Provider 和 Structured数据源的表架构（没错，连 M 查询也支持！）
+- 创建 Data model 图
+- 创建 DAX 脚本，使您能够在单个文档中编辑多个度量值或其他计算对象
+- 录制 C# Script 并保存为宏（以前称为“自定义操作”）
+- VertiPaq分析器集成
+- DAX调试器
+- 集成 DAX优化器
+- 代码操作：轻松重构你的 DAX 代码。
+
+\*=仅在连接到 Analysis Services 或 Power BI 实例时可用
+
+---
+
diff --git a/localizedContent/zh/content/references/release-notes/3_26_3.md b/localizedContent/zh/content/references/release-notes/3_26_3.md
new file mode 100644
index 000000000..851c190e5
--- /dev/null
+++ b/localizedContent/zh/content/references/release-notes/3_26_3.md
@@ -0,0 +1,65 @@
+---
+uid: release-3-26-3
+---
+
+# Tabular Editor 3.26.3
+
+# [**下载**](#tab/downloads)
+
+Tabular Editor 3.26.3 下载链接：
+
+- 下载 [Tabular Editor 3.26.3 (x64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe) _(推荐)_
+- 下载 [Tabular Editor 3.26.3 (ARM64)](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe)
+- 便携版本：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)
+- MSI 版：[x64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi), [ARM64](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)
+
+_如果您之前未使用过 Tabular Editor 3，则可获得 30 天试用期，安装后即可激活。 你也可以 [购买许可证](https://tabulareditor.com/licensing)._
+
+# [**SHA-256 校验和**](#tab/checksums)
+
+| 文件                                                                                                                                                                                                                                                 | .NET 运行时 | 平台    | SHA-256                                                            |
+| -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------ | ----- | ------------------------------------------------------------------ |
+| [TabularEditor.3.26.3.Installer.x64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.x64.Net8.exe)     | .NET 8   | x64   | `2413B042E935F010EA03E1EE7D01B6F0CDD076B10F29F1CD5651BECE1F4ADEEC` |
+| [TabularEditor.3.26.3.x64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.msi)                                         | .NET 8   | x64   | `AE7DBAE6A0432EFDB75765F6C1B3CE91495018F058A24BE67EB2BC7DF39BD915` |
+| [TabularEditor.3.26.3.x64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.x64.Net8.zip)                                         | .NET 8   | x64   | `AAEB730DADA50A424F55D0AC41961E23D09F3913A72DB240319D78271BF7DAE2` |
+| [TabularEditor.3.26.3.Installer.ARM64.Net8.exe](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.Installer.ARM64.Net8.exe) | .NET 8   | ARM64 | `8563D579F32F776A8BF4BA75D17C11B1094E1550B24DD448A2404D63860E8F78` |
+| [TabularEditor.3.26.3.ARM64.Net8.msi](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.msi)                                     | .NET 8   | ARM64 | `FC9F0B2D7B8F75BFDCBFB534CF8450E44014E706D1FB125544317A0C4683D4F2` |
+| [TabularEditor.3.26.3.ARM64.Net8.zip](https://cdn.tabulareditor.com/files/TabularEditor.3.26.3.ARM64.Net8.zip)                                     | .NET 8   | ARM64 | `37312FB9D663FA59AB07D3AA45F88B21B8FF812B8F185AF8DCFCB4D9A8583AA7` |
+
+***
+
+## 3.26.3 缺陷修复
+
+- 修复了一个问题：如果“文件 > 还原”失败（例如，当磁盘上的 TMDL 包含无法解析的引用时），未保存更改跟踪可能会在该会话的剩余时间内一直被禁用。 此前，后续编辑将不再显示表示未保存更改的星号，而“还原”或“关闭”可能会在没有任何警告的情况下直接丢弃未保存的更改。 现在，即使还原失败，更改跟踪也会保持启用。
+- 在以文件夹形式序列化的（TMDL）模型中，成功执行“文件 > 还原”后，模型不再显示为有未保存的更改。 此前，标题栏中的星号以及“从源刷新元数据？”确认提示会在此后的每次还原时持续出现，直到模型被保存。
+- 修复了 DAX 自动完成功能在当前参数上下文中建议无效的用户定义函数（UDF），并遗漏有效函数的问题。 UDF 现在会按推断出的返回类型进行筛选：在需要标量的位置，只显示返回标量、单列表格，或返回未类型化输入参数的 UDF；在需要表的位置，只显示返回表（或透传）的 UDF；此外，筛选参数（例如 CALCULATE / CALCULATETABLE 的参数）现在也会提示 UDF，而此前这类提示完全不会出现。 定义中包含语义错误的 UDF（例如需要行语境，或错误使用 MATCHBY 的 UDF）不再会出现在建议列表中，因为它们无法被合法调用。
+- DAX 格式化程序不再将 DAX 函数默认参数值中的 `=` 替换为 `:`。 此前，格式化诸如 `(p = [m]) => 1` 这样的函数时，会生成无效的 `(p: [m]) => 1`，因为格式化程序会把参数名后的任何内容都当作 `: type` 类型注解。 现在，类型注解、默认值以及两者的组合 (`p: INT64 = 1`) 都能正确格式化。
+- 修复了一个问题：在上传混淆模型的新版本后，将 DAX优化器问题标记为“已忽略”会失效，导致已忽略的问题重新显示为未解决。 现在，已忽略的问题会在混淆模型的不同版本之间保留。
+- 修复了一个间歇性崩溃（“Collection was modified”）：在上传模型或其新版本后，DAX优化器视图可能会立即发生此问题。 现在，会在进度旋转指示器仍在显示时刷新视图，而不是在窗口重绘过程中在后台刷新。
+
+---
+
+## 从 Tabular Editor 2.x 迁移过来？
+
+观看 [此视频](https://youtu.be/O4ATwdzCvWc)，快速了解 Tabular Editor 3 的主要功能。 此外，别忘了查看我们的[入门指南](https://docs.tabulareditor.com/onboarding/index.html)。
+
+**Tabular Editor 3 主要功能概览：**
+
+- 可完全自定义的 IDE，支持多显示器、Hi-DPI 和主题
+- 全新且强大的 DAX 代码编辑器，支持自动补全、语法检查、代码折叠等更多功能
+- \*工作区模式：可让你将更改保存到磁盘，同时将模型元数据同步到 Analysis Services
+- \*通过无限滚动预览表数据，创建 PivotGrid，或编写 DAX 查询来浏览模型或测试计算逻辑
+- \*安排数据刷新
+- 同时更新 Provider 数据源和 Structured数据源上的表架构（是的，甚至包括 M 查询！）
+- 创建 Data model 示意图
+- 创建 DAX 脚本，让你在一个文档中批量编辑多个度量值或其他计算对象
+- 录制 C# Script 并保存为宏（以前称为“自定义操作”）
+- 集成 VertiPaq分析器
+- DAX调试器
+- 集成 DAX优化器
+- 代码操作：轻松重构你的 DAX 代码。
+
+\*=仅在连接到 Analysis Services 或 Power BI 实例时可用
+
+---
+
diff --git a/localizedContent/zh/content/references/whats-new.md b/localizedContent/zh/content/references/whats-new.md
index e483558a1..7a49ec21c 100644
--- a/localizedContent/zh/content/references/whats-new.md
+++ b/localizedContent/zh/content/references/whats-new.md
@@ -2,7 +2,7 @@
 uid: whats-new
 title: 更新内容
 author: Morten Lønskov
-updated: 2026-03-19
+updated: 2026-06-24
 ---
 
 <script>
@@ -12,4 +12,4 @@ updated: 2026-03-19
     }
 </script>
 
-<iframe id="content-iframe" src="../whats-new/index.html?version=3.26.0" title="What's new" style="border:none;width:100%;"></iframe>
+<iframe id="content-iframe" src="../whats-new/index.html?version=3.26.2" title="What's new" style="border:none;width:100%;"></iframe>
diff --git a/localizedContent/zh/content/tutorials/udfs.md b/localizedContent/zh/content/tutorials/udfs.md
index 485656c98..43f000bfe 100644
--- a/localizedContent/zh/content/tutorials/udfs.md
+++ b/localizedContent/zh/content/tutorials/udfs.md
@@ -2,7 +2,7 @@
 uid: udfs
 title: DAX 用户自定义函数
 author: Daniel Otykier
-updated: 2026-03-19
+updated: 2026-06-24
 applies_to:
   products:
     - product: Tabular Editor 2
@@ -20,7 +20,7 @@ applies_to:
 
 # DAX 用户自定义函数
 
-DAX 用户自定义函数 (UDFs) 是语义模型的一项新功能，在 Power BI Desktop 的 2025 年九月更新中引入。
+DAX 用户自定义函数 (UDF) 是语义模型提供的一项能力。 该功能在 Power BI Desktop 2025 年九月更新中进入预览阶段，并自 Power BI 2026 年六月版本起[正式发布](https://community.fabric.microsoft.com/t5/Power-BI-Updates-Blog/DAX-User-Defined-Functions-Generally-Available/ba-p/5185738)。
 
 该功能让你能够创建可复用的 DAX 函数，并可在模型中的任何 DAX 表达式里调用，甚至在其他函数中也能调用。 这个强大的功能可帮助你保持一致性、减少代码重复，并创建更易维护的 DAX 表达式。
 
@@ -133,8 +133,31 @@ ROW(
 
 这些类型说明是可选的，但一旦指定，它们会对传入函数的参数执行隐式类型转换；同时，也会影响在 Tabular Editor 3 中编写调用该函数的 DAX 代码时的自动完成建议。
 
+Tabular Editor 3 会根据已声明的参数类型验证实参。 如果你调用 UDF 时传入的实参与其参数类型不匹配——例如，在需要 `TABLEREF` 参数的位置传入标量值——语义分析器会 Report 警告或错误。
+
 可用约束的完整列表，请参阅 [Microsoft 的 UDF 规范](https://learn.microsoft.com/en-us/dax/best-practices/dax-user-defined-functions)。
 
+### 带默认表达式的可选参数
+
+从 3.26.2 版本开始，Tabular Editor 3 支持带默认表达式的可选参数。 在参数名称后（以及任何类型或求值模式提示之后）追加 `= expression`，即可将该参数设为可选。 调用方省略该实参时，将由默认表达式提供其值。
+
+```dax
+FUNCTION AddTax =
+    (
+        amount: NUMERIC,        // 必需参数
+        taxRate: NUMERIC = 0.1  // 可选参数，默认为 10%
+    )
+    => amount * (1 + taxRate)
+```
+
+调用 `AddTax(10)` 会返回 `11`，而 `AddTax(10, 0.25)` 会返回 `12.5`。
+
+可选参数遵循以下规则：
+
+- 调用方可以将实参留空，以回退到默认值，例如 `MyFunc(1,,3)` 省略了第二个实参。 最少参数个数由最右侧必需参数的位置决定。
+- 默认表达式只能引用在函数定义位置可见的名称（列、表、度量值、函数），并且不能引用同一函数的其他参数。
+- 只有在使用默认表达式时，才会按参数的类型提示进行类型检查；如果显式传入实参，则改为检查该实参是否符合该类型提示。
+
 ## 在模型中使用 UDF
 
 ### 在对象表达式中
@@ -311,15 +334,15 @@ Tabular Editor 3 会自动识别所有注释，并在自动完成建议和工具
 
 **部署后函数无法正常工作**
 
-- 确认目标环境支持 UDF（兼容级别 1702+）。 截至 2025 年九月十六日，Power BI 服务尚不支持 UDF，Azure Analysis Services 和 SQL Server Analysis Services 也同样不支持。
+- 确认目标环境支持 UDF（兼容级别 1702+）。 Power BI 服务自 2026 年六月版本起支持 UDF。 Azure Analysis Services 和 SQL Server Analysis Services 不支持 UDF。
 
 ## 局限性
 
-- 并非所有 Power BI 环境都支持 UDF（需要特定构建版本）
+- UDF 需要 1702 或更高的兼容级别；Azure Analysis Services 和 SQL Server Analysis Services 不支持 UDF
 - UDF 不能递归（调用自身）
 
 > [!NOTE]
-> 截至 2026 年六月，UDF 已 [正式可用](https://community.fabric.microsoft.com/t5/Power-BI-Updates-Blog/DAX-User-Defined-Functions-Generally-Available/ba-p/5185738)。 作为其中的一部分，UDF 现已支持默认表达式和可选参数。 但是，在使用默认表达式语法时，Tabular Editor 3 目前会误报一条错误信息。 此问题将在 Tabular Editor 3 的下一次更新中修复。
+> 随着 UDF 于 2026 年六月[正式发布](https://community.fabric.microsoft.com/t5/Power-BI-Updates-Blog/DAX-User-Defined-Functions-Generally-Available/ba-p/5185738)，UDF 支持带默认表达式的可选参数。 Tabular Editor 3 自 3.26.2 版本起支持此语法。 较旧版本在使用默认表达式语法时会显示误报的错误信息。
 
 ---