diff --git a/.agents/skills/testing-sysml-repl/SKILL.md b/.agents/skills/testing-sysml-repl/SKILL.md
index 6268636036..d4c67287d1 100644
--- a/.agents/skills/testing-sysml-repl/SKILL.md
+++ b/.agents/skills/testing-sysml-repl/SKILL.md
@@ -6309,6 +6309,36 @@ None for these local REPL/gRPC checks.
 - Validate saved Turtle independently with rdflib; check real triples and declarations rather than
   trusting the save confirmation.
 
+
+## Migration and state-rendering comparisons
+
+- Migrate real Cameo archives through `bin/sysml model.mdzip -migrate sysml
+  -o output.sysml -migration-report output.report.txt`; source XMI is normally
+  `com.nomagic.magicdraw.uml_model.model` inside the archive.
+- Compare reports by element XMI ID, not line number or name: repeated names
+  can move records into the approximated section even when their notation was
+  successfully emitted. Preserve counts and inspect the notation as well.
+- For direction checks, resolve `informationSource`, `informationTarget`,
+  `realizingConnector`, connector ends' `partWithPort`/`role`, and part/port
+  types from XMI. A conveyed item's emitted path should end in the actual
+  flow property of the connector's port type. Include a reversed connector
+  order fixture and an unrelated-end negative control.
+- A compiler/lowering fix may repair an old migrated `.sysml` without
+  changing its state declarations. Comparing old and new notation under the
+  same new binary is not a negative control: use a separately built
+  pre-change binary to demonstrate the old empty graph.
+- Use `-render '#state:M' -render-form text` for a small state definition,
+  and `-graphs M` to inspect inherited vertices, parent IDs and transitions.
+  Unsupported inherited members may produce an empty rendering plus a
+  `cannot be inherited` note while the CLI still exits zero. Exit status and
+  strict validation alone do not establish a nonempty graph.
+- For positioned migrated views, default DOT may omit unpositioned inherited
+  nodes. Read `not represented` comments; use `-render-unplaced strip` to
+  include those nodes below the original drawing. Do not confuse omitted
+  placement with failed graph lowering. Named rendering may also print
+  validation warnings from other views; separate requested-view warnings
+  from whole-model warnings.
+
 ### Devin Secrets Needed
 
 None for native local CLI/REPL tests.
diff --git a/.circleci/config.yml b/.circleci/config.yml
index a8548d60b1..f4375f7b34 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -23,6 +23,13 @@ executors:
       - image: cimg/python:3.11
     resource_class: medium
 
+  # The -node variant of the same image: the Jupyter kernel package builds
+  # its JupyterLab extension with Node before it builds the wheels.
+  python-node-executor:
+    docker:
+      - image: cimg/python:3.11-node
+    resource_class: medium
+
   rust-executor:
     docker:
       - image: cimg/rust:1.83
@@ -1682,7 +1689,7 @@ jobs:
   # platform bundles that platform's kernel, so `pip install` alone registers
   # it; the sdist carries none and downloads by the pins.
   build-jupyter-kernel-package:
-    executor: python-executor
+    executor: python-node-executor
     steps:
       - checkout
       - rehearsal-tag
@@ -1691,9 +1698,11 @@ jobs:
       - attach_workspace:
           at: .
 
+      # jupyterlab provides `jupyter labextension build`, which bundles the
+      # extension every distribution ships (make jupyterlab-build).
       - run:
           name: Install build tooling
-          command: python -m pip install --upgrade pip build twine packaging
+          command: python -m pip install --upgrade pip build twine packaging jupyterlab==4.6.4
 
       - run:
           name: Resolve the version from the tag
@@ -1778,6 +1787,25 @@ jobs:
             # The kernelspec `install` would write names the binary it copies in.
             /tmp/verify-kernel-wheel/bin/python -m jupyter_opensysml_kernel kernelspec
 
+      # The same wheel, installed alone, put the prebuilt JupyterLab extension
+      # where JupyterLab 4 and Notebook 7 load federated extensions from.
+      - run:
+          name: Check the installed wheel registered the JupyterLab extension
+          command: |
+            /tmp/verify-kernel-wheel/bin/python - \<<'EOF'
+            import json
+            import os
+            import sys
+
+            root = os.path.join(sys.prefix, "share", "jupyter", "labextensions", "jupyterlab-opensysml")
+            with open(os.path.join(root, "package.json")) as f:
+                manifest = json.load(f)
+            load = manifest["jupyterlab"]["_build"]["load"]
+            if not os.path.isfile(os.path.join(root, load)) or not os.path.isfile(os.path.join(root, "install.json")):
+                raise SystemExit(f"Error: {root} is not a loadable federated extension (load={load!r})")
+            print(f"jupyterlab-opensysml {manifest['version']} installed at {root}, loading {load}")
+            EOF
+
       # A distribution whose table lacks any of the five kernel assets for the
       # tag, or pins a digest other than the one its binary hashes to, fails
       # the job here: every platform wheel and the sdist. The installed wheel
diff --git a/.github/workflows/nightly.yml b/.github/workflows/nightly.yml
index 5ca81ab0aa..88f9b865d9 100644
--- a/.github/workflows/nightly.yml
+++ b/.github/workflows/nightly.yml
@@ -332,9 +332,18 @@ jobs:
       - name: Build the Jupyter kernel sdist and platform wheels
         env:
           PYPI_VERSION: ${{ steps.version.outputs.pypi }}
+          NPM_VERSION: ${{ steps.version.outputs.npm }}
         run: |
-          # The sdist, then one wheel per platform bundling the kernel from dist/jupyter;
-          # the script opens each and checks what it carries.
+          # jupyterlab provides `jupyter labextension build`, which bundles the
+          # JupyterLab extension every distribution ships (make jupyterlab-build).
+          python -m pip install --only-binary ":all:" jupyterlab==4.6.4
+          # `jupyter labextension list` reports the extension's manifest version, so the
+          # manifest is stamped with the snapshot's npm version first; `npm version` keeps
+          # the lock file in step, as `npm ci` requires.
+          (cd editors/jupyterlab && npm version --no-git-tag-version "$NPM_VERSION")
+          git diff --stat -- editors/jupyterlab/package.json editors/jupyterlab/package-lock.json
+          # The extension, the sdist, then one wheel per platform bundling the kernel
+          # from dist/jupyter; the script opens each and checks what it carries.
           "$KERNEL_DIST_SCRIPT" dist/jupyter client/jupyter-kernel/dist
           # The version is PEP 440 in canonical form and the build tools normalize the
           # name, so these are the files.
@@ -344,6 +353,13 @@ jobs:
             echo "::error::expected five platform wheels for ${PYPI_VERSION}, found $#: $*"
             exit 1
           fi
+          stamped=$(unzip -p "$1" '*.data/data/share/jupyter/labextensions/jupyterlab-opensysml/package.json' \
+            | python -c 'import json, sys; print(json.load(sys.stdin)["version"])')
+          if [ "$stamped" != "$NPM_VERSION" ]; then
+            echo "::error::the labextension in $1 carries version '$stamped', not the '$NPM_VERSION' it is being published as."
+            exit 1
+          fi
+          echo "ok: the labextension carries $stamped"
           python -m twine check --strict client/jupyter-kernel/dist/*
 
       # Like the client's wheel: this platform's wheel must import at the snapshot
diff --git a/.github/workflows/pr.yml b/.github/workflows/pr.yml
index cb74289213..5672191a35 100644
--- a/.github/workflows/pr.yml
+++ b/.github/workflows/pr.yml
@@ -55,6 +55,7 @@ jobs:
       julia: ${{ steps.areas.outputs.julia }}
       matlab: ${{ steps.areas.outputs.matlab }}
       vscode: ${{ steps.areas.outputs.vscode }}
+      jupyterlab: ${{ steps.areas.outputs.jupyterlab }}
       mdk: ${{ steps.areas.outputs.mdk }}
       syson: ${{ steps.areas.outputs.syson }}
     steps:
@@ -77,10 +78,11 @@ jobs:
     needs: changes
     if: needs.changes.outputs.go == 'true'
     # The shards split the suite's slowest packages across runners so each gets its own job cap (see scripts/race-shard.sh).
+    # internal/exec/runtime alone outruns a job under -race, so it is two shards split by test name (see make test-shard).
     strategy:
       fail-fast: false
       matrix:
-        shard: [runtime, model, export, rest]
+        shard: [runtime, runtime-corpus, model, export, rest]
     runs-on: ubuntu-latest
     permissions:
       contents: read
@@ -251,8 +253,8 @@ jobs:
       - name: Download the Reference-FMUs
         run: ./scripts/download-reference-fmus.sh
 
-      # Per-package timeout: under -race the runtime package runs 31-47 minutes on
-      # these runners. Matches `make test-shard`.
+      # Per-package timeout: under -race the whole runtime package ran 31-57 minutes
+      # on these runners, hence its two shards. Matches `make test-shard`.
       - name: Run Go race tests
         env:
           SHARD: ${{ matrix.shard }}
@@ -272,8 +274,12 @@ jobs:
     permissions:
       contents: read
     timeout-minutes: 5
-    # The shard package sets are disjoint, so their blocks concatenate under one mode line.
+    # The shards' blocks concatenate under one mode line; the two runtime shards instrument
+    # the same package, so their duplicate blocks are collapsed as make coverage does.
     steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
       - name: Download shard profiles
         uses: actions/download-artifact@v4
         with:
@@ -285,12 +291,12 @@ jobs:
           set -euo pipefail
           profiles=(shards/coverage-*/coverage.txt)
           # One per race-tests shard.
-          if [ "${#profiles[@]}" -ne 4 ]; then echo "error: expected 4 shard profiles, found ${#profiles[@]}" >&2; exit 1; fi
+          if [ "${#profiles[@]}" -ne 5 ]; then echo "error: expected 5 shard profiles, found ${#profiles[@]}" >&2; exit 1; fi
           for f in "${profiles[@]}"; do
             [ "$(head -n 1 "$f")" = "mode: atomic" ] || { echo "error: $f is not an atomic-mode profile" >&2; exit 1; }
           done
           { echo "mode: atomic"; for f in "${profiles[@]}"; do tail -n +2 "$f"; done; } > coverage.txt
-          wc -l coverage.txt
+          python3 scripts/dedupe-coverage.py coverage.txt
 
       - name: Upload coverage artifact
         uses: actions/upload-artifact@v4
@@ -797,6 +803,7 @@ jobs:
       - rust-test
       - static-and-integrity
       - vscode-extension
+      - jupyterlab-extension
       - wasm-gate
       - xpect-oracle
     runs-on: ubuntu-latest
@@ -823,6 +830,7 @@ jobs:
           RUST_TEST_RESULT: ${{ needs.rust-test.result }}
           STATIC_AND_INTEGRITY_RESULT: ${{ needs.static-and-integrity.result }}
           VSCODE_EXTENSION_RESULT: ${{ needs.vscode-extension.result }}
+          JUPYTERLAB_EXTENSION_RESULT: ${{ needs.jupyterlab-extension.result }}
           WASM_GATE_RESULT: ${{ needs.wasm-gate.result }}
           XPECT_ORACLE_RESULT: ${{ needs.xpect-oracle.result }}
         run: |
@@ -844,6 +852,7 @@ jobs:
              ! ok "$RUST_TEST_RESULT" ||
              ! ok "$STATIC_AND_INTEGRITY_RESULT" ||
              ! ok "$VSCODE_EXTENSION_RESULT" ||
+             ! ok "$JUPYTERLAB_EXTENSION_RESULT" ||
              ! ok "$WASM_GATE_RESULT" ||
              ! ok "$XPECT_ORACLE_RESULT"; then
             echo "changes=$CHANGES_RESULT"
@@ -863,6 +872,7 @@ jobs:
             echo "rust-test=$RUST_TEST_RESULT"
             echo "static-and-integrity=$STATIC_AND_INTEGRITY_RESULT"
             echo "vscode-extension=$VSCODE_EXTENSION_RESULT"
+            echo "jupyterlab-extension=$JUPYTERLAB_EXTENSION_RESULT"
             echo "wasm-gate=$WASM_GATE_RESULT"
             echo "xpect-oracle=$XPECT_ORACLE_RESULT"
             exit 1
@@ -978,6 +988,49 @@ jobs:
           path: editors/vscode/opensysml-sysml.vsix
           if-no-files-found: error
 
+  jupyterlab-extension:
+    name: JupyterLab extension
+    needs: changes
+    if: needs.changes.outputs.jupyterlab == 'true'
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+    timeout-minutes: 10
+    steps:
+      - name: Check out repository
+        uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: npm
+          cache-dependency-path: editors/jupyterlab/package-lock.json
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.11'
+
+      # jupyterlab provides `jupyter labextension build`, which bundles the
+      # extension the kernel package ships. The generated syntax table is
+      # gated by go test ./editors/... in the Go suite.
+      - name: Install JupyterLab
+        run: pip install --only-binary ":all:" jupyterlab==4.6.4
+
+      - name: Test the tokenizer
+        run: make jupyterlab-test
+
+      - name: Build the prebuilt extension
+        run: make jupyterlab-build
+
+      - name: Upload JupyterLab extension artifact
+        uses: actions/upload-artifact@v4
+        with:
+          name: jupyterlab-extension
+          path: client/jupyter-kernel/labextension
+          if-no-files-found: error
+
   mdk-plugin:
     name: OpenSysML MDK plugin
     needs: [changes, build]
diff --git a/.gitignore b/.gitignore
index 169ea37cd1..4188d3517a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -70,3 +70,4 @@ cmd/*/rsrc_windows_*.syso
 
 # The kernel a platform wheel bundles, staged by the release pipeline (setup.py)
 /client/jupyter-kernel/jupyter_opensysml_kernel/bin/
+/client/jupyter-kernel/labextension/
diff --git a/CHANGELOG.md b/CHANGELOG.md
index f057ad70bc..80126a28f5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -8,7 +8,6 @@ release is described in [docs/project/releasing.md](docs/project/releasing.md).
 ## Unreleased
 
 ## 0.10.0 — 2026-10-08
-
 ### Added
 
 - **The action view draws the action's own parameters as pins on its frame, and its parameter bindings as edges.** An `action def` or action usage with `in`, `inout`, `out` or `return` parameters — declared, or a usage's inherited from its type — has them as pins on the frame boundary, inputs on the input side and outputs on the output side, as the SysML v2 action-flow notation shows them; a nested parameter's value naming the action's parameter (`in b = bread;`, `in bread = ToastBread::bread;`, `out x :>> x = y;`), an explicit `bind pack.boxed = toast;` and a `bind heat.t = pack.t;` between two nodes' pins are binding edges between the pins, in `dot`, `text`, `mermaid` and `plantuml` and through the service's render surfaces. The lowered `ActionGraph` carries the action's `Parameters` and its pins' `ValueBindings` for every consumer. The text form now lists each node's pins under it and names the pins an edge joins; Mermaid and PlantUML say which pins they cannot draw in a `not represented` notice.
@@ -258,6 +257,17 @@ release is described in [docs/project/releasing.md](docs/project/releasing.md).
 
 - **Imports that make a namespace's memberships indistinguishable are reported.** Two imports bringing members of one name or short name whose metaclasses conform — `import A::*; import B::*;` where each package owns a `part def Engine`, or one recursive `import V::**` reaching two nested `vb` — now warn once per name on the import bringing the later membership, naming every colliding member and the import it came through: `Duplicate of imported member name 'Engine': A::Engine (import A::*), B::Engine (import B::*)` (code `name-conflict`, beside the owned and inherited duplicate-name warnings). An imported member repeating one the type inherits warns the same way (`Base::x (inherited)`). Resolution is unchanged and still takes the first membership. One membership two imports both reach, an alias beside the element it names, an imported name an owned member hides, a pair whose metaclasses are unrelated and the standard library's own members are not reported.
 
+- **SysML syntax highlighting in JupyterLab 4 and Notebook 7, shipped with the kernel's pip package.** `pip install jupyter-opensysml-kernel` now installs `jupyterlab-opensysml`, a prebuilt JupyterLab extension (`editors/jupyterlab`), as shared data under `share/jupyter/labextensions`, in every platform wheel and the sdist — no Node.js, no `jupyter labextension install`. It registers the `sysml` (`text/x-sysml`, `.sysml`) and `kerml` (`text/x-kerml`, `.kerml`) CodeMirror languages, so the cells of a `sysml` notebook, `.sysml`/`.kerml` files in the editor and Markdown fences tagged `sysml` are highlighted: keywords, contextual keywords, comments and `doc` bodies, strings, numbers, unrestricted and qualified names, operators, and a cell's leading `%command`. The keyword tables are generated from the lexer by the VS Code grammar generator (`make vscode-grammar`) and gated by a test, and the kernel now reports `language_info.codemirror_mode = "sysml"`.
+
+- **`sysml model.sysml -list documents|views|diagrams|pseudo-views|all` names what a model declares by the names `-render-document` and `-render` read.** Each document or view is listed by its qualified name as the notation writes it — quoted segments, `::` inside a segment and a line break escaped as `\n` included — so it can be passed back unchanged. `views` marks a view whose kind is not produced as unsupported with the reason; `diagrams` keeps the graph-shaped views (`tree`, `interconnection`, `state`, `action`, `case`, `mixed`, `sequence`, `requirement`, `definition` and `package`); `-list-kind state,action` filters by kind; `-list-form text|tsv|json` writes aligned text, tab-separated values with a header, or a JSON array carrying each item's kind, support, reason, file and 1-based line. The REPL's `%documents` and `%views [diagrams] [<kind>...]` print the same text form, and the workspace's `AllViews` lists the views of all its own documents, each naming its declaring document.
+
+- **`%load` reads Jupyter notebooks.** A path ending in `.ipynb` — named at the prompt, on the `sysml` command line, or found under a directory or pattern beside `.sysml` and `.kerml` files — loads the notebook's code cells in order, each a source of its own, so a diagnostic names `<notebook>.ipynb cell 3` and its line in the cell, and re-loading the notebook redeclares it. A cell is loaded for what it declares: its `%` command lines and its expressions are skipped and the report says how many, so a loaded notebook runs no one's `%sweep` or `%save`. `--cells 1,3-5` or `--cells tag:<tag>` picks cells; a cell tagged `skip-load` is never loaded; a notebook written for another kernel language, or in a format other than nbformat 4, is refused with the reason.
+
+- **The REPL and the Jupyter kernel read and write a SysML v2 API repository with the OMG pilot kernel's four commands.** `%repo [<base path>]` shows or sets the server (seeded from `FLEXO_SYSMLV2_URL`, the token from `FLEXO_INTEROP_TOKEN`, never printed); `%projects` lists every project, paged to the end; `%load [--id=<project id>] [--name=<name>] [--branch=<branch name or id>] [<name>]` reads a project's model at a branch head into the session as notation and remembers where it came from; `%publish [-d] [--project=<project name>] [--branch=<branch name>] <name>` writes the elements rooted in a session element as a new project or as a commit of what changed on the branch, reporting the commit id and the counts created, updated and deleted; `-d` includes derived properties. Any server speaking the standard API serves — the pilot's `SysML-v2-API-Services` without a token, Flexo MMS with one — and the kernel answers argument problems as `UsageError`.
+- **The standard SysML v2 API client is its own package.** `internal/translate/interop/sysmlapi` drives projects, branches, commits with `change` payloads, elements and roots with optional bearer authentication and follows a server's `Link: rel="next"` paging to the end; `internal/translate/interop/flexo` keeps Flexo's extras — Layer 1 Turtle, organizations, ETag pushes — over it, and `internal/translate/interop/modelsync` holds what `sysml -sync` and the REPL share.
+
+- `%viz [--view=<VIEW>] [--style=<STYLE>...] [<form>] <name> [<name>...]` draws named elements on demand in the `sysml` REPL and the Jupyter kernel with the OMG pilot kernel's grammar: `VIEW` is `DEFAULT`, `TREE`, `INTERCONNECTION`, `STATE`, `ACTION`, `SEQUENCE`, `MIXED` or `CASE` in any letter case, `DEFAULT` choosing the rendering kind from what the names resolve to; several names draw in one diagram; `--style` maps the pilot's directions to the rendering direction and takes the `pilot`/`cameo` drawing styles, palettes and port displays, while a pilot style no form here draws (`ORTHOLINE`, `POLYLINE`, `COMPTREE`, …) is accepted and noted as not drawn. In the kernel a `%viz` cell with no form shows the diagram as Mermaid and, where Graphviz is installed, as SVG drawn from DOT.
+
 ### Changed
 
 - **A migrated operation call runs on the object its target pin holds, and send object actions are migrated.** A `CallOperationAction` whose target pin is fed by an object not read from `this` — an activity parameter, a fork, another action's output — was written as an action typed by the operation's action def running in the caller's context; it is now written with the target pin as a parameter typed by the class owning the operation, to which the operation's `context` is bound (`action n : Owner::Op { in ref :>> context = target; in target : Owner[1]; }`), and the flow into the pin is written, so the call runs on the object the pin holds. A call whose target is an object a `CreateObjectAction` creates acts on an empty pin, since `CreateObjectAction` is not migrated; the migration report says so. A `SendObjectAction` is now written `send request to target;` (or `via` its port), sending the object its request pin holds. A `StartObjectBehaviorAction` or `StartClassifierBehaviorAction` stays a placeholder keeping its pins, its note saying that a v2 object's behaviors start when the object does. The transformation census records the call operation and send object mappings as faithful and the two start mappings as a deliberate divergence, with candidate errata for the output pin's feature chain and for the send object mapping typing the sent item by its request pin.
@@ -416,6 +426,8 @@ release is described in [docs/project/releasing.md](docs/project/releasing.md).
 - **The findings SonarCloud reported against the tree since 0.9.2 are resolved.** The documentation REPL's file listings and the editor landing page's attribute rows sort with an explicit comparator, the diagram layout's nearest-side search starts from a known side, the landing page's last debugger step is an acknowledged promise, the install test's conditionals are bash's, and the nightly workflow pins the Python build tooling and npm it installs. No behaviour changes.
 - **The npm publish job installs Z3 before it runs the Node client's suite.** `publish-npm` runs the client's full test suite against the release binary before packing it, and three of those tests ask the service solver-backed verification questions; with no solver on PATH they were undecided and the job failed, as the release rehearsal showed. The job now installs Z3 ahead of the tests, as `node-test` does.
 
+- **The race suite's runtime shard is two shards.** `internal/exec/runtime` under `-race` took 31–57 minutes on the CI runners, straddling its 55-minute limit, so `make test-shard` now runs it as `runtime-corpus` (the suites that run every model of the conformance corpus: exploration, check/explore agreement, witness replay, execution conformance and its policies) and `runtime` (everything else), each about half the time. The merged coverage profile collapses the blocks the two share.
+
 ### Deprecated
 
 - **The `choice`, `junction`, `history`, `shallow history`, `deep history` and `defer` state-machine keywords are deprecated.** They still parse and lower as before — nothing is removed — but each is a `nonstandard-notation` warning (an error under `-strict`) naming the `StateMachines` metadata spelling that replaces it, with a quick-fix that performs the rewrite and adds the import.
@@ -645,6 +657,26 @@ release is described in [docs/project/releasing.md](docs/project/releasing.md).
 
 - Enumerating the members an import surfaces — completion through a wildcard import, an `expose`, the imported-name check — visited every simple path through a cycle of packages publicly re-importing one another, so six mutually importing packages did not finish; each import edge is now enumerated once per enumeration, as a lookup already searched it once.
 
+- **A decision's branch stating a trigger, or another source through `sysml:sourceFeature` alone, is refused.** `if g then b;` and `else b;` have no notation for a trigger and take their source from the member before them, yet a graph stating `sysx:trigger` on such a branch was written back without it, and one stating a different source through `sysml:sourceFeature` rather than `sysml:source`, or a second source beside the member before it, passed the source check and was rebound to that member. Each is now refused as unsupported, as a branch stating another `sysml:source`, an effect or a body already is.
+
+- **The Jupyter kernel binds its channels in `Listen` and serves them in `Serve`; `Run` is the two in sequence.** A TCP channel whose port is 0 is bound on a free port and the connection `Listen` returns names the port taken, while a port given is bound as given, so a connection file keeps naming the ports Jupyter chose. The kernel's own tests used to reserve five free ports, release them and have the kernel bind them later; another process on a busy CI runner could take one in between, and the test then waited minutes on a dial the kernel would never answer. They now bind on port 0 and dial the ports `Listen` reports, and a kernel that fails to bind fails the test at once.
+
+- **A view listing of a file read from the analysis cache reports the rendering kind the view states.** A view whose kind came from a `render` member (`render Views::asElementTable;`, `render Views::asTextualNotation;`) was listed as a `tree` view when its file was held as its cached interface record; the editor's view list and the workspace listing now read the file's parsed body first.
+
+- **A migrated item flow finds its ends through the parts and blocks a tool names.** An «ItemFlow» whose `informationSource` and `informationTarget` are the parts on the realizing connector's ends, the blocks typing them, or the connector's owner at its own port — as Cameo writes a flow drawn between parts — is now written as the `flow` between the ports those ends name. It was left as a comment, since only the connector ends' roles themselves were accepted; the report's note for a flow naming neither end now says what was tried.
+
+- **The terminal prompt prints every line of a usage error.** A repository or notebook command given wrong arguments — `%load --id x`, `%load --id=a --id=b`, `%load --tags=a a.ipynb` — printed only the usage line at the prompt, leaving out the line saying what was wrong (`--id is not an option of %load`), which the Jupyter kernel's `UsageError` traceback showed. The prompt now prints the usage and the problem, as the kernel does.
+
+- **A state usage inherits a definition that declares a view.** A `view`, `viewpoint`, `rendering` or `metadata` annotation in a state def body — what a migrated state machine diagram writes into its state def — made every usage typed by it fail to lower, so a state diagram showing such a usage rendered empty and its layout annotations warned that no node is drawn. Such members are not state content and are now passed over, like a comment or a nested definition.
+
+- **A SysML v2 API server cannot have the bearer token paged on to another host.** A `Link: rel="next"` header naming a page on another server, on another port, or over plaintext is refused with the error a redirect there gets ("the token is for *host* only"); the page is never requested with the token. Without a token the link is followed as before.
+
+- **The repository URL the environment supplies is held to the plaintext rule.** `FLEXO_SYSMLV2_URL` naming an `http://` server off this machine is refused by `%repo`, `%projects`, `%load` and `%publish` before any request goes out — the same refusal `%repo <url>` gives, lifted the same way by `FLEXO_ALLOW_PLAIN_HTTP=1` — instead of sending `FLEXO_INTEROP_TOKEN` in the clear.
+
+- **A branch read before its first commit is still checked for a moved head.** A change set computed against a branch with no head commit is refused as a stale branch when another writer made the first commit in between, instead of being posted onto the commit it never saw.
+
+- **`%publish` by name reaches the project the session loaded by id.** When the session tracks a project of that name on the server, the publish resolves it by the stored id, so a second project with the same name no longer makes the name ambiguous; `--project` naming another project and the refusal of a shared name no session project matches are unchanged.
+
 ### Security
 
 - **Refuse active SVG content and non-data URL schemes in diagram pictures.** Unsafe pictures are omitted without sanitizing their bytes, with a notice naming the refusal reason; document images, links and stylesheets remain unchanged.
@@ -665,6 +697,26 @@ release is described in [docs/project/releasing.md](docs/project/releasing.md).
 
 - **`ParseSources` re-analyzes only what an edit reaches when a client parses the same documents again.** From the second parse of a document set, the service answers from an incremental workspace held for it: unchanged documents keep their trees and diagnostics, and only the changed documents and those whose analysis read them are analyzed again. The answer is the one a fresh parse gives. On a 186-document model a re-parse after a one-line edit takes about 0.9 s instead of 1.7 s.
 
+- **Recognising `this`, `that` and `isActive` no longer builds a qualified name.** Each read of a feature chain in a calculation or action body asked whether its target was `Occurrences::Occurrence::this`, `Base::things::that` or `StateActivity::isActive` by assembling the target's fully-qualified name and comparing it; the owner chain is now compared against the known name segment by segment, so a conformant body allocates nothing for the question, and every answer is as before.
+
+- **Compiled calcs pass their Integers, Rationals, Reals and Booleans in three words.** The
+  compiled calc tier held each scalar in 56 bytes and, for every parameter, local and result,
+  boxed it back into the evaluator's constant to decide whether the declaration holds it, and
+  built the diagnostic a refusal would name whether or not one followed. A scalar is now the
+  constant packed into 24 bytes (`semantics.Packed`), unpacked without allocating; which kinds
+  a declaration holds whatever the value is decided once when the calc is compiled; the
+  diagnostic is built only on refusal; and the step charge inlines into every node.
+  `Fib(25)` interpreted runs in a fifth of the time with a quarter of the allocations; every
+  result, promotion to a big value, refusal, error message and step count is unchanged.
+
+- **The gRPC service converts a cached model's diagnostics to protobuf once.** `ParseFile`, `ParseSources` and `GetDiagnostics` on a model parsed before answered the same diagnostics converted again on every call, two allocations per warning; each document's are now converted on first use and shared by every later response, and a model answered from a lineage shares those of every document the edit did not reach. The responses are unchanged.
+
+- **A body statement's write no longer pays for its diagnostic description when it conforms.** The binding check of an assignment or declaration in an action, state or calculation body took the description of where it ran (`action node step`, `state behavior s`, `action A`) as a string built on every write; it now takes a function and formats the description only in the refusal it reports. An assignment step of an action loop allocates about a thousand fewer objects per thousand iterations, and every diagnostic reads as before.
+
+- **Replacing a document no longer copies the re-export claims of every name it re-registers.** Before a name's registration changes, the index notes what a lookup of it reads so that one registered again exactly as it was does not count as a change; the note held a copy of every document's claims and routes on the name, taken once per name touched. It now shares the index's own claim tables, which a write replaces rather than changes, so an edit beside a large model allocates a fraction of what it did. What counts as a change is as before.
+
+- Constraint checks and other runs no longer walk the succession graph for a cycle among held behaviors on every quiescent scan: the runtime remembers that no behavior is held until one enters held, by instantiation, image or snapshot restore, which cut `BenchmarkBatchConstraints` per-check time.
+
 ## 0.9.2 — 2026-10-05
 
 ### Added
diff --git a/Makefile b/Makefile
index 81d063687f..59ca917ab3 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: all build build-sysml build-prod build-wasm-prod build-lsp build-grpc build-engine build-core build-syntax build-sysml-wasm build-release-wasm build-wasm build-wasm-wasip1 build-wasm-js wasm-check static-check windows-versioninfo-check man man-check install-tree pgo-profile conformance conformance-pkg conformance-rust conformance-julia conformance-matlab test test-shard coverage coverage-shard coverage-merge lint clean install help ontology-table ontology-table-check python-metamodel python-metamodel-check fuml-expected python-test python-coverage scripts-coverage node-coverage python-install jupyter-kernel-install jupyter-kernel-test proto proto-buf python-proto proto-ts proto-rust proto-lint proto-breaking vscode-grammar vscode-build vscode-package docs docs-install docs-serve docs-engine-assets docs-landing-assets docs-counts docs-check changelog-check changelog-render self-model
+.PHONY: all build build-sysml build-prod build-wasm-prod build-lsp build-grpc build-engine build-core build-syntax build-sysml-wasm build-release-wasm build-wasm build-wasm-wasip1 build-wasm-js wasm-check static-check windows-versioninfo-check man man-check install-tree pgo-profile conformance conformance-pkg conformance-rust conformance-julia conformance-matlab test test-shard coverage coverage-shard coverage-merge lint clean install help ontology-table ontology-table-check python-metamodel python-metamodel-check fuml-expected python-test python-coverage scripts-coverage node-coverage python-install jupyter-kernel-install jupyter-kernel-test proto proto-buf python-proto proto-ts proto-rust proto-lint proto-breaking jupyterlab-build jupyterlab-test jupyterlab-install vscode-grammar vscode-build vscode-package docs docs-install docs-serve docs-engine-assets docs-landing-assets docs-counts docs-check changelog-check changelog-render self-model
 
 # Version information
 # Only release tags describe a build; the moving `nightly` tag is not a version.
@@ -53,6 +53,7 @@ NODE_DIR := client/node
 # The TypeScript protobuf plugin, installed by `npm ci` from the client's lockfile.
 PROTOC_GEN_ES := $(NODE_DIR)/node_modules/.bin/protoc-gen-es
 VSCODE_DIR := editors/vscode
+JUPYTERLAB_DIR := editors/jupyterlab
 PYTHON ?= python3
 # api/proto/buf.gen.python.yaml starts the interpreter this names.
 export PYTHON
@@ -282,12 +283,20 @@ test: ## Run Go tests with race detection and coverage
 
 # Run race-free by their own gate steps in the PR workflow's static-and-integrity job.
 RACE_SHARD_SKIP := ^(TestTrainingExamplesSemanticErrors|TestCorpusGatesCacheStateIndependent|TestPilotCorporaDiagnostics|TestPilotLibraryXMI|TestPSSMSuiteMigration|TestDifferentialRandomizedAssignments|TestDifferentialConformanceCorpus|TestDifferentialStandardLibrary|TestDifferentialTrainingCorpus|TestPortability|TestPortabilityGateIsRequired)$$
+# The runtime-corpus shard: the suites that run every model of the conformance corpus,
+# about half the package's time under -race.
+RACE_RUNTIME_CORPUS := ^Test(ExploreWithIsExploreOverTheConformanceCorpus|CheckAgreesWithExploreOverTheConformanceCorpus|CheckWitnessesReplayOverTheConformanceCorpus|ExecutionConformance|ExecutionConformanceUnderPolicies)$$
 RACE_SHARD_TOOLS_SKIP := ^(TestSuiteRead|TestSuiteClassification|TestEmitSuite|TestSuiteClassificationReasons|TestSuiteLibraryCallsAreClassified|TestSuiteReadsControlAndObjectFlow|TestSuiteReadsClassifiers|TestSuiteReadsExceptionHandlers)$$
 
-test-shard: ## Run one CI shard of the race suite (SHARD=runtime|model|export|rest)
+test-shard: ## Run one CI shard of the race suite (SHARD=runtime|runtime-corpus|model|export|rest)
 	@echo "Running Go race tests, shard $(SHARD)..."
-	@# 55m per package: the runtime shard takes 31-47 minutes under -race; its job's ceiling is 60.
-	pkgs=$$(scripts/race-shard.sh $(SHARD)) && go test -skip '$(RACE_SHARD_SKIP)' -v -race -pgo=off -timeout 55m -coverprofile=coverage.txt -covermode=atomic $$pkgs
+	@# 55m per package; its job's ceiling is 60. Whole, internal/exec/runtime took 31-57 minutes
+	@# under -race on the CI runners, so it runs as two shards of about half that each.
+	pkgs=$$(scripts/race-shard.sh $(SHARD)) && case "$(SHARD)" in \
+	  runtime-corpus) go test -run '$(RACE_RUNTIME_CORPUS)' -skip '$(RACE_SHARD_SKIP)' -v -race -pgo=off -timeout 55m -coverprofile=coverage.txt -covermode=atomic $$pkgs ;; \
+	  runtime) go test -skip '$(RACE_SHARD_SKIP)|$(RACE_RUNTIME_CORPUS)' -v -race -pgo=off -timeout 55m -coverprofile=coverage.txt -covermode=atomic $$pkgs ;; \
+	  *) go test -skip '$(RACE_SHARD_SKIP)' -v -race -pgo=off -timeout 55m -coverprofile=coverage.txt -covermode=atomic $$pkgs ;; \
+	esac
 	if [ "$(SHARD)" = rest ]; then go test -C $(TOOLS_DIR) -skip '$(RACE_SHARD_TOOLS_SKIP)' -v -race -pgo=off -timeout 55m ./...; fi
 
 coverage: ## Write the coverage profile the SonarCloud scan reads
@@ -507,11 +516,28 @@ node-coverage: ## Run Node client tests and write coverage-node.lcov
 	sed -e 's|^SF:|SF:$(NODE_DIR)/|' $(NODE_DIR)/coverage/lcov.info > coverage-node.lcov
 	@echo "✓ Wrote coverage-node.lcov"
 
-vscode-grammar: ## Regenerate the VS Code TextMate grammars from the keyword lists
-	@echo "Generating TextMate grammars..."
-	go run ./$(VSCODE_DIR)/tools/gengrammar -out $(VSCODE_DIR)/syntaxes
+vscode-grammar: ## Regenerate the VS Code TextMate grammars and the JupyterLab CodeMirror syntax table from the keyword lists
+	@echo "Generating TextMate grammars and the CodeMirror syntax table..."
+	go run ./$(VSCODE_DIR)/tools/gengrammar -out $(VSCODE_DIR)/syntaxes -codemirror-out $(JUPYTERLAB_DIR)/src/syntax.json
 	@echo "✓ Grammars generated"
 
+# `jupyter labextension build` needs the jupyterlab Python package on PATH
+# beside Node; the bundle lands in the kernel package, which ships it.
+jupyterlab-build: ## Build the JupyterLab extension into client/jupyter-kernel (needs Node and the jupyterlab package)
+	@echo "Building the JupyterLab extension..."
+	cd $(JUPYTERLAB_DIR) && npm ci && npm run build
+	cp $(JUPYTERLAB_DIR)/install.json $(JUPYTER_KERNEL_DIR)/labextension/
+	@echo "✓ Built $(JUPYTER_KERNEL_DIR)/labextension"
+
+jupyterlab-test: ## Run the JupyterLab extension's tokenizer tests
+	@echo "Running the JupyterLab extension tests..."
+	cd $(JUPYTERLAB_DIR) && npm ci && npm test
+	@echo "✓ JupyterLab extension tests passed"
+
+jupyterlab-install: jupyterlab-build ## Link the built JupyterLab extension into the current Jupyter environment for development
+	jupyter labextension develop --overwrite $(JUPYTER_KERNEL_DIR)
+	@echo "✓ Linked jupyterlab-opensysml; restart JupyterLab to load it"
+
 vscode-build: ## Type-check and bundle the VS Code extension
 	@echo "Building the VS Code extension..."
 	cd $(VSCODE_DIR) && npm ci && npm run typecheck && npm run build
diff --git a/client/jupyter-kernel/jupyter_opensysml_kernel/__init__.py b/client/jupyter-kernel/jupyter_opensysml_kernel/__init__.py
index 89d5abc059..9e794875c4 100644
--- a/client/jupyter-kernel/jupyter_opensysml_kernel/__init__.py
+++ b/client/jupyter-kernel/jupyter_opensysml_kernel/__init__.py
@@ -7,8 +7,12 @@
 verifies it against the digest pinned here for that release, and registers it::
 
     python -m jupyter_opensysml_kernel install
+
+Every distribution also installs the prebuilt JupyterLab extension that
+highlights SysML v2 in notebook cells, under ``share/jupyter/labextensions``.
 """
 
 from ._version import VERSION as __version__
+from .labextension import labextension_paths as _jupyter_labextension_paths
 
-__all__ = ["__version__"]
+__all__ = ["__version__", "_jupyter_labextension_paths"]
diff --git a/client/jupyter-kernel/jupyter_opensysml_kernel/labextension.py b/client/jupyter-kernel/jupyter_opensysml_kernel/labextension.py
new file mode 100644
index 0000000000..8ab88fd10e
--- /dev/null
+++ b/client/jupyter-kernel/jupyter_opensysml_kernel/labextension.py
@@ -0,0 +1,49 @@
+"""The prebuilt JupyterLab extension that highlights SysML v2 and KerML.
+
+``editors/jupyterlab`` builds it (``make jupyterlab-build``) into the
+``labextension/`` directory beside ``setup.py``; every distribution of the
+package then installs it as shared data under
+``share/jupyter/labextensions/jupyterlab-opensysml``, where JupyterLab 4 and
+Notebook 7 load federated extensions from, so ``pip install`` alone enables it.
+"""
+
+import os
+import re
+
+LABEXTENSION_NAME = "jupyterlab-opensysml"
+LABEXTENSION_DIR = os.path.join(os.path.dirname(os.path.dirname(os.path.abspath(__file__))), "labextension")
+SHARED_DATA = f"share/jupyter/labextensions/{LABEXTENSION_NAME}"
+
+# What a federated extension needs to load: its manifest and the webpack entry
+# the manifest's `_build.load` names.
+MANIFEST = "package.json"
+REMOTE_ENTRY = re.compile(r"^remoteEntry\.[0-9a-f]+\.js$")
+
+
+def labextension_paths() -> list[dict[str, str]]:
+    """The extension `jupyter labextension develop` links, in the shape it reads:
+    `src` is relative to this package."""
+    return [{"src": "../labextension", "dest": LABEXTENSION_NAME}]
+
+
+def is_built(root: str = LABEXTENSION_DIR) -> bool:
+    """Whether a build of the extension is staged at `root`."""
+    static = os.path.join(root, "static")
+    if not os.path.isfile(os.path.join(root, MANIFEST)) or not os.path.isdir(static):
+        return False
+    return any(REMOTE_ENTRY.match(name) for name in os.listdir(static))
+
+
+def data_files(root: str = LABEXTENSION_DIR) -> list[tuple[str, list[str]]]:
+    """setup.py's `data_files` entries for every file of the build at `root`:
+    paths relative to the package source, grouped by their share/ directory."""
+    entries: list[tuple[str, list[str]]] = []
+    source = os.path.dirname(root)
+    for directory, subdirectories, files in os.walk(root):
+        subdirectories.sort()
+        if not files:
+            continue
+        relative = os.path.relpath(directory, root)
+        target = SHARED_DATA if relative == os.curdir else f"{SHARED_DATA}/{relative.replace(os.sep, '/')}"
+        entries.append((target, [os.path.relpath(os.path.join(directory, f), source) for f in sorted(files)]))
+    return entries
diff --git a/client/jupyter-kernel/setup.py b/client/jupyter-kernel/setup.py
index 3799f834c3..76ced38e02 100644
--- a/client/jupyter-kernel/setup.py
+++ b/client/jupyter-kernel/setup.py
@@ -7,6 +7,10 @@
 Unset, the wheel is pure and carries neither, like the sdist: an install from
 either registers a verified download with `python -m jupyter_opensysml_kernel
 install`.
+
+Every distribution installs the prebuilt JupyterLab extension staged in
+`labextension/` (`make jupyterlab-build`) under
+`<prefix>/share/jupyter/labextensions`; none is built without it.
 """
 
 import os
@@ -20,6 +24,7 @@
 HERE = os.path.dirname(os.path.abspath(__file__))
 sys.path.insert(0, HERE)
 
+from jupyter_opensysml_kernel import labextension
 from jupyter_opensysml_kernel.binary import BUNDLED_DIR, binary_name, wheel_platform_tag
 from jupyter_opensysml_kernel.kernelspec import KERNEL_NAME, write_launcher_spec
 
@@ -43,6 +48,15 @@ def bundled_files() -> list[str]:
     return sorted(f for f in os.listdir(BUNDLED_DIR) if os.path.isfile(os.path.join(BUNDLED_DIR, f)))
 
 
+def labextension_data() -> list[tuple[str, list[str]]]:
+    if not labextension.is_built():
+        raise SystemExit(
+            f"{os.path.relpath(labextension.LABEXTENSION_DIR, HERE)} holds no built JupyterLab extension; "
+            "every distribution ships it: run `make jupyterlab-build` first"
+        )
+    return labextension.data_files()
+
+
 class PlatformDistribution(Distribution):
     """Platform-specific when a kernel is bundled, so the package installs as platlib
     and the wheel is tagged for the machine, though it has no extension modules."""
@@ -75,6 +89,7 @@ def run(self) -> None:
                     f"{BUNDLED_DIR} holds {', '.join(bundled)} but {PLATFORM_ENV} is unset: "
                     "a pure wheel bundles no kernel"
                 )
+            self.distribution.data_files = labextension_data()
             super().run()
             return
         expected = binary_name(self.target[0])
@@ -85,7 +100,7 @@ def run(self) -> None:
             )
         spec_dir = os.path.join(HERE, "build", "kernelspec")
         os.makedirs(spec_dir, exist_ok=True)
-        self.distribution.data_files = [(SHARED_DATA, write_launcher_spec(spec_dir))]
+        self.distribution.data_files = [(SHARED_DATA, write_launcher_spec(spec_dir)), *labextension_data()]
         super().run()
 
     def drop_stale_build_kernel(self) -> None:
@@ -96,12 +111,14 @@ def drop_stale_build_kernel(self) -> None:
 
 
 class SourceOnly(sdist):
-    """The sdist is built before any kernel is staged; it never carries one."""
+    """The sdist is built before any kernel is staged; it never carries one. It
+    does carry the labextension, so a wheel built from it installs the extension."""
 
     def run(self) -> None:
         bundled = bundled_files()
         if bundled:
             raise SystemExit(f"{BUNDLED_DIR} holds {', '.join(bundled)}: an sdist bundles no kernel")
+        self.distribution.data_files = labextension_data()
         super().run()
 
 
diff --git a/client/jupyter-kernel/tests/test_wheel.py b/client/jupyter-kernel/tests/test_wheel.py
index 4a7729bd85..7913c4c62c 100644
--- a/client/jupyter-kernel/tests/test_wheel.py
+++ b/client/jupyter-kernel/tests/test_wheel.py
@@ -1,4 +1,5 @@
-"""The platform wheels setup.py builds: tagged for their kernel, carrying it and the kernelspec."""
+"""The distributions setup.py builds: platform wheels tagged for their kernel, carrying it and
+the kernelspec, and every one of them carrying the JupyterLab extension."""
 
 import json
 import os
@@ -12,29 +13,59 @@
 
 import pytest
 
-from jupyter_opensysml_kernel import binary
+import jupyter_opensysml_kernel
+from jupyter_opensysml_kernel import binary, labextension
 from jupyter_opensysml_kernel._version import VERSION
 
 from .conftest import KERNEL_BYTES
 
 SOURCE = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 PLATFORM_ENV = "JUPYTER_OPENSYSML_KERNEL_PLATFORM"
+LABEXTENSION = "share/jupyter/labextensions/jupyterlab-opensysml/"
+REMOTE_ENTRY = "static/remoteEntry.0123456789abcdef.js"
+LABEXTENSION_FILES = {
+    "package.json": json.dumps(
+        {"name": "jupyterlab-opensysml", "jupyterlab": {"extension": True, "_build": {"load": REMOTE_ENTRY}}}
+    ).encode(),
+    "install.json": b'{"packageManager": "python", "packageName": "jupyter-opensysml-kernel"}',
+    REMOTE_ENTRY: b"// the federated entry\n",
+    "static/style.js": b"",
+}
 
 pytest.importorskip("build", reason="the distributions are built as the release builds them, with python -m build")
 
 
 @pytest.fixture
-def source_tree(tmp_path):
-    """A copy of the package source, so staging a kernel never touches the checkout."""
+def bare_tree(tmp_path):
+    """A copy of the package source without any build of the extension, so staging a
+    kernel or an extension never touches the checkout."""
     tree = tmp_path / "src"
     shutil.copytree(
         SOURCE,
         tree,
-        ignore=shutil.ignore_patterns("build", "dist", "*.egg-info", "__pycache__", ".mypy_cache", ".pytest_cache", "tests"),
+        ignore=shutil.ignore_patterns(
+            "build", "dist", "*.egg-info", "__pycache__", ".mypy_cache", ".pytest_cache", "tests", "labextension"
+        ),
     )
     return tree
 
 
+@pytest.fixture
+def source_tree(bare_tree):
+    """The source with a build of the JupyterLab extension staged, as `make jupyterlab-build` leaves it."""
+    stage_labextension(bare_tree)
+    return bare_tree
+
+
+def stage_labextension(tree):
+    root = tree / "labextension"
+    for name, data in LABEXTENSION_FILES.items():
+        path = root / name
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_bytes(data)
+    return root
+
+
 def stage(tree, goos):
     bin_dir = tree / "jupyter_opensysml_kernel" / "bin"
     bin_dir.mkdir(exist_ok=True)
@@ -66,6 +97,18 @@ def built(tree, suffix):
     return tree / "dist" / files[0]
 
 
+def labextension_members(names, prefix):
+    """The extension's files among an archive's `names`, keyed under its share/ directory."""
+    return {n[len(prefix) + len(LABEXTENSION):] for n in names if n.startswith(prefix + LABEXTENSION)}
+
+
+def assert_carries_the_labextension(zf, data_prefix):
+    names = set(zf.namelist())
+    assert labextension_members(names, data_prefix) == set(LABEXTENSION_FILES)
+    for name, data in LABEXTENSION_FILES.items():
+        assert zf.read(data_prefix + LABEXTENSION + name) == data
+
+
 def test_a_platform_wheel_bundles_the_kernel_and_registers_it(source_tree):
     stage(source_tree, "linux")
     result = build(source_tree, "wheel", "linux-amd64")
@@ -117,13 +160,16 @@ def test_a_wheel_built_after_another_platform_carries_only_its_own_kernel(source
     assert bundled == ["jupyter_opensysml_kernel/bin/sysml-jupyter-kernel.exe"]
 
 
-def test_a_pure_wheel_bundles_nothing_and_registers_nothing(source_tree):
+def test_a_pure_wheel_bundles_no_kernel_and_registers_only_the_labextension(source_tree):
     result = build(source_tree, "wheel")
     assert result.returncode == 0, result.output
     wheel = built(source_tree, ".whl")
     assert wheel.name == f"jupyter_opensysml_kernel-{VERSION}-py3-none-any.whl"
     with zipfile.ZipFile(wheel) as zf:
-        assert not any("/bin/" in n or "share/jupyter" in n for n in zf.namelist())
+        names = zf.namelist()
+        assert not any("/bin/" in n or "share/jupyter/kernels" in n for n in names)
+        assert_carries_the_labextension(zf, f"jupyter_opensysml_kernel-{VERSION}.data/data/")
+        assert not any(n.startswith("jupyter_opensysml_kernel/labextension/") for n in names), "the extension is shared data, not package data"
 
 
 def test_a_staged_kernel_without_a_platform_is_refused(source_tree):
@@ -154,13 +200,63 @@ def test_the_sdist_refuses_a_staged_kernel(source_tree):
     assert "an sdist bundles no kernel" in result.output
 
 
-def test_the_sdist_carries_setup_py_and_no_bin(source_tree):
+def test_the_sdist_carries_setup_py_and_the_labextension_and_no_bin(source_tree, tmp_path):
     result = build(source_tree, "sdist")
     assert result.returncode == 0, result.output
-    with tarfile.open(built(source_tree, ".tar.gz")) as tf:
-        names = tf.getnames()
+    sdist = built(source_tree, ".tar.gz")
+    with tarfile.open(sdist) as tf:
+        names = [m.name for m in tf.getmembers() if m.isfile()]
+        tf.extractall(tmp_path / "unpacked", filter="data")
     assert any(n.endswith("/setup.py") for n in names)
     assert not any("/bin/" in n for n in names)
+    root = f"jupyter_opensysml_kernel-{VERSION}/"
+    staged = root + "labextension/"
+    assert {n[len(staged):] for n in names if n.startswith(staged)} == set(LABEXTENSION_FILES)
+    # A wheel built from the sdist, as pip builds one, installs the extension too.
+    unpacked = tmp_path / "unpacked" / root
+    result = build(unpacked, "wheel")
+    assert result.returncode == 0, result.output
+    with zipfile.ZipFile(built(unpacked, ".whl")) as zf:
+        assert_carries_the_labextension(zf, f"jupyter_opensysml_kernel-{VERSION}.data/data/")
+
+
+@pytest.mark.parametrize("command", ["sdist", "wheel"])
+def test_no_distribution_is_built_without_the_labextension(bare_tree, command):
+    result = build(bare_tree, command)
+    assert result.returncode != 0
+    assert "run `make jupyterlab-build` first" in result.output
+
+
+def test_a_platform_wheel_is_refused_without_the_labextension(bare_tree):
+    stage(bare_tree, "linux")
+    result = build(bare_tree, "wheel", "linux-amd64")
+    assert result.returncode != 0
+    assert "run `make jupyterlab-build` first" in result.output
+
+
+def test_the_labextension_module_describes_a_staged_build(bare_tree):
+    assert not labextension.is_built(str(bare_tree / "labextension"))
+    root = stage_labextension(bare_tree)
+    assert labextension.is_built(str(root))
+    assert labextension.data_files(str(root)) == [
+        (
+            "share/jupyter/labextensions/jupyterlab-opensysml",
+            ["labextension/install.json", "labextension/package.json"],
+        ),
+        (
+            "share/jupyter/labextensions/jupyterlab-opensysml/static",
+            [
+                "labextension/static/remoteEntry.0123456789abcdef.js",
+                "labextension/static/style.js",
+            ],
+        ),
+    ]
+    (root / "static" / "remoteEntry.0123456789abcdef.js").unlink()
+    assert not labextension.is_built(str(root)), "a build without its federated entry is no build"
+
+
+def test_jupyter_labextension_develop_finds_the_extension_through_the_package():
+    assert jupyter_opensysml_kernel._jupyter_labextension_paths() == [{"src": "../labextension", "dest": "jupyterlab-opensysml"}]
 
 
 @pytest.mark.parametrize(
diff --git a/client/python/scripts/check_version.py b/client/python/scripts/check_version.py
index b964a7f69b..652cbdf737 100644
--- a/client/python/scripts/check_version.py
+++ b/client/python/scripts/check_version.py
@@ -69,6 +69,8 @@
 EDITOR_MANIFESTS = (
     ("editors/vscode/package.json", "json"),
     ("editors/vscode/package-lock.json", "lock"),
+    ("editors/jupyterlab/package.json", "json"),
+    ("editors/jupyterlab/package-lock.json", "lock"),
     ("editors/syson/frontend/package.json", "json"),
     ("editors/syson/frontend/package-lock.json", "lock"),
     ("editors/mdk/pom.xml", "pom"),
diff --git a/client/python/tests/test_check_version.py b/client/python/tests/test_check_version.py
index f07ee9ceee..3573580591 100644
--- a/client/python/tests/test_check_version.py
+++ b/client/python/tests/test_check_version.py
@@ -390,7 +390,7 @@ def test_main_refuses_rust_and_java_together():
 def _editor_tree(root, version):
     """The minimal editor manifest tree editors_version reads, at one version."""
     ns = 'xmlns="http://maven.apache.org/POM/4.0.0"'
-    for pkg in ("editors/vscode", "editors/syson/frontend"):
+    for pkg in ("editors/vscode", "editors/jupyterlab", "editors/syson/frontend"):
         (root / pkg).mkdir(parents=True, exist_ok=True)
         (root / pkg / "package.json").write_text(
             f'{{"version": "{version}"}}', encoding="utf-8"
diff --git a/cmd/sysml-jupyter-kernel/language_test.go b/cmd/sysml-jupyter-kernel/language_test.go
new file mode 100644
index 0000000000..8679e6bfc9
--- /dev/null
+++ b/cmd/sysml-jupyter-kernel/language_test.go
@@ -0,0 +1,45 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"regexp"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/buildinfo"
+)
+
+// The extension registers each language in one addLanguage call; these read
+// the sysml one's fields out of it.
+var registration = regexp.MustCompile(`(?s)addLanguage\(\{\s*name: 'sysml',(.*?)\}\)`)
+
+func TestTheLanguageInfoIsWhatTheJupyterLabExtensionRegisters(t *testing.T) {
+	info := kernelInfo(buildinfo.Info{Version: "v0.0.0-test"})
+	lang := info.Language
+	if lang.Name != "sysml" || lang.CodeMirrorMode != "sysml" || lang.MIMEType != "text/x-sysml" || lang.FileExtension != ".sysml" {
+		t.Fatalf("language_info = %+v", lang)
+	}
+	if lang.Version != "2.0" || lang.PygmentsLexer != "text" {
+		t.Errorf("language_info = %+v", lang)
+	}
+
+	path := filepath.Join("..", "..", "editors", "jupyterlab", "src", "index.ts")
+	src, err := os.ReadFile(filepath.Clean(path))
+	if err != nil {
+		t.Fatalf("read %s: %v", path, err)
+	}
+	m := registration.FindSubmatch(src)
+	if m == nil {
+		t.Fatalf("%s registers no language named %q", path, lang.CodeMirrorMode)
+	}
+	fields := string(m[1])
+	for _, want := range []string{
+		"mime: '" + lang.MIMEType + "'",
+		"extensions: ['" + strings.TrimPrefix(lang.FileExtension, ".") + "']",
+	} {
+		if !strings.Contains(fields, want) {
+			t.Errorf("%s registers sysml without %s:\n%s", path, want, fields)
+		}
+	}
+}
diff --git a/cmd/sysml-jupyter-kernel/main.go b/cmd/sysml-jupyter-kernel/main.go
index e22e72daa8..ecd6557a0f 100644
--- a/cmd/sysml-jupyter-kernel/main.go
+++ b/cmd/sysml-jupyter-kernel/main.go
@@ -131,20 +131,24 @@ func serve(opts *options, info buildinfo.Info) int {
 	return 0
 }
 
+// language is what front ends key highlighting on: the name, MIME type and
+// file extension the jupyterlab-opensysml extension registers with CodeMirror.
+var language = jupyter.LanguageInfo{
+	Name:           "sysml",
+	Version:        "2.0",
+	MIMEType:       "text/x-sysml",
+	FileExtension:  ".sysml",
+	PygmentsLexer:  "text",
+	CodeMirrorMode: "sysml",
+}
+
 // kernelInfo is what the kernel tells a front end about itself.
 func kernelInfo(info buildinfo.Info) jupyter.Info {
 	return jupyter.Info{
 		Implementation:        kernelCommand,
 		ImplementationVersion: info.Version,
-		Language: jupyter.LanguageInfo{
-			Name:           "sysml",
-			Version:        "2.0",
-			MIMEType:       "text/x-sysml",
-			FileExtension:  ".sysml",
-			PygmentsLexer:  "text",
-			CodeMirrorMode: "text/plain",
-		},
-		Banner: fmt.Sprintf("OpenSysML %s — SysML v2 in Jupyter. Declarations accumulate into the session model; %%help lists the commands.", info.Version),
+		Language:              language,
+		Banner:                fmt.Sprintf("OpenSysML %s — SysML v2 in Jupyter. Declarations accumulate into the session model; %%help lists the commands.", info.Version),
 		HelpLinks: []jupyter.HelpLink{
 			{Text: "OpenSysML REPL guide", URL: "https://open-mbee.github.io/OpenSysML/guide/04-repl/"},
 			{Text: "REPL command reference", URL: "https://open-mbee.github.io/OpenSysML/reference/repl-commands/"},
diff --git a/cmd/sysml/list.go b/cmd/sysml/list.go
new file mode 100644
index 0000000000..ab681394ab
--- /dev/null
+++ b/cmd/sysml/list.go
@@ -0,0 +1,129 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"slices"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+)
+
+// The targets -list names.
+const (
+	listDocuments   = "documents"
+	listViews       = "views"
+	listDiagrams    = "diagrams"
+	listPseudoViews = "pseudo-views"
+	listAll         = "all"
+)
+
+// The forms -list-form names.
+const (
+	listFormText = "text"
+	listFormTSV  = "tsv"
+	listFormJSON = "json"
+)
+
+func listTargets() []string {
+	return []string{listDocuments, listViews, listDiagrams, listPseudoViews, listAll}
+}
+
+func listForms() []string { return []string{listFormText, listFormTSV, listFormJSON} }
+
+// listMisuse is the refusal of a -list invocation another mode or option
+// contradicts, or "" when it stands; checks are refused separately.
+func listMisuse() string {
+	switch {
+	case renderView != "" || renderAllDir != "" || renderDoc != "" || renderDocsDir != "" || len(renderRuns) > 0:
+		return "-list names the documents and views; -render, -render-all, -render-document, -render-documents and -render-run render them; ask for one per run"
+	case convertFormat != "" || migrateFormat != "" || graphsSubject != "" || compileCalc != "" || syncDiffWith != "" || syncApplyTo != "":
+		return "-list, -convert, -migrate, -graphs, -compile, -sync-diff and -sync-apply each answer a run of their own; ask for one per run"
+	case queryText != "" || len(evalExprs) > 0 || fromFormat != "":
+		return "-list cannot be combined with -query, -eval or -from"
+	case outputPath != "":
+		return "-list writes its listing to stdout and cannot be combined with -output"
+	case len(dataImports) > 0 || importMap.given() || importFormat.given() || importDryRun || flagGiven("import-as"):
+		return "-list names the documents and views and imports nothing; -import and its -import-map, -import-format, -import-as and -import-dry-run belong to a run of their own"
+	}
+	return ""
+}
+
+// listKindFilter reads -list-kind into the kinds it names, refusing an unknown
+// kind and a filter on what has no kind to filter by.
+func listKindFilter() ([]view.Kind, error) {
+	if !flagGiven("list-kind") {
+		return nil, nil
+	}
+	if listWhat == listDocuments || listWhat == listPseudoViews {
+		return nil, fmt.Errorf("-list-kind filters the views of -list views, diagrams or all; -list %s has none to filter", listWhat)
+	}
+	var kinds []view.Kind
+	for _, name := range strings.Split(listKinds, ",") {
+		kind := view.Kind(strings.TrimSpace(name))
+		if !slices.Contains(view.Kinds(), kind) {
+			return nil, fmt.Errorf("unknown view kind %q; -list-kind takes a comma-separated list of %s", name, repl.ViewKindList())
+		}
+		kinds = append(kinds, kind)
+	}
+	return kinds, nil
+}
+
+// runList writes the documents, views or pseudo-views -list names to stdout in
+// the -list-form asked for.
+func runList(files []string) error {
+	if !slices.Contains(listTargets(), listWhat) {
+		return fmt.Errorf("unknown listing %q; -list takes %s", listWhat, strings.Join(listTargets(), ", "))
+	}
+	form := listForm
+	if form == "" {
+		form = listFormText
+	}
+	if !slices.Contains(listForms(), form) {
+		return fmt.Errorf("unknown listing form %q; -list-form takes %s", listForm, strings.Join(listForms(), ", "))
+	}
+	kinds, err := listKindFilter()
+	if err != nil {
+		return err
+	}
+	var items []repl.ListItem
+	if len(files) == 0 {
+		if listWhat != listPseudoViews {
+			return errors.New("no model to list; name the files to list, as `sysml model.sysml -list documents`")
+		}
+	} else {
+		sess, err := loadArtifactModel(files, "nothing was listed")
+		if err != nil {
+			return err
+		}
+		if listWhat == listDocuments || listWhat == listAll {
+			items = append(items, sess.ListDocuments()...)
+		}
+		if listWhat == listViews || listWhat == listDiagrams || listWhat == listAll {
+			items = append(items, sess.ListViews(listWhat == listDiagrams, kinds)...)
+		}
+	}
+	if listWhat == listPseudoViews {
+		items = repl.PseudoViewItems()
+	}
+	return writeListing(os.Stdout, items, form)
+}
+
+// writeListing writes items in form; nothing at all when there are none.
+func writeListing(w io.Writer, items []repl.ListItem, form string) error {
+	switch form {
+	case listFormTSV:
+		return repl.WriteListTSV(w, items)
+	case listFormJSON:
+		return repl.WriteListJSON(w, items)
+	}
+	for _, line := range repl.ListText(items) {
+		if _, err := fmt.Fprintln(w, line); err != nil {
+			return err
+		}
+	}
+	return nil
+}
diff --git a/cmd/sysml/list_test.go b/cmd/sysml/list_test.go
new file mode 100644
index 0000000000..007d744406
--- /dev/null
+++ b/cmd/sysml/list_test.go
@@ -0,0 +1,330 @@
+package main
+
+import (
+	"encoding/json"
+	"path/filepath"
+	"slices"
+	"strings"
+	"testing"
+)
+
+// listedModel names its documents and views as only quoting can: a quote, a
+// space, `::` inside a segment and a line break the notation escapes as \n.
+const listedModel = `package 'My Pkg' {
+	private import DocumentQueries::*;
+	private import Views::*;
+	private import StandardViewDefinitions::*;
+
+	part def Widget { part cog : Cog; }
+	part def Cog { part tooth : Tooth; }
+	part def Tooth;
+	part def Gear { part rim : Tooth; }
+
+	part def 'Doc "A"' :> Document { attribute redefines title = "Title A"; }
+	part def 'a::b doc' :> Document { attribute redefines title = "Title B"; }
+	part def 'line\nbreak' :> Document { attribute redefines title = "Title C"; }
+
+	view 'v one' { expose Widget; }
+	view 'x::y' : GridView { expose Cog; }
+	view 'nl\nview' : InterconnectionView { expose Gear; }
+	view geo : GeometryView { expose Widget; }
+}
+`
+
+const geoReason = `(unsupported: 'My Pkg'::geo: geometry rendering (view def GeometryView) is not supported)`
+
+// listItem is one decoded entry of -list-form json.
+type listItem struct {
+	Category  string `json:"category"`
+	Name      string `json:"name"`
+	Kind      string `json:"kind"`
+	Supported *bool  `json:"supported"`
+	Reason    string `json:"reason"`
+	File      string `json:"file"`
+	Line      int    `json:"line"`
+}
+
+// listRun runs the binary with args as given, the model files among them.
+func listRun(t *testing.T, binary string, args ...string) runOutcome {
+	t.Helper()
+	return runBinary(t, binary, "", args)
+}
+
+func listJSON(t *testing.T, got runOutcome) []listItem {
+	t.Helper()
+	if got.status != 0 {
+		t.Fatalf("exit = %d\n%s", got.status, got.output())
+	}
+	var items []listItem
+	if err := json.Unmarshal([]byte(got.stdout), &items); err != nil {
+		t.Fatalf("decode %q: %v", got.stdout, err)
+	}
+	return items
+}
+
+func wantLines(t *testing.T, got runOutcome, want ...string) {
+	t.Helper()
+	if got.status != 0 {
+		t.Fatalf("exit = %d\n%s", got.status, got.output())
+	}
+	lines := strings.Split(strings.TrimSuffix(got.stdout, "\n"), "\n")
+	if !slices.Equal(lines, want) {
+		t.Errorf("listed\n%s\nwant\n%s", strings.Join(lines, "\n"), strings.Join(want, "\n"))
+	}
+}
+
+// TestListTargets checks each -list target names what it lists, in qualified-name
+// order, one aligned line per item.
+func TestListTargets(t *testing.T) {
+	binary := buildCLI(t)
+	documents := []string{
+		`document  'My Pkg'::'Doc "A"'`,
+		`document  'My Pkg'::'a::b doc'`,
+		`document  'My Pkg'::'line\nbreak'`,
+	}
+	wantLines(t, check(t, binary, listedModel, "-list", "documents"), documents...)
+	wantLines(t, check(t, binary, listedModel, "-list", "views"),
+		`view  geometry         'My Pkg'::geo  `+geoReason,
+		`view  interconnection  'My Pkg'::'nl\nview'`,
+		`view  tree             'My Pkg'::'v one'`,
+		`view  table            'My Pkg'::'x::y'`,
+	)
+	wantLines(t, check(t, binary, listedModel, "-list", "diagrams"),
+		`view  interconnection  'My Pkg'::'nl\nview'`,
+		`view  tree             'My Pkg'::'v one'`,
+	)
+	wantLines(t, check(t, binary, listedModel, "-list", "all"),
+		`document  'My Pkg'::'Doc "A"'`,
+		`document  'My Pkg'::'a::b doc'`,
+		`document  'My Pkg'::'line\nbreak'`,
+		`view      geometry         'My Pkg'::geo  `+geoReason,
+		`view      interconnection  'My Pkg'::'nl\nview'`,
+		`view      tree             'My Pkg'::'v one'`,
+		`view      table            'My Pkg'::'x::y'`,
+	)
+
+	pseudo := check(t, binary, listedModel, "-list", "pseudo-views")
+	if pseudo.status != 0 || !strings.Contains(pseudo.stdout, "pseudo-view  tree             #tree\n") ||
+		!strings.Contains(pseudo.stdout, "pseudo-view  interconnection  #interconnection\n") {
+		t.Errorf("-list pseudo-views: exit = %d\n%s", pseudo.status, pseudo.output())
+	}
+	without := listRun(t, binary, "-list", "pseudo-views")
+	if without.status != 0 || without.stdout != pseudo.stdout {
+		t.Errorf("-list pseudo-views without a model: exit = %d\n%s\nwant\n%s", without.status, without.output(), pseudo.stdout)
+	}
+}
+
+// TestListForms checks the tsv and json forms carry the kind, support, file,
+// line, name and reason of each item, leaving out what an item has none of.
+func TestListForms(t *testing.T) {
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	path := writeModel(t, dir, "model.sysml", listedModel)
+
+	tsv := listRun(t, binary, path, "-list", "all", "-list-form", "tsv")
+	if tsv.status != 0 {
+		t.Fatalf("exit = %d\n%s", tsv.status, tsv.output())
+	}
+	rows := strings.Split(strings.TrimSuffix(tsv.stdout, "\n"), "\n")
+	want := []string{
+		"category\tkind\tsupported\tfile\tline\tname\treason",
+		"document\t\t\t" + path + "\t11\t'My Pkg'::'Doc \"A\"'\t",
+		"document\t\t\t" + path + "\t12\t'My Pkg'::'a::b doc'\t",
+		"document\t\t\t" + path + "\t13\t'My Pkg'::'line\\nbreak'\t",
+		"view\tgeometry\tfalse\t" + path + "\t18\t'My Pkg'::geo\t'My Pkg'::geo: geometry rendering (view def GeometryView) is not supported",
+		"view\tinterconnection\ttrue\t" + path + "\t17\t'My Pkg'::'nl\\nview'\t",
+		"view\ttree\ttrue\t" + path + "\t15\t'My Pkg'::'v one'\t",
+		"view\ttable\ttrue\t" + path + "\t16\t'My Pkg'::'x::y'\t",
+	}
+	if !slices.Equal(rows, want) {
+		t.Errorf("tsv\n%s\nwant\n%s", strings.Join(rows, "\n"), strings.Join(want, "\n"))
+	}
+
+	items := listJSON(t, listRun(t, binary, path, "-list", "all", "-list-form", "json"))
+	if len(items) != 7 {
+		t.Fatalf("json lists %d items, want 7: %+v", len(items), items)
+	}
+	doc := items[2]
+	if doc.Category != "document" || doc.Name != `'My Pkg'::'line\nbreak'` || doc.File != path || doc.Line != 13 ||
+		doc.Kind != "" || doc.Supported != nil || doc.Reason != "" {
+		t.Errorf("document item %+v", doc)
+	}
+	geo := items[3]
+	if geo.Category != "view" || geo.Kind != "geometry" || geo.Supported == nil || *geo.Supported ||
+		!strings.Contains(geo.Reason, "is not supported") || geo.Line != 18 {
+		t.Errorf("unsupported view item %+v", geo)
+	}
+	tree := items[5]
+	if tree.Kind != "tree" || tree.Supported == nil || !*tree.Supported || tree.Reason != "" {
+		t.Errorf("supported view item %+v", tree)
+	}
+	raw := listRun(t, binary, path, "-list", "documents", "-list-form", "json").stdout
+	for _, absent := range []string{`"kind"`, `"supported"`, `"reason"`} {
+		if strings.Contains(raw, absent) {
+			t.Errorf("a document item writes the empty field %s:\n%s", absent, raw)
+		}
+	}
+}
+
+// TestListAcrossFiles checks each item names the file it was declared in.
+func TestListAcrossFiles(t *testing.T) {
+	binary := buildCLI(t)
+	got := checkFiles(t, binary, map[string]string{
+		"a.sysml": "package A {\n\tprivate import DocumentQueries::*;\n\tpart def Report :> Document { attribute redefines title = \"R\"; }\n}\n",
+		"b.sysml": "package B {\n\tpart def P;\n\n\tview pv { expose P; }\n}\n",
+	}, "-list", "all", "-list-form", "json")
+	items := listJSON(t, got)
+	if len(items) != 2 {
+		t.Fatalf("listed %+v", items)
+	}
+	if items[0].Name != "A::Report" || filepath.Base(items[0].File) != "a.sysml" || items[0].Line != 3 {
+		t.Errorf("document item %+v", items[0])
+	}
+	if items[1].Name != "B::pv" || filepath.Base(items[1].File) != "b.sysml" || items[1].Line != 4 {
+		t.Errorf("view item %+v", items[1])
+	}
+}
+
+// TestListKindFilter checks -list-kind keeps the views of the kinds it names and
+// is refused where there is nothing to filter or a kind is unknown.
+func TestListKindFilter(t *testing.T) {
+	binary := buildCLI(t)
+	wantLines(t, check(t, binary, listedModel, "-list", "views", "-list-kind", "table,geometry"),
+		`view  geometry  'My Pkg'::geo  `+geoReason,
+		`view  table     'My Pkg'::'x::y'`,
+	)
+	wantLines(t, check(t, binary, listedModel, "-list", "diagrams", "-list-kind", "tree,table"),
+		`view  tree  'My Pkg'::'v one'`,
+	)
+	wantLines(t, check(t, binary, listedModel, "-list", "all", "-list-kind", "interconnection"),
+		`document  'My Pkg'::'Doc "A"'`,
+		`document  'My Pkg'::'a::b doc'`,
+		`document  'My Pkg'::'line\nbreak'`,
+		`view      interconnection  'My Pkg'::'nl\nview'`,
+	)
+	if got := check(t, binary, listedModel, "-list", "views", "-list-kind", "state"); got.status != 0 || got.stdout != "" {
+		t.Errorf("no view of the kind: exit = %d stdout = %q", got.status, got.stdout)
+	}
+
+	wantReport(t, check(t, binary, listedModel, "-list", "views", "-list-kind", "bogus"),
+		2, `unknown view kind "bogus"`, "tree, interconnection, state, action")
+	wantReport(t, check(t, binary, listedModel, "-list", "documents", "-list-kind", "tree"),
+		2, "-list documents has none to filter")
+	wantReport(t, check(t, binary, listedModel, "-list", "pseudo-views", "-list-kind", "tree"),
+		2, "-list pseudo-views has none to filter")
+}
+
+// TestListRefusals checks -list refuses what it cannot list and what it cannot
+// be combined with.
+func TestListRefusals(t *testing.T) {
+	binary := buildCLI(t)
+	wantReport(t, check(t, binary, listedModel, "-list", "bogus"), 2, `unknown listing "bogus"`, "documents, views, diagrams, pseudo-views, all")
+	wantReport(t, check(t, binary, listedModel, "-list", ""), 2, "-list is empty")
+	wantReport(t, check(t, binary, listedModel, "-list", "views", "-list-form", "xml"), 2, `unknown listing form "xml"`, "text, tsv, json")
+	wantReport(t, check(t, binary, listedModel, "-list-form", "json"), 2, "name what to list")
+	wantReport(t, check(t, binary, listedModel, "-list-kind", "tree"), 2, "name what to list")
+	wantReport(t, listRun(t, binary, "-list", "views"), 2, "no model to list")
+
+	for _, args := range [][]string{
+		{"-render", "'My Pkg'::'v one'"},
+		{"-render-all", "out"},
+		{"-render-document", "'My Pkg'::'Doc \"A\"'"},
+		{"-render-documents", "out"},
+	} {
+		wantReport(t, check(t, binary, listedModel, append([]string{"-list", "views"}, args...)...), 2, "ask for one per run")
+	}
+	for _, args := range [][]string{{"-convert", "ttl"}, {"-migrate", "sysml"}} {
+		wantReport(t, check(t, binary, listedModel, append([]string{"-list", "views"}, args...)...), 2, "ask for one per run")
+	}
+	wantReport(t, check(t, binary, listedModel, "-list", "views", "-query", "parts"), 2, "cannot be combined with -query")
+	wantReport(t, check(t, binary, listedModel, "-list", "views", "-o", "out.txt"), 2, "cannot be combined with -output")
+	wantReport(t, check(t, binary, listedModel, "-list", "views", "-constraint", "C"), 2, "check it in its own run")
+	wantReport(t, check(t, binary, listedModel, "-list", "views", "-validate"), 2, "check it in its own run")
+	for _, args := range [][]string{
+		{"-import", "values.csv"},
+		{"-import", "values.csv", "-import-dry-run"},
+		{"-import-dry-run"},
+		{"-import-as", "values"},
+	} {
+		wantReport(t, check(t, binary, listedModel, append([]string{"-list", "views"}, args...)...), 2, "imports nothing")
+	}
+	for _, args := range [][]string{{"-list", "pseudo-views"}, {"-list", "views", "-list-form", "json"}, {"-list-kind", "tree"}} {
+		wantReport(t, listRun(t, binary, append([]string{"-html-default-css"}, args...)...), 2, "-html-default-css writes the default stylesheet and nothing else")
+	}
+}
+
+// TestListEmptyModel checks a model declaring nothing to list writes nothing in
+// every form and succeeds.
+func TestListEmptyModel(t *testing.T) {
+	binary := buildCLI(t)
+	for _, what := range []string{"documents", "views", "diagrams", "all"} {
+		for _, form := range []string{"text", "tsv", "json"} {
+			got := check(t, binary, "package Empty { part def P; }\n", "-list", what, "-list-form", form)
+			if got.status != 0 || got.stdout != "" {
+				t.Errorf("-list %s -list-form %s: exit = %d stdout = %q", what, form, got.status, got.stdout)
+			}
+		}
+	}
+}
+
+// TestListModelThatDoesNotAnalyse checks a model with errors stops the run with
+// status 2 and its diagnostics, as -render-documents does.
+func TestListModelThatDoesNotAnalyse(t *testing.T) {
+	binary := buildCLI(t)
+	got := check(t, binary, "package Broken { part p : Missing; }\n", "-list", "documents")
+	wantReport(t, got, 2, "Missing", "did not analyse cleanly; nothing was listed")
+	if got.stdout != "" {
+		t.Errorf("stdout = %q, want nothing", got.stdout)
+	}
+}
+
+// TestListNamesRoundTrip checks every name -list prints, passed back unchanged,
+// resolves through -render-document or -render to the element it names.
+func TestListNamesRoundTrip(t *testing.T) {
+	binary := buildCLI(t)
+	dir := t.TempDir()
+	path := writeModel(t, dir, "model.sysml", listedModel)
+
+	titles := map[string]string{
+		`'My Pkg'::'Doc "A"'`:     "# Title A",
+		`'My Pkg'::'a::b doc'`:    "# Title B",
+		`'My Pkg'::'line\nbreak'`: "# Title C",
+	}
+	exposed := map[string]string{
+		`'My Pkg'::'v one'`:    "part def 'My Pkg'::Widget",
+		`'My Pkg'::'x::y'`:     "'My Pkg'::Cog",
+		`'My Pkg'::'nl\nview'`: "part def 'My Pkg'::Gear",
+	}
+	items := listJSON(t, listRun(t, binary, path, "-list", "all", "-list-form", "json"))
+	resolved := 0
+	for _, item := range items {
+		switch {
+		case item.Category == "document":
+			got := listRun(t, binary, path, "-render-document", item.Name)
+			if got.status != 0 || !strings.Contains(got.stdout, titles[item.Name]+"\n") || titles[item.Name] == "" {
+				t.Errorf("-render-document %s: exit = %d\n%s", item.Name, got.status, got.output())
+			}
+			resolved++
+		case *item.Supported:
+			got := listRun(t, binary, path, "-render", item.Name, "-render-form", "text")
+			if got.status != 0 || !strings.HasPrefix(got.stdout, item.Name+" - ") || exposed[item.Name] == "" ||
+				!strings.Contains(got.stdout, exposed[item.Name]) {
+				t.Errorf("-render %s: exit = %d\n%s", item.Name, got.status, got.output())
+			}
+			resolved++
+		default:
+			got := listRun(t, binary, path, "-render", item.Name, "-render-form", "text")
+			if got.status == 0 || !strings.Contains(got.stderr, item.Reason) {
+				t.Errorf("-render %s of an unsupported view: exit = %d\n%s", item.Name, got.status, got.output())
+			}
+		}
+	}
+	if resolved != len(titles)+len(exposed) {
+		t.Errorf("resolved %d names, want %d", resolved, len(titles)+len(exposed))
+	}
+
+	text := listRun(t, binary, path, "-list", "all")
+	if strings.Count(text.stdout, "\n") != len(items) {
+		t.Errorf("text listing is not one line per item:\n%s", text.stdout)
+	}
+}
diff --git a/cmd/sysml/load_test.go b/cmd/sysml/load_test.go
index bacf09f2ed..02a11a2bad 100644
--- a/cmd/sysml/load_test.go
+++ b/cmd/sysml/load_test.go
@@ -183,3 +183,35 @@ func runPaths(t *testing.T, dir, binary string, env []string, args ...string) ru
 	}
 	return result
 }
+
+// A notebook named on the command line loads its code cells, as `%load` does,
+// beside the model files; a directory contributes its notebooks too.
+func TestLoadFilesAcceptsANotebook(t *testing.T) {
+	dir := t.TempDir()
+	write(t, filepath.Join(dir, "lib.sysml"), "package Lib { part def Base; }\n")
+	nb := write(t, filepath.Join(dir, "model.ipynb"), `{"cells": [
+  {"cell_type": "markdown", "metadata": {}, "source": "# The model"},
+  {"cell_type": "code", "metadata": {}, "outputs": [], "source": ["%verbosity quiet\n", "package M {\n", "  private import Lib::*;\n", "  part def Derived :> Base;\n", "}\n", "1 + 2\n"]}
+ ], "metadata": {"kernelspec": {"language": "sysml", "name": "sysml"}}, "nbformat": 4, "nbformat_minor": 5}`)
+
+	sess := repl.NewSession()
+	if status, err := loadFiles(sess, []string{nb}); err != nil || status != exitHolds {
+		t.Fatalf("loadFiles(%s) = %d, %v", nb, status, err)
+	}
+	if got := sess.List(); len(got) != 2 {
+		t.Fatalf("want the cell and the sibling it imports in the session, got %v", got)
+	}
+
+	sess = repl.NewSession()
+	if status, err := loadFiles(sess, []string{dir}); err != nil || status != exitHolds {
+		t.Fatalf("loadFiles(%s) = %d, %v", dir, status, err)
+	}
+	if got := sess.List(); len(got) != 2 {
+		t.Fatalf("want the model file and the notebook's cell, got %v", got)
+	}
+
+	python := write(t, filepath.Join(t.TempDir(), "analysis.ipynb"), `{"cells": [], "metadata": {"kernelspec": {"language": "python", "name": "python3"}}, "nbformat": 4, "nbformat_minor": 5}`)
+	if status, err := loadFiles(repl.NewSession(), []string{python}); err == nil || status != exitUnevaluable {
+		t.Fatalf("loadFiles(%s) = %d, %v; want a python notebook refused", python, status, err)
+	}
+}
diff --git a/cmd/sysml/main.go b/cmd/sysml/main.go
index 1a475de5d7..e088b5bc86 100644
--- a/cmd/sysml/main.go
+++ b/cmd/sysml/main.go
@@ -133,6 +133,9 @@ var (
 	renderPorts      string
 	renderOverlay    string
 	renderDoc        string
+	listWhat         string
+	listKinds        string
+	listForm         string
 	renderDocsDir    string
 	docForm          string
 	diagramForm      string
@@ -450,7 +453,8 @@ func runCLI() int {
 			return 2
 		case renderDoc != "" || renderDocsDir != "" || renderView != "" || renderAllDir != "" ||
 			convertFormat != "" || migrateFormat != "" || flagGiven("sync-diff") || flagGiven("sync-apply") ||
-			queryText != "" || graphsSubject != "" || len(evalExprs) > 0 || modelChecks.requested():
+			queryText != "" || graphsSubject != "" || len(evalExprs) > 0 || modelChecks.requested() ||
+			flagGiven("list") || flagGiven("list-kind") || flagGiven("list-form"):
 			fmt.Fprintln(os.Stderr, "sysml: -html-default-css writes the default stylesheet and nothing else; ask for it in its own run")
 			return 2
 		case docForm != "" || diagramForm != "" || pdfEngine != "" || pdfTitlePage || pdfTOC || pdfNumbering || docNumberFigures || htmlPageFlagsGiven():
@@ -473,6 +477,29 @@ func runCLI() int {
 		return 2
 	}
 
+	if listWhat == "" && (flagGiven("list-kind") || flagGiven("list-form")) {
+		fmt.Fprintln(os.Stderr, "sysml: -list-kind and -list-form shape what -list lists; name what to list, as -list views")
+		return 2
+	}
+	if flagGiven("list") {
+		if listWhat == "" {
+			fmt.Fprintf(os.Stderr, "sysml: -list is empty; name what to list: %s\n", strings.Join(listTargets(), ", "))
+			return 2
+		}
+		if message := listMisuse(); message != "" {
+			fmt.Fprintln(os.Stderr, errPrefix, message)
+			return 2
+		}
+		if modelChecks.requested() {
+			return refuse(modelChecks,
+				"-list names the model's documents and views and decides nothing about it; check it in its own run")
+		}
+		if err := runList(args); err != nil {
+			return fail(err)
+		}
+		return exitHolds
+	}
+
 	if flagGiven("sync-diff") && syncDiffWith == "" {
 		fmt.Fprintln(os.Stderr, "sysml: -sync-diff is empty; name the repository graph or endpoint to diff against")
 		return 2
diff --git a/cmd/sysml/repository.go b/cmd/sysml/repository.go
new file mode 100644
index 0000000000..026155fb77
--- /dev/null
+++ b/cmd/sysml/repository.go
@@ -0,0 +1,7 @@
+//go:build !sysml_prod && !sysml_nosync
+
+package main
+
+import (
+	_ "github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext/repository" // registers the repository REPL commands
+)
diff --git a/cmd/sysml/usage.go b/cmd/sysml/usage.go
index 242a234584..51abc40e69 100644
--- a/cmd/sysml/usage.go
+++ b/cmd/sysml/usage.go
@@ -466,6 +466,32 @@ func doc() usage.Doc {
 					"The same setting shapes the diagrams of -render-document and " +
 					"-render-documents.",
 			},
+		}, {
+			Title: "Listing documents and views",
+			Examples: []usage.Example{
+				usage.Ex("sysml model.sysml -list documents", "the names -render-document reads"),
+				usage.Ex("sysml model.sysml -list views", "the names -render reads, with their kinds"),
+				usage.Ex("sysml model.sysml -list diagrams -list-kind state,action", ""),
+				usage.Ex("sysml model.sysml -list all -list-form json", ""),
+			},
+			Paragraphs: []string{
+				"-list documents lists the document definitions the loaded model declares, " +
+					"-list views its views with the rendering kind each states, a view whose kind " +
+					"this build does not produce marked unsupported with the reason, -list diagrams " +
+					"the graph-shaped views — tree, interconnection, state, action, case, mixed, " +
+					"sequence, requirement, definition and package, the kinds a document draws as " +
+					"a diagram — -list pseudo-views the pseudo-views a document declaring no view " +
+					"is rendered through, and -list all the documents followed by the views. " +
+					"Each name is the qualified name as the notation writes it, every segment " +
+					"quoted that needs it and a line break escaped as \\n, so it is passed back " +
+					"unchanged to -render-document or -render.",
+				"-list-kind keeps the views of the comma-separated kinds it names. -list-form " +
+					"text (default) writes one aligned line per item; tsv writes a header record " +
+					"category, kind, supported, file, line, name and reason, then a record per item; " +
+					"json writes an array of objects with those fields, each omitted when empty. " +
+					"file is the path the declaration was loaded from and line its 1-based line. " +
+					"A model declaring nothing to list writes nothing.",
+			},
 		}, {
 			Title: "Rendering a document",
 			Examples: []usage.Example{
@@ -690,6 +716,9 @@ func registerFlags(fs *flag.FlagSet) {
 	fs.StringVar(&renderUnplaced, "render-unplaced", "", "Where a graph form of a view some Layout positions puts the nodes none does: omit (default) leaves them undrawn in every form, strip draws them, in rows below the dot drawing; applies to -render, -render-all and document diagrams")
 
 	fs.StringVar(&renderDoc, "render-document", "", "Compile this document definition, run its queries and write the rendered document")
+	fs.StringVar(&listWhat, "list", "", "List the model's documents, views, diagrams (the graph-shaped views), pseudo-views or all of them, by the qualified names -render-document and -render read: documents, views, diagrams, pseudo-views or all")
+	fs.StringVar(&listKinds, "list-kind", "", "Comma-separated view kinds -list views, diagrams or all keeps, as state,action")
+	fs.StringVar(&listForm, "list-form", "", "Form -list writes: text (default), one aligned line per item, tsv or json")
 	fs.StringVar(&renderDocsDir, "render-documents", "", "Render every document definition, linked to one another, into this directory; a document that cannot be rendered gets a page stating why and the run exits 3")
 	fs.StringVar(&docForm, "doc-form", "", docFormUsage())
 	fs.StringVar(&diagramForm, "diagram-form", "", "Form the documents' graph-shaped diagrams are written in: mermaid, dot, plantuml or d2; D2 writes tree, interconnection, state, action, sequence, requirement, definition and package renderings, not case or mixed; unset, a positioned view is dot and any other mermaid; a table or matrix view is a table either way")
@@ -820,6 +849,13 @@ func optionGroups() []usage.OptionGroup {
 			usage.Opt("render-ports", "<display>"),
 			usage.Opt("render-overlay", "<overlay>"),
 		},
+	}, {
+		Title: "Listing documents and views",
+		Options: []usage.Option{
+			usage.Opt("list", "<what>"),
+			usage.Opt("list-kind", "<kinds>"),
+			usage.Opt("list-form", formArg),
+		},
 	}, {
 		Title: "Rendering documents",
 		Options: []usage.Option{
diff --git a/docs/guide/04-repl.md b/docs/guide/04-repl.md
index eb1a175601..7f37e2ada4 100644
--- a/docs/guide/04-repl.md
+++ b/docs/guide/04-repl.md
@@ -118,7 +118,13 @@ loaded file, edit it and load it again. Tab completion completes paths after `%l
 and meta-commands and symbol names everywhere else.
 
 A specifically named API element-form `.json` file is converted and loaded; directory and glob
-expansion still collects only `.sysml` and `.kerml` files.
+expansion collects `.sysml` and `.kerml` files and `.ipynb` notebooks.
+
+A Jupyter notebook (`.ipynb`) loads its code cells, in order, for what they declare: each cell
+is a source of its own, named `<notebook> cell <n>` in diagnostics, and the cells' `%` command
+lines and expressions are skipped rather than run — the load report counts them. `--cells 1,3-5`
+or `--cells tag:<tag>` picks cells; a cell tagged `skip-load` is never loaded. See
+[Reusing another notebook](12-jupyter.md#reusing-another-notebook).
 
 A loaded file's imports are followed to its neighbors: when a file imports a root namespace that
 neither the loaded files nor the standard library declare, the `.sysml` and `.kerml` files beside
@@ -336,6 +342,13 @@ with `render asMixedDiagram;`; `CaseView` and `MixedView` provide the same choic
 For a model with no declared view, `%render #case` and `%render #mixed` draw the loaded content, and
 `#case:<element>` or `#mixed:<element>` draws one element directly.
 
+`%viz <name> [<name>...]` is the OMG pilot kernel's spelling of the same: it draws several named
+elements in one rendering, choosing the kind from what the names resolve to (a state def draws a
+state rendering, a part with connections an interconnection, a package a tree, a mixed set a mixed
+rendering) unless `--view <VIEW>` names one, and takes the pilot's `--style` words — `LR` and `TB`
+set the direction, and a style no form here draws is noted as not represented rather than dropped.
+`%viz --view STATE P::Lamp mermaid` writes what `%render #state:P::Lamp mermaid` writes.
+
 `%render <name> mermaid` writes a graph-shaped rendering as a Mermaid diagram, `dot` as Graphviz
 DOT, and `plantuml` as PlantUML. `%render <name> markdown` writes a table as a Markdown table.
 These forms can be pasted straight into a document or an editor. A diagram node is labelled the way
diff --git a/docs/guide/12-jupyter.md b/docs/guide/12-jupyter.md
index ed6585d214..65c8af1fc6 100644
--- a/docs/guide/12-jupyter.md
+++ b/docs/guide/12-jupyter.md
@@ -64,6 +64,15 @@ pip install jupyterlab
 jupyter lab
 ```
 
+The package also carries `jupyterlab-opensysml`, a prebuilt JupyterLab extension, as shared
+data (`<prefix>/share/jupyter/labextensions/jupyterlab-opensysml`), where JupyterLab 4 and
+Notebook 7 load extensions from without a build step: `jupyter labextension list` shows it
+enabled right after `pip install`, with no Node.js and no `jupyter labextension install`.
+It highlights SysML v2 and KerML — keywords, comments and `doc` bodies, strings, numbers,
+`'unrestricted names'`, `Qualified::Names`, operators — in the cells of a `sysml` notebook,
+in `.sysml` and `.kerml` files opened in the editor, and in Markdown code fences tagged
+`sysml` or `kerml`; a cell's leading `%command` is marked as the kernel command it is.
+
 ## Cells
 
 A cell may hold declarations, `%` commands and expressions, mixed. The kernel splits it as the
@@ -115,6 +124,95 @@ whatever it holds; it is `jupyter console` that asks the kernel whether the inpu
 complete, and there <kbd>Enter</kbd> on an unfinished declaration (an unclosed brace) reads
 another line rather than running it.
 
+## Drawing an element
+
+`%viz` draws any named element on demand, with no view declared, in the grammar of the OMG
+pilot kernel's `%viz`, so a notebook written for the pilot runs unchanged:
+
+```
+%viz [--view=<VIEW>] [--style=<STYLE>...] [<form>] <NAME> [<NAME>...]
+```
+
+```
+%viz Vehicles::Car
+%viz --view Tree --style LR --style ortholine Vehicles::Car Vehicles::Wheel
+%viz --view STATE Vehicles::Lamp
+```
+
+`VIEW` is `DEFAULT`, `TREE`, `INTERCONNECTION`, `STATE`, `ACTION`, `SEQUENCE`, `MIXED` or `CASE`,
+in any letter case. `DEFAULT` — the view when `--view` is absent — chooses the rendering from what
+the names resolve to: a state def or usage draws a state diagram, an action def or usage an action
+diagram, a case def or usage a case diagram, a part or other structural usage holding a
+connection, binding or flow an interconnection diagram, and a definition, a package or a usage
+with nothing to connect a tree; names calling for different diagrams draw a mixed one. Several
+names draw in one diagram. Names resolve as `%render`'s do: qualified, or simple and in scope.
+
+Each `--style` is a direction (`TB`, `LR`, `RL`, `BT`), a drawing style (`pilot`, `cameo`), a
+palette (`okabe-ito`, `viridis`, …) or a port display (`minimal`, `full`). The pilot's other
+styles (`ORTHOLINE`, `POLYLINE`, `COMPTREE`, `SHOWINHERITED`, …) are accepted and noted in the
+diagram as not drawn, so a pilot notebook runs and nothing is dropped silently; `PUMLCODE` asks for
+the PlantUML source, as it does in the pilot. An unknown view or style is refused with the list.
+
+With no form named, a cell shows the diagram — as Mermaid, and as an SVG drawn from DOT when
+Graphviz is installed. A form (`text`, `mermaid`, `dot`, `plantuml`, `d2`) shows that form, as
+`%render` does. `%viz` is the pilot's spelling of a pseudo-view: `%viz --view STATE P::Lamp` draws
+what `%render #state:P::Lamp mermaid` writes, and `%viz P::Car P::Lamp` what a view exposing both
+would render. At the `sysml` prompt the same command prints the text rendering.
+
+## Reusing another notebook
+
+Jupyter has no import between notebooks. `%load` has: a path ending in `.ipynb` loads that
+notebook's code cells into the session, in notebook order, as if their declarations had been run
+here.
+
+```sysml
+%load wheels.ipynb
+```
+
+```text
+loaded wheels.ipynb: 3 of 4 code cells, 2 declarations
+  skipped 2 % command lines and 3 expression lines: a loaded notebook declares; its commands are not run and its expressions not evaluated
+  skipped cell 4: tagged skip-load
+✓ package Wheels
+✓ package Cars
+```
+
+What is loaded is the model: every code cell's declarations, split as the kernel splits a cell.
+Markdown and raw cells are not code. A cell's `%` command lines and its bare expressions are
+skipped — a notebook you load must not run its author's `%sweep`, `%save` or `%load`, nor spend
+your session evaluating its expressions — and the report counts what it passed over. A cell
+tagged `skip-load` (Jupyter's cell tags, in the cell's metadata) is skipped whole; tag the scratch
+cells of a notebook others load. The lines of a cell keep their numbers: an error in a loaded cell
+is reported as `wheels.ipynb cell 3:2:5` — the notebook, the cell's position among the code
+cells, then the line and column within the cell — and `%print` of a loaded name still finds its
+text.
+
+To load part of a notebook, name the cells:
+
+```sysml
+%load wheels.ipynb --cells 1,3-5
+%load wheels.ipynb --cells tag:model
+```
+
+`--cells` takes positions among the code cells, counted from 1, as single numbers and ranges, or
+`tag:<tag>` for the cells carrying a tag; one `--cells` applies to every notebook the same
+`%load` names, and may be written anywhere among the paths (`--cells=tag:model` too). A position
+past the notebook's last code cell is refused with the notebook's code-cell count; a tag no cell
+carries is refused too.
+
+Loading a notebook again redeclares it, as loading a file again does: what an earlier load of the
+whole notebook declared and the notebook no longer holds is gone. Loading picked cells replaces
+just those cells and leaves the others as they were.
+
+Only a SysML notebook loads: one whose kernel language (`metadata.kernelspec.language`, else
+`metadata.language_info.name`) is `sysml`, or that records none. A Python notebook is refused
+with `cannot load analysis.ipynb: a python notebook`; a file that is not nbformat 4 — an older
+nbformat 3 notebook, or a file that is no notebook at all — is refused with the reason.
+
+Notebooks load wherever model files do: `%load notebooks/` and `%load '*.ipynb'` pick them up
+beside `.sysml` files, `sysml wheels.ipynb` loads one on the command line, and a notebook's
+imports are followed to the files beside it as a loaded file's are.
+
 ## Rich output
 
 Output that has a richer form than text is sent in that form beside the text, and the
@@ -122,6 +220,8 @@ front end shows the richest it can:
 
 | Command | Shown as |
 |---|---|
+| `%viz <name> [<name>...]` | The diagram: a Mermaid diagram, and an SVG drawing when Graphviz is installed |
+| `%viz <form> <name>` | What `%render <view> <form>` shows |
 | `%render <view> mermaid` | A Mermaid diagram (JupyterLab 4.1 and later draw it) |
 | `%render <view> dot` | An SVG drawing when Graphviz is installed; otherwise the DOT source |
 | `%render <view> markdown` | Rendered Markdown |
@@ -149,6 +249,50 @@ The bounds the REPL takes from the environment (`OPENSYSML_MAX_STEPS`,
 kernel, read when it starts: set them in the environment of the notebook server. See
 [environment variables](../reference/environment.md).
 
+## Working with a repository
+
+The kernel round-trips models with a SysML v2 API server through the same four commands the
+OMG pilot's kernel has: `%repo` shows or sets the server, `%projects` lists its projects,
+`%load` reads a project's model into the session and `%publish` writes elements back as a new
+project or a commit. Any server speaking the standard API serves: the pilot's
+`SysML-v2-API-Services` wants no token and the default URL is its `http://localhost:9000`
+when `%repo` names it; Flexo MMS wants a bearer token and an organization. Set, in the
+environment of the notebook server:
+
+| Variable | For the pilot API server | For Flexo MMS |
+|---|---|---|
+| `FLEXO_SYSMLV2_URL` | `http://localhost:9000` | the SysML v2 API endpoint, by default `http://localhost:8083` |
+| `FLEXO_INTEROP_TOKEN` | unset | the bearer token; never put it in a cell |
+| `FLEXO_SYSMLV2_ORG` | unset | the organization, by default `sysmlv2` |
+| `FLEXO_ALLOW_PLAIN_HTTP` | unset on this machine | `1` to allow a plaintext `http://` server on another, whether `FLEXO_SYSMLV2_URL` or `%repo` names it; the token still never follows a redirect or a next-page link to another server |
+
+Then, as the pilot's notebooks do:
+
+```text
+%repo http://localhost:9000
+%projects
+%load --name=Vehicles --branch=main
+part def Truck :> Vehicles::Car;
+%publish --project=Vehicles Truck
+%publish -d --project="Trucks only" --branch=main Truck
+```
+
+`%load` takes the project by name, by `--id` or by `--name`, the branch by name or id or the
+default when absent, and submits the model as a document, so the cells after it refer to the
+loaded names; the session remembers which project, branch and commit, and a `%publish` of
+what it loaded is a commit on that branch, not a second project. `%publish <name>` names the
+project after the element's own name unless `--project` says otherwise; a project of that name
+receives a commit of what changed against the branch head, reported as the commit id with the
+counts created, updated and deleted, and no project of that name is created. The commit stays
+within its root: what the branch holds under other roots is left in place, and elements are
+deleted only from a branch the session loaded or published, since only then has it seen them;
+what was left alone is reported. `-d` sends every
+derived property the exporter computes, as the pilot's `-d` does. An argument problem is a
+`UsageError`; a server that cannot be reached, a missing project or branch, or a refused commit a
+`CommandError` with the status and the server's message. A project name two projects share is
+refused naming both ids: use `--id`. The [REPL commands reference](../reference/repl-commands.md#working-with-a-repository)
+has each command's grammar.
+
 ## Troubleshooting
 
 - **The kernel is not listed.** `jupyter kernelspec list` shows what the server sees; the
@@ -167,6 +311,11 @@ kernel, read when it starts: set them in the environment of the notebook server.
   `OPENSYSML_MAX_ACTION_STEPS` lower, or use `%step` to drive it a step at a time.
 - **Diagrams show as source.** Mermaid is drawn by JupyterLab 4.1 and later, and by Notebook
   7.1 and later; DOT is drawn only where Graphviz is installed on the kernel's machine.
+- **Cells are not highlighted.** `jupyter labextension list` must show `jupyterlab-opensysml`
+  enabled; it is shared data of the package, so it is found under the prefix of the Python
+  that runs JupyterLab or Notebook — install the package with that Python. A notebook server
+  started before the install needs a restart, and a browser tab a reload. JupyterLab 3 and
+  the classic Notebook do not load JupyterLab 4 extensions.
 
 The protocol the kernel speaks, what `kernel.json` holds, and every option are in the
 [Jupyter kernel reference](../reference/jupyter-kernel.md).
diff --git a/docs/internals/architecture.md b/docs/internals/architecture.md
index 355b1f798b..ea97e0d2cd 100644
--- a/docs/internals/architecture.md
+++ b/docs/internals/architecture.md
@@ -572,7 +572,7 @@ See [the guide](../guide/) for VS Code configuration.
 - `%help` — Show help
 - `%list` — List current session declarations
 - `%clear` — Reset session
-- `%load <file>` — Load .sysml file
+- `%load [--cells <sel>] <path>...` — Load .sysml/.kerml files and the code cells of .ipynb notebooks
 
 **Runtime execution:**
 - `%instantiate <name>` — Create instance from part def
diff --git a/docs/project/releasing.md b/docs/project/releasing.md
index 0849555439..f1b4a2dd99 100644
--- a/docs/project/releasing.md
+++ b/docs/project/releasing.md
@@ -170,7 +170,7 @@ branch that moves the integration state onto `main`:
    set `[package] version` to the same spelling and run
    `cargo update -p opensysml` in `client/rust` so the lockfile
    agrees. The editors carry the same spelling too, though nothing publishes them:
-   `"version"` in `editors/vscode/package.json` and
+   `"version"` in `editors/vscode/package.json`, `editors/jupyterlab/package.json` and
    `editors/syson/frontend/package.json`, each lock regenerated with
    `npm install --package-lock-only` in that directory; `<version>` in
    `editors/mdk/pom.xml` and `editors/syson/pom.xml`; and `<parent><version>`
diff --git a/docs/reference/cli.md b/docs/reference/cli.md
index 13ead284ba..d59b7cdff8 100644
--- a/docs/reference/cli.md
+++ b/docs/reference/cli.md
@@ -24,8 +24,14 @@ Load files and enter interactive mode:
 ```bash
 sysml model.sysml
 sysml types.sysml instances.sysml
+sysml wheels.ipynb
 ```
 
+A file argument is a `.sysml` or `.kerml` file, a directory or glob pattern (every `.sysml`,
+`.kerml` and `.ipynb` under it), an API element-form `.json` file, or a Jupyter notebook
+(`.ipynb`), whose code cells load as `%load` loads them: declarations only, `%` command lines and
+expressions skipped and counted ([Reusing another notebook](../guide/12-jupyter.md#reusing-another-notebook)).
+
 ## Non-Interactive Mode
 
 Execute expressions and exit without entering interactive mode.
@@ -256,6 +262,9 @@ the same member-path parser as `Project` and `OrderBy`.
 | `--render-document <name>` | | Compile a document definition (a `part def` specializing `DocumentQueries::Document`), run its queries against the model, render its diagram blocks through the view engine and write the result as CommonMark Markdown, as `%render-document` does. Paragraphs may hold inline runs (`Span` with a `plain`/`emphasis`/`strong`/`code` style, `Link` to a URL, `Ref` linking to another content block's anchor); a query-backed paragraph or list styles its projected values through nested `SpanColumn`/`LinkColumn` column runs; a table with a `groupBy` column writes one subtable per group value, with the query's projected properties and computed `Column` names as its columns. A `Diagram` block embeds a declared view, or an element with a stated rendering kind, in a form chosen per diagram: a view some `DiagramLayout::Layout` or `Route` positions is drawn by Graphviz where it states — inline SVG when `dot` is installed, a fenced ` ```dot ` block otherwise — and every other graph-shaped view is a fenced ` ```mermaid ` block; when Graphviz is absent a positioned view is written as Mermaid under a visible notice saying so (`-diagram-form mermaid|dot|plantuml|d2` writes every graph-shaped block in that one form; a table or matrix view is a pipe table whichever form), with an optional caption and `TB`/`LR`/`RL`/`BT` flow direction. An `Image` block (`location` a path relative to the document's file or an http(s)/file URL, optional `caption` and `alt`) renders as a CommonMark image under its caption, a relative `location` resolved beside the document's source file and written relative to the `-o` output's directory; `-doc-form pdf` draws the file — a missing local `location` is a `missing-image` error — and an `http(s)` location is fetched by the engine. Markdown is the default form; `-doc-form html` renders the same document tree as semantic HTML (see [Rendering a document as HTML](#rendering-a-document-as-html)) and `-doc-form pdf` converts the Markdown (see [Rendering a document as PDF](#rendering-a-document-as-pdf)). Combined with `--instantiate`, the document's queries run over the objects created (see [Rendering a document over objects](#rendering-a-document-over-objects)). `-json` does not apply. See the [document generation manual](../manual/README.md) |
 | `--doc-form <form>` | | Form `--render-document` writes: `markdown` (default), `html`, rendered from the document tree itself (see [Rendering a document as HTML](#rendering-a-document-as-html)), or `pdf`, which drives an external converter |
 | `--diagram-form <form>` | | Form the graph-shaped diagram blocks of `--render-document` and `--render-documents` are written in: `mermaid`, `dot`, Graphviz DOT for a toolchain that lays diagrams out with Graphviz, produced without Graphviz installed, `plantuml`, PlantUML in the Pilot visualizer's B&W style, produced without a PlantUML jar, or `d2`, a [D2](https://d2lang.com) diagram in the same look, produced without `d2`. D2 writes `tree`, `interconnection`, `state`, `action`, `sequence`, `requirement`, `definition` and `package` renderings; case and mixed views are refused with a typed error. Unset, the form is chosen per diagram: `dot` for a view some `DiagramLayout::Layout` or `Route` positions, drawn by Graphviz where it states (inline SVG in Markdown and HTML when `dot`, or `OPENSYSML_DOT`, is installed; Mermaid under a visible notice naming the missing tool when it is not), `mermaid` for every other graph-shaped view. Stated, it applies to every diagram of the document in every `--doc-form`; a table or matrix view remains a table whichever form, and a `sequence` diagram, which has no DOT form, is refused under `dot` |
+| `--list <what>` | | List what the loaded model declares by the qualified names `--render-document` and `--render` read, to stdout: `documents`, its document definitions; `views`, its views with the rendering kind each states, a view whose kind this build does not produce marked unsupported with the reason; `diagrams`, the graph-shaped views (`tree`, `interconnection`, `state`, `action`, `case`, `mixed`, `sequence`, `requirement`, `definition` and `package`); `pseudo-views`, the pseudo-views a document declaring no view is rendered through, which needs no model; or `all`, the documents followed by the views. Cannot be combined with another mode, `-import`, `-o` or a check flag (see [Listing documents and views](#listing-documents-and-views)) |
+| `--list-kind <kinds>` | | Comma-separated view kinds `--list views`, `diagrams` or `all` keeps, as `state,action`; an unknown kind is refused with the kinds there are, and `--list documents` or `pseudo-views` with the flag is refused |
+| `--list-form <form>` | | Form `--list` writes: `text` (the default), one aligned line per item; `tsv`, a header record `category`, `kind`, `supported`, `file`, `line`, `name`, `reason` then a record per item; or `json`, an array of objects with those fields, each omitted when empty |
 | `--render-documents <dir>` | | Render every document definition the model declares as a linked set into the directory, one file per document, so cross-document references resolve on disk; a document that cannot be rendered gets a page stating why and the run exits 3. `--doc-form html` writes the set as HTML pages linking shared stylesheet files written beside them |
 | `--doc-title-page` | | Put the document title on a page of its own (`--doc-form html` or `pdf`) |
 | `--doc-toc` | | Write a table of contents ahead of the content (`--doc-form html` or `pdf`) |
@@ -537,6 +546,68 @@ with `-json`; name a file for each rendering instead. `-render-run` cannot be co
 and PlantUML timeline lanes and single-state spans to their declarations. Mermaid gantt and run
 messages are not linked.
 
+## Listing documents and views
+
+`-list` names what the loaded model declares by the qualified names `-render-document` and
+`-render` read, so a name is copied from the listing and passed back unchanged:
+
+```bash
+sysml model.sysml -list documents
+# document  Reports::'Mass Report'
+# document  Reports::'line\nbreak'
+sysml model.sysml -list views
+# view  textual  Kit::asText  (unsupported: Kit::asText: textual rendering (render Views::asTextualNotation) is not supported; ...)
+# view  table    Kit::'parts table'
+# view  tree     Kit::vehicleView
+sysml model.sysml -render-document "Reports::'Mass Report'" -doc-form html -o mass.html
+```
+
+Each name is written as the notation writes it: a segment that is not a plain identifier is
+quoted, a quote inside escaped, a `::` inside a quoted segment kept within it, and a line break
+in a name written as `\n` inside the quotes, so every item stays on one line. The targets are:
+
+- `documents` — every document definition (a `part def` specializing `DocumentQueries::Document`)
+  the model's own files declare.
+- `views` — every view they declare, with the rendering kind it states. A view whose kind this
+  build does not produce (`textual`, `geometry`, `timeline`) is listed too, marked unsupported with
+  the reason `-render` would give.
+- `diagrams` — the graph-shaped views: those of the kinds `-render` draws as a graph of nodes and
+  edges and a document's `Diagram` block writes in the `-diagram-form` forms — `tree`,
+  `interconnection`, `state`, `action`, `case`, `mixed`, `sequence`, `requirement`, `definition`
+  and `package`. A `table` or `matrix` view, which a document writes as a table, and an unsupported
+  kind are not among them.
+- `pseudo-views` — the pseudo-views (`#tree`, `#state`, …) a document declaring no view is rendered
+  through; they need no model.
+- `all` — the documents followed by the views.
+
+Documents and views are each listed in qualified-name order; the library's are not listed.
+`-list-kind state,action` keeps the views of the kinds it names, under `views`, `diagrams` or
+`all`; an unknown kind is refused with the kinds there are, and so is the flag with `documents` or
+`pseudo-views`, which have no kind to filter by.
+
+```bash
+sysml model.sysml -list diagrams -list-kind state,action
+sysml model.sysml -list all -list-form tsv
+sysml model.sysml -list views -list-form json
+```
+
+`-list-form` chooses the form: `text` (the default) writes one line per item, its columns aligned
+— `document  <name>`, `view  <kind>  <name>`, an unsupported view followed by
+`  (unsupported: <reason>)`. `tsv` writes the header record
+`category	kind	supported	file	line	name	reason` and then a record per item, a tab or
+line break inside a field escaped as `\t` or `\n`. `json` writes an array of objects with the fields
+`category`, `name`, `kind`, `supported`, `reason`, `file` and `line`, each left out when empty — a
+document has no kind or support, a supported view no reason. `file` is the path the declaration
+was loaded from, as named on the command line, and `line` its 1-based line.
+
+The model is loaded and analysed as `-render-documents` loads it: one that does not load or does
+not analyse cleanly stops the run with status 2 and its diagnostics. A model that declares nothing
+to list writes nothing and exits 0. The listing goes to stdout and the loading report to stderr.
+`-list` cannot be combined with `-render`, `-render-all`, `-render-document`, `-render-documents`,
+`-render-run`, `-convert`, `-migrate`, `-graphs`, `-compile`, `-sync-diff`, `-sync-apply`, a query
+flag, `-import`, `-html-default-css`, `-o` or a check flag. The REPL's `%documents` and `%views [diagrams] [<kind>...]` print the same
+text form (see [REPL commands](repl-commands.md)).
+
 ## Rendering a view
 
 `-render <view>` renders one view of the model and exits. Every file named on the command line is
@@ -558,6 +629,12 @@ render the named element directly (`-render '#interconnection:Plant::Loop'`, quo
 Only kinds registered as pseudo-views are offered; a filter-dependent `GeneralView` graph remains
 available through its declared view.
 
+At the `sysml` prompt and in the Jupyter kernel, `%viz` is the OMG pilot kernel's spelling of the
+same rendering: `%viz [--view=<VIEW>] [--style=<STYLE>...] [<form>] <name> [<name>...]` draws
+several named elements in one diagram, `--view` naming the kind (`TREE`, `INTERCONNECTION`,
+`STATE`, `ACTION`, `SEQUENCE`, `MIXED`, `CASE`) or `DEFAULT` choosing it from what the names
+resolve to; see the [REPL commands reference](repl-commands.md).
+
 A matrix's rows are relationship sources, its columns are targets, and each cell lists its
 relationship keywords in the order `satisfy`, `verify`, `allocate`, `connect`, `derive`, `refine`,
 `dependency`. It supports text, Markdown, CSV and TSV. Mermaid, DOT, PlantUML and D2 are refused as
diff --git a/docs/reference/java-api.md b/docs/reference/java-api.md
index 7a757b7da8..7809d7a88d 100644
--- a/docs/reference/java-api.md
+++ b/docs/reference/java-api.md
@@ -11,7 +11,7 @@ dependency footprint, service ownership and release verification are in
 <dependency>
   <groupId>org.openmbee</groupId>
   <artifactId>opensysml</artifactId>
-  <version>0.9.2</version>
+  <version>0.10.0</version>
 </dependency>
 ```
 
diff --git a/docs/reference/jupyter-kernel.md b/docs/reference/jupyter-kernel.md
index 6bae8de558..298434b6ca 100644
--- a/docs/reference/jupyter-kernel.md
+++ b/docs/reference/jupyter-kernel.md
@@ -61,7 +61,7 @@ The pip package installs a kernelspec holding the binary itself and naming it th
   "metadata": {
     "implementation": "sysml-jupyter-kernel",
     "package": "jupyter-opensysml-kernel",
-    "package_version": "0.9.2"
+    "package_version": "0.10.0"
   }
 }
 ```
@@ -87,8 +87,34 @@ what a front end falls back to when a notebook names a kernel that is not instal
 | `language_info.version` | `2.0` |
 | `language_info.mimetype` | `text/x-sysml` |
 | `language_info.file_extension` | `.sysml` |
+| `language_info.codemirror_mode` | `sysml` |
 | `banner` | The REPL's greeting |
 
+`codemirror_mode` names the language the bundled JupyterLab extension registers, so a front
+end highlights the cells of a `sysml` notebook with it.
+
+## Syntax highlighting
+
+Every distribution of the pip package carries `jupyterlab-opensysml`, a prebuilt (federated)
+JupyterLab 4 and Notebook 7 extension built from `editors/jupyterlab`, installed as shared data
+at `<prefix>/share/jupyter/labextensions/jupyterlab-opensysml`. A front end in the same
+environment loads it from there: `jupyter labextension list` shows it enabled with no Node.js,
+no `jupyter labextension install` and no build. It registers two CodeMirror 6 languages with
+JupyterLab's editor language registry:
+
+| Name | MIME type | Files | Used for |
+|---|---|---|---|
+| `sysml` | `text/x-sysml` | `.sysml` | Cells of a notebook on the `sysml` kernel, which reports these in `language_info`; the file editor; Markdown fences tagged `sysml` |
+| `kerml` | `text/x-kerml` | `.kerml` | The file editor; Markdown fences tagged `kerml` |
+
+The tokenizer marks reserved keywords, the words that are keywords only in context (`chain`,
+`deep`, `done`, `history`, `junction`, `shallow`, …), the literals `true`, `false` and `null`,
+`//` and `/* */` comments, the bodies of `doc` and `comment` as documentation, strings with
+their escapes, numbers, `'unrestricted names'`, the `A::B` of qualified names, operators and
+punctuation, and a cell's first token when it is a kernel command (`%help`, `%run`, …). The
+keyword tables are generated from the lexer's keyword list by the same tool that generates the
+VS Code grammars (`make vscode-grammar`), and a test holds the committed table to the lexer.
+
 ## Cells and the protocol
 
 The kernel serves the shell, control, stdin and IOPub channels and the heartbeat over
@@ -108,9 +134,26 @@ message whose signature or framing is wrong, logging it under `-verbose`. It ans
 
 `stdin_request` is not used: no REPL command reads from the terminal.
 
+A cell may load another notebook: `%load other.ipynb` submits the other notebook's code cells
+for what they declare, skipping their `%` command lines and expressions and reporting the count,
+each cell a source named `other.ipynb cell <n>` in diagnostics; `--cells 1,3-5` or
+`--cells tag:<tag>` picks cells, a cell tagged `skip-load` is skipped, and a notebook whose
+kernel language is not `sysml` is refused. See
+[Reusing another notebook](../guide/12-jupyter.md#reusing-another-notebook).
+
 A `%quit` in a cell is noted — the notebook's shutdown ends the kernel — and an unknown
 `%` command is an error (`UnknownCommand`), where the prompt would print guidance.
 
+A `%` command given wrong arguments is a `UsageError` whose traceback is the command's usage;
+a command that fails — a repository server that cannot be reached, a project that does not exist
+— is a `CommandError` with the message the prompt would print, the HTTP status and the server's
+message included.
+
+The repository commands `%repo`, `%projects`, `%load` and `%publish` address the SysML v2 API
+server `FLEXO_SYSMLV2_URL` names, with the bearer token `FLEXO_INTEROP_TOKEN` when the server wants
+one and Flexo's organization `FLEXO_SYSMLV2_ORG`, all read from the kernel's environment; a token
+is never echoed and no state is written. See [Working with a repository](../guide/12-jupyter.md#working-with-a-repository).
+
 ## Rich output
 
 Output with a richer form than plain text is a `display_data` carrying that form beside
@@ -118,6 +161,8 @@ Output with a richer form than plain text is a `display_data` carrying that form
 
 | Output | MIME types |
 |---|---|
+| `%viz [--view=<VIEW>] [--style=<STYLE>...] <name> [<name>...]` | `text/vnd.mermaid`, and `text/vnd.graphviz` where the rendering kind has a DOT form, with `image/svg+xml` when a Graphviz `dot` is on the kernel's `PATH` |
+| `%viz [--view=<VIEW>] [--style=<STYLE>...] <form> <name> [<name>...]` | What `%render <view> <form>` carries |
 | `%render <view> mermaid` | `text/vnd.mermaid` |
 | `%render <view> dot` | `text/vnd.graphviz`, and `image/svg+xml` when a Graphviz `dot` is on the kernel's `PATH` |
 | `%render <view> markdown` | `text/markdown` |
@@ -149,7 +194,10 @@ process on Windows), so the kernel runs with no second step and no network. It p
 only `-connection-file FILE` (the file must exist), `-verbose`, `-version`, `-man` and
 `-print-kernelspec`, and refuses any other argument; the native `-install` flags have no
 place there, as the `install` subcommand below is the package's way to the same end. The
-sdist, which `pip` builds where no wheel applies, bundles nothing and registers nothing.
+sdist, which `pip` builds where no wheel applies, bundles no kernel and registers no
+kernelspec. Every wheel and the sdist install the JupyterLab extension as shared data at
+`<prefix>/share/jupyter/labextensions/jupyterlab-opensysml` (see
+[Syntax highlighting](#syntax-highlighting)); `pip uninstall` removes it with the package.
 
 ```bash
 python -m jupyter_opensysml_kernel install [--user | --sys-prefix | --prefix DIR | --system]
@@ -174,7 +222,7 @@ when set). `uninstall` removes what `install` wrote, not the wheel's shared-data
 which `pip uninstall` removes with the package.
 
 The package's version is the core release's, and it bundles and pins only that release:
-`jupyter-opensysml-kernel 0.9.2` installs `sysml-jupyter-kernel` from `v0.9.2`. Nightly
+`jupyter-opensysml-kernel 0.10.0` installs `sysml-jupyter-kernel` from `v0.10.0`. Nightly
 snapshots are published as development versions carrying the night's prerelease.
 `OPENSYSML_GITHUB_REPO` points the download at a fork that publishes the same assets.
 
diff --git a/docs/reference/rdf-mapping.md b/docs/reference/rdf-mapping.md
index b9cfec9da4..67ccdf779b 100644
--- a/docs/reference/rdf-mapping.md
+++ b/docs/reference/rdf-mapping.md
@@ -1317,7 +1317,7 @@ the node, that name is used; the rest are `sysx:` terms, marked below.
 | `accept sig : Signal;`, `accept when c;` | `sysml:AcceptActionUsage` (SysML.xtext `AcceptNode`) | the payload is the action's `sysml:payloadParameter`, owned through a `sysml:ParameterMembership` and flagged `sysml:isAccept`; `via p` is the action's `sysml:receiverArgument`, the `sysml:FeatureReferenceExpression` to `p` a second parameter binds, as a transition's trigger has it (a graph stating `sysml:via` instead still reads); and `sysx:declaredKeyword "accept"` where the optional `action` was not written; an `after`, `at` or `when` event is the payload's value, a `sysml:TriggerInvocationExpression` whose `sysml:kind` is the keyword |
 | `fork`, `join`, `merge`, `decide` | `sysml:ForkNode`, `JoinNode`, `MergeNode`, `DecisionNode` | `sysml:declaredName` |
 | `succession first a then b;`, and a state body's keyword-less `first a then b;` (a succession between two vertices, no initial node) | `sysml:SuccessionAsUsage` | `sysml:sourceFeature`, `sysml:targetFeature`, `sysx:declaredKeyword`; the keyword-less spelling comes back as `succession first a then b;` from the graph alone, the same succession |
-| `if g then b;`, `else b;` after a decision in an action body | `sysml:TransitionUsage` (SysML.xtext `GuardedTargetSuccession`, `DefaultTargetSuccession`) | its guard owned through a `sysml:TransitionFeatureMembership` of `sysml:kind "guard"` (none for `else`, which `sysx:isElse` marks), the `then` succession it owns as any transition does, `sysml:source` the decision ahead of it and `sysml:target`, and `sysx:transitionSyntax "target"`. A branch whose target is bound by position rather than named stays a `sysml:SuccessionAsUsage` with `sysx:guard`; graphs written with that form for every branch still read |
+| `if g then b;`, `else b;` after a decision in an action body | `sysml:TransitionUsage` (SysML.xtext `GuardedTargetSuccession`, `DefaultTargetSuccession`) | its guard owned through a `sysml:TransitionFeatureMembership` of `sysml:kind "guard"` (none for `else`, which `sysx:isElse` marks), the `then` succession it owns as any transition does, `sysml:source` the decision ahead of it and `sysml:target`, and `sysx:transitionSyntax "target"`. A branch whose target is bound by position rather than named stays a `sysml:SuccessionAsUsage` with `sysx:guard`; graphs written with that form for every branch still read. Reading back, a branch the notation cannot state — one stating a source (`sysml:source` or `sysml:sourceFeature`) that is not the member before it, one stating a trigger, an effect or a body, or one with neither a guard nor `sysx:isElse`, which `then` alone would write as a succession — is refused rather than written as a different branch |
 | `public succession S first a if g then b;` (a guarded succession, which is a transition) | `sysml:TransitionUsage` | as a transition, with `sysx:declaredKeyword "succession"` for the keyword written; `sysx:transitionSyntax` is derived from where the AST places the source, not from the words ahead of it, so a visibility or a name does not change it. Written back, a named form always writes `first` (`succession S first a …`, `transition T first a …`), since only a nameless `transition` may state a bare source |
 | `while c { … }`, `loop { … } until c;` | `sysml:WhileLoopActionUsage` | `sysx:whileCondition`, `sysx:untilCondition` |
 | `for x in c { … }` | `sysml:ForLoopActionUsage` | `sysx:loopVariable`, `sysx:collection` |
diff --git a/docs/reference/repl-commands.md b/docs/reference/repl-commands.md
index b07c13ba96..5632321f15 100644
--- a/docs/reference/repl-commands.md
+++ b/docs/reference/repl-commands.md
@@ -43,7 +43,8 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `%help` | Show help message |
 | `%list` | List all declarations in current session |
 | `%clear` | Clear session (reset all declarations) |
-| `%load <path>...` | Submit the contents of files, directories or globs |
+| `%load [--cells <sel>] <path>...` | Submit the contents of files, directories or globs. A `.ipynb` notebook loads its code cells in order, each a source named `<notebook> cell <n>`; the cells' `%` command lines and expressions are skipped and counted in the report, a cell tagged `skip-load` is skipped, and `--cells 1,3-5` or `--cells tag:<tag>` picks cells by position among the code cells or by tag ([Reusing another notebook](../guide/12-jupyter.md#reusing-another-notebook)) |
+| `%load [--id=<project id>] [--name=<name>] [--branch=<branch>] [<name>]` | Load a repository project's model into the session: the project named, or given by `--id` or `--name`, at the branch named by `--branch` (name or id) or its default branch. The elements at the branch head are read as SysML v2 API JSON and submitted as notation, so later input refers to the loaded names; the session remembers the project, branch and commit, and a `%publish` of the loaded element commits on that branch. A name two projects share is refused naming both ids. A lone name that is a path on disk — a separator, a `.sysml`/`.kerml`/`.ipynb` extension, a wildcard, or a file that exists — loads the files; a project whose name reads as one is loaded by `--name` ([Working with a repository](#working-with-a-repository)) |
 | `%print [name]` | Print the session model as SysML notation at the prompt, or only the named element and its body (`%print 'My Pkg'::Car`). Comments are kept, since the same writer `%save` writes notation with is used, and what is printed can be typed back in. Notation only: nothing about RDF is reported. Reading the model materializes nothing and leaves a debugging session running |
 | `%save <file>` | Write the session model to a file: `.sysml` notation (comments preserved), `.ttl` RDF or `.json` the API's element form, which are [experimental](rdf-mapping.md#status-experimental) and reported as such on each save |
 | `%import <file> [as values] [map <file>] [format csv\|tsv\|json\|jsonl] [dry-run]` | Set the feature values a CSV, TSV, JSON or JSON Lines file assigns, one row per element: an `element` column names the element and each other column a feature, with a unit as `mass [kg]`. A declared value is replaced and an inherited one redefined; an empty cell leaves a value as it was. The file is checked whole first, and a row, value or unit the model refuses imports nothing. `map` names a JSON mapping file, `format` overrides the extension, and `dry-run` prints the values without changing the model. Same import as the CLI's [`-import`](cli.md#importing-data); see [Importing data into a model](../manual/importing-data.md) |
@@ -71,6 +72,7 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `%view <name>` | Show what a view exposes: its own `expose` relationships plus the protected ones of the views it specializes, the views nested in it (each with its own exposed set), and its conformance to every viewpoint it satisfies. Conformance is a verdict of `conforms`, `violated` or `unevaluable` per viewpoint and per framed concern, with the reason, the exposed element a concern's condition failed for, and `(from <view>)` where the `satisfy` is inherited. Asking about an element that is not a view says so |
 | `%graphs <name>` | Export the lowered graph of an action or state machine, and of every behavior it performs, as the canonical `graphs:1` JSON an external analysis engine is sent ([the `graphs:1` model form](external-engines.md#the-graphs1-model-form)) — what `sysml -graphs <subject>` writes. Asking about an element that is no behavior, or a name nothing declares, says so |
 | `%render <name> [form [palette] [style] [ports] [overlay] [link=<template>]]` | Render a view's exposed set in the kind its `render` member states: a containment tree with nested views as subtrees, an interconnection diagram of the exposed parts and their connections, a state machine's states and transitions, an action's nodes and successions, case-family nodes and their actors, subjects, objectives and relationships, a mixed canvas combining structural, behavioral and case content, or a table of exposed elements and what they declare. A view without a `render` member renders as a tree. Output is indented text by default or the machine-readable form of the kind: Mermaid with `mermaid`, Markdown with `markdown`, CSV or TSV with `csv` or `tsv`; notices follow under `not represented:`. `dot` writes Graphviz DOT, `plantuml` writes PlantUML and `d2` writes D2, the last two including sequences, D2 refusing case and mixed renderings. Mermaid, DOT, PlantUML and D2 each accept the documented palettes. `mermaid [palette] pilot|cameo` and `dot [palette] pilot|cameo` select the Pilot or Cameo style (for example, `mermaid [palette] cameo` or `dot [palette] cameo`); PlantUML and D2 report the style as not represented. A GeneralView whose filters select a requirement, definition and usage, package, or case view renders as that graph ([which filters](../project/view-rendering-forms.md#generalview-graphs)), and `verdicts` after the form runs the verification cases verifying each requirement a requirement graph draws and labels and colours it by their verdicts, refused on another kind. `link=<template>` links diagram elements to their source and accepts `{file}`, `{line}`, `{col}`, `{qname}` and `{id}`; `{file}` is the path as loaded. A form the kind cannot use is refused with its supported form. The command is read-only and leaves `%action`/`%state` debugging sessions running. Empty views and unsupported kinds or elements are reported rather than substituted or dropped |
+| `%viz [--view=<VIEW>] [--style=<STYLE>...] [<form>] <name> [<name>...]` | Draw the named elements on demand, with no view declared, in the OMG pilot kernel's `%viz` grammar. `VIEW` is `DEFAULT`, `TREE`, `INTERCONNECTION`, `STATE`, `ACTION`, `SEQUENCE`, `MIXED` or `CASE` in any letter case; `DEFAULT` (the view when none is named) chooses the kind from what the names resolve to — state defs and usages a state diagram, action defs and usages an action diagram, case defs and usages a case diagram, a structural usage holding a connection an interconnection diagram, definitions, packages and other usages a tree, and names calling for different kinds a mixed diagram. Several names draw in one diagram. Each `--style` is a direction (`TB`, `LR`, `RL`, `BT`), a drawing style (`pilot`, `cameo`), a palette or a port display; a pilot style no form here draws (`ORTHOLINE`, `POLYLINE`, `COMPTREE`, …) is accepted and noted as not drawn; `PUMLCODE` asks for the `plantuml` form. The form is any `%render` form, `text` when none is named; an unquoted word spelling a form is the form. `%viz --view STATE P::Lamp mermaid` writes what `%render #state:P::Lamp mermaid` writes |
 | `%render-run <timeline\|sequence> [text\|mermaid\|plantuml\|dot] [link=<template>]` | Render the current session's recorded run as state occupancy over time or as ordered messages; text is the default. Requires `%trace on` before the run, accepts Mermaid or PlantUML, and refuses DOT. `link=<template>` links sequence object participants and PlantUML timeline lanes and single-state spans; Mermaid gantt and messages remain unlinked. It leaves the session and its trace unchanged |
 | **Instantiation & Inspection** | |
 | `%instantiate <name>` | Create an object of a part definition and start the behaviors its type exhibits or performs. Each object runs its own machine, initialized after its feature values are built and run until it is quiescent. A second `%instantiate` of the same name creates a new object, and the name then refers to that one. A later submission keeps the object's identity but restarts its behaviors from their initial states, and says so |
@@ -83,6 +85,8 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `%analysis <name>[(<args>)] [<object>]` | Run an analysis or verification case — a calculation performed as an action — and print its `out` and `return` values with their units, then the verdict of its `objective` and of each `assert constraint` in its body: `satisfied`, `not satisfied` with the violated condition, or `undecided` with the reason the condition could not be evaluated. An objective typed by a requirement def binds the def's subject as a requirement usage does (`subject = ship;`, `subject s = ship;` or `subject :>> s = ship;`), reading the case's subject, parameters and steps' outputs; one binding none checks the case's result, the library's default for it (`Cases::Case::obj`), and is `undecided` naming the type when that result is not of the subject's type. Arguments in parentheses bind the case's `in` parameters, positionally (`%analysis An::Case(3.0)`) or by name (`%analysis An::Case(limit = 3.0)`), evaluated at the prompt like `%calc`'s; an [object reference](#object-references) after them is the case's `subject` (`%analysis An::CostAnalysis An::barge`). A usage that binds its subject (`subject s = ship;`) needs no object; a definition, or a usage that binds none, is refused by name without one, as `%requirement` refuses an unbound subject. A usage nested in a part runs as a feature of the object the session holds for that part (`%instantiate An::holder`, then `%analysis An::Holder::inner`). The body's `action` steps, sequenced by `then` or by declaration order, run as an action does, later steps reading earlier steps' outputs; a step that fails, a body that deadlocks or exhausts the step budget, a case that runs itself, and an `in` parameter with no argument and no default are errors naming the case; a case recursing without bound through a nested `analysis` step reports the depth limit on one line, its repeated frames collapsed to a count as `%calc`'s are. `%calc` refuses an analysis case and says to run it this way. A `verification def` or `verification` usage runs the same way and reports in addition the `VerdictKind` its body produced: `pass`/`fail` from the library's own `VerificationCases::PassIf` calculation, a `VerdictKind` literal the body bound, `inconclusive` for a body producing no verdict value, or `error` with the reason a body's run could not be carried out; each nested verification step is reported on its own line, marked `(subcase)`, the library stating no roll-up. A `TradeStudies::TradeStudy` runs the same way — the library's own expressions apply the case's `evaluationFunction` to each alternative the subject lists, in subject order, and `selectOne` returns the first scoring the objective's `best` — and the report adds each evaluation the run made of the case's own calc as a value, with `[selected]` on the alternative returned and `[tied]` on a later one scoring the same; an evaluation that fails is listed with its error and leaves the objective `undecided`, a subject listing no alternative or redeclared `[1]` and bound to several is a `multiplicity violation` ([Trade studies](../guide/06-behavior.md#trade-studies)) |
 | `%record <name>[(<args>)] [<object>] [into <package>]` | Run an analysis case as `%analysis` does — the same verdict lines and the same bindings — and record the run into the model as `AnalysisRecords` elements: a record definition named for the case (`TimedRun` for `Demo::timed`) specializing `AnalysisRecords::AnalysisRun`, in a `Records` package beside the case's enclosing package or the one `into` names, and one part per run carrying a redefinition of each input bound and output produced, `caseName`, `kind`, `iteration`, a `ref` to the subject, `VerdictRecord`/`EvaluationRecord` parts for the verdicts and evaluations it made, and `@AnalysisRecords::RecordedRun` provenance metadata (`runAt`, `tool`, `command`, `kind`). The last line names what was recorded (`recorded Records::timed_run1 (Records::TimedRun)`); recording again of the same case numbers the part on (`timed_run2`), including after a `%save` and reload. The record submission is atomic: a run that fails, a record definition that does not specialize `AnalysisRecords::AnalysisRun`, a declared feature that collides with a reserved one, or a merge that would drop or produce diagnostics leaves the session's model untouched and reports the error. The records are ordinary elements — `%save` writes them with the model, and a `%run-query`/`%render-document` reads them by `WhereMetadata('metadata' = "AnalysisRecords::RecordedRun")`, `WhereFeature` and `Project`. Same recording as the CLI's [`-record-run`](cli.md#recording-analysis-runs); sweeps and Monte Carlo samples are recorded through `-record-run` with `-sweep`/`-runs`. See [Recording analysis runs](../manual/recording-analysis-runs.md) |
 | `%run-query <name> [<p>=<expr>...]` | Execute a document query (a `calc def` specializing `DocumentQueries::Query`) and print its rows and projected cells. A projection lists declared property names and may add computed columns using exactly one of `Column(name = "<column>", expression = <expr>)`, `Column(name = "<column>", cell = { in row : <Type>; ... })`, or `Column(name = "<column>", path = "<member.path>")`. Expressions run in query scope, cells receive each row as a typed parameter, and paths read dotted members from each row. A column expression that fails (including a reference that resolves to no value and has no `??` default) fails the query with a typed error rather than producing an empty cell. A `RelatedColumn(name, relationshipKind, direction, maxDepth, aggregate = "list")` entry derives a column from the elements `RelatedElements` reaches from each row — the elements themselves as a multi-valued cell (`[a, b]`, `(none)` when there are none), their `"count"` or `"any"` of them — and `WhereFeature`/`OrderBy` read it by name ([Traceability matrix](../manual/query-cookbook.md#traceability-matrix)). Each binding is written as `<parameter>=<expression>`; a name binds the object the session holds under it while it holds one (`car` after `%instantiate car`; `#2` and `car.wheels[2]` bind an object by id and by path), else the element it refers to, and anything else is evaluated as an expression. Over an object the operations read what the session holds: its parts as `OwnedElements`/`Descendants`, the values it holds now as its properties, and `Objects(type = "<type>")` enumerates every object held that is of the type ([Objects the session holds](../manual/query-cookbook.md#objects-the-session-holds)). `Verdicts(source = <rows>)` checks the object behind each row as `%validate` does — the held object, or the element's declared object — and answers one verdict row per assertion about it and the objects it holds, printed as `<assertion> on <path>: <verdict>`; `Project`, `WhereFeature` and `OrderBy` read its `path`, `kind`, `verdict`, `condition`, `reason` and `verification` beside the assertion's own properties ([Which constraints and requirements hold](../manual/query-cookbook.md#which-constraints-and-requirements-hold)). `States(source = <rows>)` answers the state each object's machine is in now, one row per active leaf (`<object>.<machine> in <statePath>`, with `machine`, `name`, `statePath`, `region` and `enclosing`), `InState(name = "<state>")` the held objects in that state, and `Events(source, kind, since, before)` the trace the session records — `%trace on` first, or the query is refused — as rows (`t=<instant> <object>.<machine>: <text>`, with `kind`, `time`, `state`, `from`, `to`, `target`, `event`, `payload`, `alternatives`, `taken`), `[since, before)` inclusive at the start and exclusive at the end ([Where the objects stand and what they did](../manual/query-cookbook.md#where-the-objects-stand-and-what-they-did)). A parameter left unbound takes its declared default (`in root : Element = telescope;`, `in pattern : String default "m";`) under the same rule: a name binds the element it refers to, anything else is evaluated once in the query that declared it, and a redefining parameter's default replaces the inherited one. Named query invocation and relationship traversal (`RelatedElements` over specialization, subsetting, redefinition, typing, connection, allocation, satisfaction and verification edges, outgoing or incoming) are supported. See the [query cookbook](../manual/query-cookbook.md) |
+| `%documents` | List the document definitions the session's model declares, one line per document, by the qualified names `%render-document` reads — every segment quoted that needs it and a line break in a name written as `\n` — in the text form `sysml -list documents` writes (see [Listing documents and views](cli.md#listing-documents-and-views)). Prints `(no documents)` when there are none |
+| `%views [diagrams] [<kind>...]` | List the views the session's model declares with the rendering kind each states, by the qualified names `%render` reads, in the text form `sysml -list views` writes; a view whose kind this build does not produce is listed with `(unsupported: <reason>)`. `diagrams` keeps the graph-shaped views (`tree`, `interconnection`, `state`, `action`, `case`, `mixed`, `sequence`, `requirement`, `definition` and `package`), and each kind named keeps the views of that kind; an unknown kind is refused with the kinds there are. Prints `(no views)` when none is left |
 | `%render-document <name> [mermaid\|dot\|plantuml\|d2 [pilot\|cameo]]` | Compile a document definition (a `part def` specializing `DocumentQueries::Document`), run its queries against the model — and against the objects the session holds, a parameter bound to a usage's name binding the object held under it while one is — and print the rendered Markdown. A document binds its queries' parameters in the model, so the name is the whole invocation apart from the optional diagram form: `mermaid`, `dot`, `plantuml` or `d2`, the form every graph-shaped diagram block of the document is written in — D2 writes `tree`, `interconnection`, `state`, `action`, `sequence`, `requirement`, `definition` and `package` renderings; case and mixed blocks are refused with a typed unrenderable-form error — omitted, a view some `DiagramLayout::Layout` or `Route` positions is `dot`, drawn by Graphviz where it states (inline SVG when `dot` is installed, Mermaid under a visible notice naming the missing tool when it is not), and every other graph-shaped view is `mermaid` — and after it the optional drawing style the `dot` and `mermaid` blocks are drawn in, `pilot` (the default) or `cameo`. The output is deterministic CommonMark: the title and sections as ATX headings; paragraphs from text runs (`Span` runs with a `plain`/`emphasis`/`strong`/`code` style, `Link` runs to a URL, `Ref` runs linking to another content block's anchor, and query-produced values styled through nested `SpanColumn`/`LinkColumn` column runs); GitHub-flavored pipe tables with the projected column names (one subtable per group value when the table has a `groupBy` column); bullet and numbered lists; diagram blocks as fenced ` ```mermaid ` blocks rendered through the view engine (` ```dot ` blocks of Graphviz DOT with the `dot` form, ` ```plantuml ` blocks with `plantuml`, ` ```d2 ` blocks with `d2`; a table or matrix view as a pipe table whichever form), with an optional caption and `TB`/`LR`/`BT`/`RL` flow direction. Markdown metacharacters in content are escaped. Markdown is the only form the REPL writes; the CLI's `-doc-form html` renders the same document tree as semantic HTML ([Rendering a document as HTML](cli.md#rendering-a-document-as-html)) and `-doc-form pdf` converts the Markdown to PDF ([Rendering a document as PDF](cli.md#rendering-a-document-as-pdf)). See the [document generation manual](../manual/README.md) |
 | `%sweep <name>[(<args>)] [<object>] <parameter>=<from>..<to>[:<step>] ...` | Run an analysis case or a calc once per value of a range and print the runs as a table: one row per run, carrying the values bound for it, the run's `out`/`return` values, the verdict of its `objective` where it has one, and the wall time of that run. The invocation is written as `%analysis`/`%calc` writes it — arguments in parentheses, an [object reference](#object-references) after them as the case's `subject` — and each range that follows names a parameter the case declares and the arguments do not bind. Endpoints and step are expressions evaluated at the prompt, units included (`speed=0.0 [SI::'m/s']..10.0 [SI::'m/s']:2.0 [SI::'m/s']`), converted to the unit `<from>` carries; `<to>` is included where the step lands on it. The values are produced in the parameter's declared type, not the literals' — a `Real` or `Rational` parameter swept over `1..4:1` is bound to `1.0`, `2.0`, `3.0`, `4.0` and shown so; an `Integer`, `Natural` or `Positive` parameter swept over `1.0..3.0:1.0` to `1`, `2`, `3`, and an endpoint or step of it that is no Integer, or below what a `Natural` or `Positive` holds, is refused naming the parameter and its type before any run; an `attribute def` specializing a scalar takes that scalar's values; a quantity-typed parameter is typed through its `num` (`Number` in the library, so its magnitudes are read as written; `Integer` where a model redefines it so, a `Natural` or `Positive` one refusing a magnitude below what it holds and one holding no number refusing the range) and takes the unit `<from>` carries; a `Number`-typed parameter and one declaring no type take the range as written — Integers between Integer literals, reals otherwise — and an untyped one is noted under the table; a `Boolean`, `String`, enumeration or non-scalar parameter refuses a range naming its type. A range between whole numbers with no `:<step>` steps by one, up or down as its endpoints direct; a range with a fractional endpoint and no step is refused. A range read as reals takes an Integer endpoint or step only where a Real holds it without rounding, and steps only where the reals tell its rows apart, so a range whose rows would repeat one value is refused rather than run. Several ranges run their cartesian product, the first written varying slowest, and rows come out in that order. A run that fails is a row numbering its typed error, printed in full under the table, rather than an abort of the table. A parameter whose name needs the quotes of an unrestricted name is swept under that name, quotes included (`'launch mass'=1..3`). A step of zero, a step whose sign never reaches `<to>`, an endpoint that is no number or is not finite, incompatible units, an undeclared parameter, the case's subject, one the arguments already bind — by name or by holding the position it is bound from — and a plan asking for more runs than `OPENSYSML_MAX_SWEEP_RUNS` allows are errors naming what was asked for. A trade study's rows carry an `evaluations` column, each run's evaluations of its alternatives with the one selected marked, a failed row keeping the ones it made. Each row is a run in a context of its own — the subject and the `self` of a nested case instantiated there, the arguments evaluated once at the prompt (a held feature a run wrote reads as written) and their values carried in, an argument naming a held object bound to the object the row makes for it — so no row sees another's writes; rows run `%jobs` at a time, and the table is in range order whatever order they finish in, the `time` column alone varying with the count. A sweep on an object the session holds runs each row on an object of its own that is the held object as the sweep found it, and leaves the held object as it was: a fresh object of the held object's declaration (one reached through a feature of another, `fleet.flagship`, on the like of `fleet` walked to its `flagship`) while the object is as the declaration made it, the behaviors its type exhibits or performs still as their start left them — as one fresh from `%instantiate` is; otherwise — named by `#<id>`, a feature of it written by a run, a signal sent to it, its state machine moved or its performed action past a wait — a copy from one image of the held object and what it holds, taken as the sweep begins and made in each row's context under the same identities, executors and posted signals included. One destroyed, or in a state no copy carries (a body paused mid-statement, a debugger inside a step), is refused naming the reason, never swept on shared state; an argument naming a held object binds the row's copy of it, and is refused naming the argument when no copy can be made or its value is bound to the run that made it. Same tables as the CLI's [`-sweep`](cli.md#sweeping-a-parameter) |
 | `%samples <n> <seed> <name>[(<args>)] [<object>] <parameter>=<from>..<to> ...` | Draw `n` values for each range instead of running every value of it, uniformly over `[<from>, <to>]` for a parameter taking Integers and `[<from>, <to>)` for one taking reals — the parameter's type decides, so an `Integer` parameter sampled over `1.0..4.0` draws the Integers 1 to 4 and a `Real` parameter sampled over `1..4` draws reals in `[1, 4)` — and print the rows in draw order with the seed in the table header. The generator is `math/rand/v2`'s `PCG` seeded from `<seed>`, so the same seed draws the same values on every platform; a sampled range needs no step and stating one is refused. Sampling is uniform because the bundled standard library states no probability distribution — a range written as a named distribution (`n=normal(1.0, 0.2)`) is an error naming what is missing rather than an approximation |
@@ -115,7 +119,15 @@ into the parts it holds (`car.fl.hub`, `#3.fl`, `car.wheels[2]`).
 | `%advance <time>` | Advance the runtime's simulation clock by `<time>` seconds (`SI::s`), running every state event, action token, change-condition poll and do behavior that comes due, in due order. The clock is the session's, not one debugger's: an `%action` parked at `accept after` and a `%state` machine both move, and the report covers each. A state's do behavior whose action body waits (`do action poll { action wait accept after 3 [SI::s]; then … }`) is parked on the clock too, listed under `Waiting on the clock` and resumed when its instant comes; a transition that leaves the state first ends it, its wait leaving the clock. Two executors due at the same instant run in the order the scheduling policy picks — the one started last first under the default `reverse` — and the pick is a choice point, as is which of two regions' do behaviors due together acts first in a round ([Choice points](../guide/06-behavior.md)). Under `%engine check` there is no run to advance: `%advance` searches the behavior last checked again, up to that instant as its horizon |
 | **Control** | |
 | `%quit` | Exit the REPL |
-| `Tab` | Complete meta commands, symbol names (after `%print`, `%instantiate`, `%features` …; a name that needs quoting is offered in quotes, `Q::'the ra` completing to `Q::'the rack'`), object references where a command takes one (`#` offers the ids there are; `car.` offers the object-holding features of `car` — the same ones a path may pass through — a multi-valued one as `car.wheels[1]`, `car.wheels[2]` …; completing reads and materializes nothing, so a part no command has reached yet is offered by type, and only the elements reading it would hold: those the features subsetting it contribute, then anonymous ones up to its lower bound — so an optional part (`spare : Wheel[0..1]`) or an abstract one, which hold only what subsets them, is offered only once something does), the form after `%render <name>` and the palette after `%render <name> dot`, and file paths after `%load` and `%save` |
+
+**Repository** — the SysML v2 API server the session talks to ([Working with a repository](#working-with-a-repository)):
+
+| Command | Description |
+|---------|-------------|
+| `%repo [<base path>]` | Show or set the base URL of the SysML v2 API server the repository commands address, seeded from `FLEXO_SYSMLV2_URL` (default `http://localhost:8083`). A bearer token, when the server wants one, is read from `FLEXO_INTEROP_TOKEN`; it is never printed, and nothing is persisted. A plaintext `http://` URL off this machine is refused unless `FLEXO_ALLOW_PLAIN_HTTP=1`, whether `%repo` names it or `FLEXO_SYSMLV2_URL` does; and the token stays on the server it was given for: a redirect or a next-page link to another host, another port or plaintext is refused, not followed with the token |
+| `%projects` | List the repository's projects, `<name> (<id>)` one per line, every page of them; `no projects` for an empty repository |
+| `%publish [-d] [--project=<project name>] [--branch=<branch name>] <name>` | Publish the elements rooted in `<name>` — a qualified name resolved in the session — as SysML v2 API JSON: when no project is named after it (or after `--project`) a project is created and its first commit made, otherwise a commit on the branch `--branch` names, or the default branch, holding what differs from the branch head under that root — elements under other roots are left in place, and elements are deleted only from a branch the session loaded or published: the commit id and the counts of elements created, updated and deleted are reported, with what was left in place, `nothing to publish` when none differ. An option given twice is a usage error. `-d` sends every derived property the exporter computes; without it the ones the reader recomputes are left out. A project with the same name twice is refused naming both ids |
+| `Tab` | Complete meta commands, symbol names (after `%print`, `%instantiate`, `%features` …; a name that needs quoting is offered in quotes, `Q::'the ra` completing to `Q::'the rack'`), object references where a command takes one (`#` offers the ids there are; `car.` offers the object-holding features of `car` — the same ones a path may pass through — a multi-valued one as `car.wheels[1]`, `car.wheels[2]` …; completing reads and materializes nothing, so a part no command has reached yet is offered by type, and only the elements reading it would hold: those the features subsetting it contribute, then anonymous ones up to its lower bound — so an optional part (`spare : Wheel[0..1]`) or an abstract one, which hold only what subsets them, is offered only once something does), the form after `%render <name>` and the palette after `%render <name> dot`, file paths after `%load` and `%save`, and the flags of `%load` and `%publish` with the repository's project names after `--name=`, `--id=` and `--project=` and after `%load` |
 | `Ctrl-C` | Discard the line being typed, and any continuation buffered before it; at an empty `sysml>` prompt, exit REPL |
 | `Ctrl-D` | Exit REPL |
 
@@ -622,3 +634,28 @@ pins no positions either, so `DiagramLayout` geometry rides along as `#` comment
 ([the D2 form](../project/view-rendering-forms.md#d2)).
 
 To render a view outside the prompt, use [`sysml -render`](cli.md#rendering-a-view).
+
+## Working with a repository
+
+`%repo`, `%projects`, `%load` and `%publish` address a SysML v2 API server — the OMG pilot's
+`SysML-v2-API-Services` or Flexo MMS — through the standard `/projects`, `/branches`, `/commits`
+and `/elements` resources, as the CLI's [`-sync`](cli.md#reading-and-pushing-a-repository-branch)
+does. The server is `FLEXO_SYSMLV2_URL` until `%repo <url>` sets another for the session; a
+bearer token comes from `FLEXO_INTEROP_TOKEN` and is never shown, and Flexo's organization from
+`FLEXO_SYSMLV2_ORG` where a server has one. Nothing is written to disk.
+
+```text
+sysml> %repo http://localhost:9000
+API base path: http://localhost:9000
+sysml> %projects
+Vehicles (9c0e2b3a-…)
+sysml> %load Vehicles
+loaded project Vehicles (9c0e2b3a-…) at branch main (5d1f…), commit 7a2c…: 13 elements
+sysml> part def Truck :> Vehicles::Car;
+sysml> %publish --project=Vehicles Truck
+commit 0b4e… on branch main (5d1f…) of Vehicles (9c0e2b3a-…): 3 created, 0 updated, 0 deleted
+```
+
+A server that cannot be reached, a project or branch that does not exist, and a commit the server
+refuses are reported with the status and the server's message; a syntax or argument problem with
+the command's usage.
diff --git a/docs/reference/sysml-v1-migration.md b/docs/reference/sysml-v1-migration.md
index 917ee958c3..1ac8bd2cc1 100644
--- a/docs/reference/sysml-v1-migration.md
+++ b/docs/reference/sysml-v1-migration.md
@@ -174,7 +174,7 @@ ties each of its mapping classes to the code that carries it out (or records why
 | Property or port sharing the name of an inherited feature without redefining it | `:>>` the inherited feature when both are the same kind of usage; otherwise the collision is reported and left | approximated |
 | Connector, nested ends | `connect a.b to c.d` | mapped |
 | «BindingConnector» | `bind`, or `binding name bind` when named | mapped |
-| InformationFlow / «ItemFlow» over a connector | `flow of Item from a.x to b.y` | mapped |
+| InformationFlow / «ItemFlow» over a connector | `flow of Item from a.x to b.y`, from the end standing for the flow's source to the one standing for its target: the end whose role it is, whose path names it or a part typed by it (a flow a tool draws between parts or blocks), or the connector's own port when it is the connector's owner | mapped |
 | «Satisfy» | `satisfy requirement … by …` in the satisfying usage's owner | mapped |
 | «Verify» from a test case | `verify` in the verification def | mapped |
 | «DeriveReqt» | `connection … :> RequirementDerivation::Derivation` | mapped |
diff --git a/editors/README.md b/editors/README.md
index c969f212d6..01665df8a0 100644
--- a/editors/README.md
+++ b/editors/README.md
@@ -6,6 +6,14 @@ directory here with its own build.
 - **[VS Code](vscode/)** — the extension that runs `sysml-lsp` as its language server and hosts
   the diagram panel; see [`docs/guide/08-editors.md`](../docs/guide/08-editors.md) for what a user sees.
 
+- **[JupyterLab](jupyterlab/)** — `jupyterlab-opensysml`, a prebuilt JupyterLab 4 / Notebook 7
+  extension that registers the `sysml` and `kerml` CodeMirror languages, so the cells of a
+  notebook on the `sysml` kernel, `.sysml`/`.kerml` files and Markdown fences are highlighted.
+  Its keyword tables are generated from the lexer by the same tool as the VS Code grammars
+  (`make vscode-grammar`), and the kernel's pip package
+  ([`client/jupyter-kernel`](../client/jupyter-kernel)) ships the build in every wheel and the
+  sdist (`make jupyterlab-build`); see [`docs/guide/12-jupyter.md`](../docs/guide/12-jupyter.md).
+
 <!-- mdk: begin -->
 - **[OpenSysML MDK](mdk/)** — a plugin for Cameo Systems Modeler 2026x Refresh1 (2024x
   Refresh3 as the minimum), positioned as the successor to OpenMBEE's Model Development Kit
@@ -33,9 +41,9 @@ directory here with its own build.
 
 ## Versions
 
-The editors carry the core version — `0.9.2` now — the same lockstep the clients
+The editors carry the core version — `0.10.0` now — the same lockstep the clients
 follow, even though nothing publishes them. `check_version.py --editors` checks
-every manifest (the two package.json files and their locks, the Cameo and SysON
+every manifest (the three package.json files and their locks, the Cameo and SysON
 poms and their children's `<parent><version>`), and a release fails early when
 one disagrees. The client references the editors build against —
 `opensysml.client.version` in the Cameo pom and the `opensysml`
diff --git a/editors/jupyterlab/.gitignore b/editors/jupyterlab/.gitignore
new file mode 100644
index 0000000000..7e0d4405ed
--- /dev/null
+++ b/editors/jupyterlab/.gitignore
@@ -0,0 +1,4 @@
+node_modules/
+lib/
+out/
+*.tsbuildinfo
diff --git a/editors/jupyterlab/LICENSE b/editors/jupyterlab/LICENSE
new file mode 100644
index 0000000000..7739fc18de
--- /dev/null
+++ b/editors/jupyterlab/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2026 Open-MBEE
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/editors/jupyterlab/README.md b/editors/jupyterlab/README.md
new file mode 100644
index 0000000000..b86ba03864
--- /dev/null
+++ b/editors/jupyterlab/README.md
@@ -0,0 +1,65 @@
+# SysML v2 for JupyterLab (OpenSysML)
+
+`jupyterlab-opensysml` is a prebuilt (federated) JupyterLab 4 / Notebook 7 extension that
+highlights SysML v2 and KerML. It registers two CodeMirror 6 languages with JupyterLab's
+editor language registry — `sysml` (`text/x-sysml`, `.sysml`) and `kerml` (`text/x-kerml`,
+`.kerml`) — so the cells of a notebook on the `sysml` kernel, `.sysml` and `.kerml` files
+opened in the editor, and Markdown code fences tagged `sysml` or `kerml` are highlighted.
+
+It is not published to npm. The kernel's pip package,
+[`jupyter-opensysml-kernel`](../../client/jupyter-kernel), ships the build in every wheel
+and the sdist as shared data under `share/jupyter/labextensions/jupyterlab-opensysml`, so
+`pip install jupyter-opensysml-kernel` is the whole install: no Node.js, no
+`jupyter labextension install`.
+
+## What it highlights
+
+A `StreamLanguage` tokenizer (`src/sysml.ts`) marks reserved keywords, the words that are
+keywords only in context (`chain`, `deep`, `done`, `history`, `junction`, `shallow`, and
+`var` in KerML), the literals `true`, `false` and `null`, `//` and `/* */` comments, the
+bodies of `doc` and `comment` as documentation, strings with their escapes, numbers,
+`'unrestricted names'`, the `A::B` of qualified names, operators and punctuation, and a
+cell's first token when it is a kernel command (`%help`, `%run`, …).
+
+The keyword and operator tables are `src/syntax.json`, generated from the lexer's keyword
+list (`internal/syntax/source.Keywords()`, `lexer.ContextualWords()`) by
+`editors/vscode/tools/gengrammar`, the tool that generates the VS Code grammars:
+
+```bash
+make vscode-grammar    # regenerates the TextMate grammars and src/syntax.json
+```
+
+`go test ./editors/vscode/tools/gengrammar/` fails when the committed table is stale, so the
+highlighting cannot drift from the language. Do not edit `src/syntax.json` by hand.
+
+## Build and test
+
+Node.js 22 and the `jupyterlab` Python package (for `jupyter labextension build`) are needed;
+end users need neither.
+
+```bash
+make jupyterlab-test     # the tokenizer tests over sample snippets (test/sysml.test.ts)
+make jupyterlab-build    # client/jupyter-kernel/labextension/, which the pip package ships
+```
+
+The build output is not committed. `scripts/build-jupyter-kernel-dist.sh` runs
+`make jupyterlab-build` before it builds the sdist and the platform wheels and checks that
+all six carry the same bundle; `python -m build` in `client/jupyter-kernel` refuses to build
+a distribution without it.
+
+## Development install
+
+`make jupyter-kernel-install` installs the kernel package in editable mode; it does not
+build the extension. To see the highlighting in a development environment, build it and let
+JupyterLab link the build in place, so a rebuild is picked up on reload:
+
+```bash
+make jupyter-kernel-install
+make jupyterlab-install        # make jupyterlab-build + jupyter labextension develop --overwrite
+jupyter labextension list      # jupyterlab-opensysml ... enabled OK
+```
+
+`jupyter labextension develop` symlinks `client/jupyter-kernel/labextension/` into the
+environment's `share/jupyter/labextensions/`, which `_jupyter_labextension_paths()` in the
+package points it at. Alternatively, `make jupyterlab-build` followed by `pip install
+client/jupyter-kernel` (not editable) installs the build as shared data, as a wheel does.
diff --git a/editors/jupyterlab/install.json b/editors/jupyterlab/install.json
new file mode 100644
index 0000000000..7bce6fb4c8
--- /dev/null
+++ b/editors/jupyterlab/install.json
@@ -0,0 +1,5 @@
+{
+  "packageManager": "python",
+  "packageName": "jupyter-opensysml-kernel",
+  "uninstallInstructions": "Use your Python package manager (pip, conda, etc.) to uninstall the package jupyter-opensysml-kernel"
+}
diff --git a/editors/jupyterlab/package-lock.json b/editors/jupyterlab/package-lock.json
new file mode 100644
index 0000000000..6c3ac75811
--- /dev/null
+++ b/editors/jupyterlab/package-lock.json
@@ -0,0 +1,3597 @@
+{
+  "name": "jupyterlab-opensysml",
+  "version": "0.10.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "jupyterlab-opensysml",
+      "version": "0.10.0",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@jupyterlab/application": "^4.0.0",
+        "@jupyterlab/codemirror": "^4.0.0"
+      },
+      "devDependencies": {
+        "@jupyter/builder": "^1.2.3",
+        "@jupyterlab/core-meta": "~4.6.4",
+        "@types/node": "^22.0.0",
+        "rimraf": "^6.0.0",
+        "typescript": "~5.7.3"
+      }
+    },
+    "node_modules/@codemirror/autocomplete": {
+      "version": "6.20.3",
+      "resolved": "https://registry.npmjs.org/@codemirror/autocomplete/-/autocomplete-6.20.3.tgz",
+      "integrity": "sha512-tlosUqb+3BbxCxZdu4tKeRghPFC+QM7q4X5YhKV2eCmPG+1r2F3f4AaSz5sCrFqUtX4Jh20VFTKecl16MgiV9g==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/commands": {
+      "version": "6.11.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/commands/-/commands-6.11.1.tgz",
+      "integrity": "sha512-O/4hG3SC1YwcmQ0d2UVNDs+AsaNWd1iHVxbTeEBuqH+6bExAiPK3iS/BvpY6rZGURALv4ZD3sIgcCmRvw3ehBg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.7.0",
+        "@codemirror/view": "^6.27.0",
+        "@lezer/common": "^1.1.0"
+      }
+    },
+    "node_modules/@codemirror/lang-cpp": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-cpp/-/lang-cpp-6.0.3.tgz",
+      "integrity": "sha512-URM26M3vunFFn9/sm6rzqrBzDgfWuDixp85uTY49wKudToc2jTHUrKIGGKs+QWND+YLofNNZpxcNGRynFJfvgA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/cpp": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-css": {
+      "version": "6.3.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-css/-/lang-css-6.3.1.tgz",
+      "integrity": "sha512-kr5fwBGiGtmz6l0LSJIbno9QrifNMUusivHbnA1H6Dmqy4HZFte3UAICix1VuKo0lMPKQr2rqB+0BkKi/S3Ejg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.0.2",
+        "@lezer/css": "^1.1.7"
+      }
+    },
+    "node_modules/@codemirror/lang-html": {
+      "version": "6.4.12",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-html/-/lang-html-6.4.12.tgz",
+      "integrity": "sha512-pw2ReWKUqSkbvh76RAT4NYxiogRu+PWkR2ukAwO9uOgrm8uipkzjtKKtNpyeAQwHOqxEeSvAXZ6vr3AfyB9y/w==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/lang-css": "^6.0.0",
+        "@codemirror/lang-javascript": "^6.0.0",
+        "@codemirror/language": "^6.4.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/css": "^1.1.0",
+        "@lezer/html": "^1.3.12"
+      }
+    },
+    "node_modules/@codemirror/lang-java": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-java/-/lang-java-6.0.2.tgz",
+      "integrity": "sha512-m5Nt1mQ/cznJY7tMfQTJchmrjdjQ71IDs+55d1GAa8DGaB8JXWsVCkVT284C3RTASaY43YknrK2X3hPO/J3MOQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/java": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-javascript": {
+      "version": "6.2.5",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-javascript/-/lang-javascript-6.2.5.tgz",
+      "integrity": "sha512-zD4e5mS+50htS7F+TYjBPsiIFGanfVqg4HyUz6WNFikgOPf2BgKlx+TQedI1w6n/IqRBVBbBWmGFdLB/7uxO4A==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.6.0",
+        "@codemirror/lint": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.17.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/javascript": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-json": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-json/-/lang-json-6.0.2.tgz",
+      "integrity": "sha512-x2OtO+AvwEHrEwR0FyyPtfDUiloG3rnVTSZV1W8UteaLL8/MajQd8DpvUb2YVzC+/T18aSDv0H9mu+xw0EStoQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/json": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-markdown": {
+      "version": "6.5.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-markdown/-/lang-markdown-6.5.2.tgz",
+      "integrity": "sha512-AwBOdkWYuA//WcM0xO5PfHPUcmz/O2i5o0Nsg1U69SII/loCJlFI1Romd9xp2HYb1kYJRGZotyqRghuHH5n8Kw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.7.1",
+        "@codemirror/lang-html": "^6.0.0",
+        "@codemirror/language": "^6.3.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0",
+        "@lezer/common": "^1.2.1",
+        "@lezer/markdown": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-php": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-php/-/lang-php-6.0.2.tgz",
+      "integrity": "sha512-ZKy2v1n8Fc8oEXj0Th0PUMXzQJ0AIR6TaZU+PbDHExFwdu+guzOA4jmCHS1Nz4vbFezwD7LyBdDnddSJeScMCA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/lang-html": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/php": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-python": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-python/-/lang-python-6.2.1.tgz",
+      "integrity": "sha512-IRjC8RUBhn9mGR9ywecNhB51yePWCGgvHfY1lWN/Mrp3cKuHr0isDKia+9HnvhiWNnMpbGhWrkhuWOc09exRyw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.3.2",
+        "@codemirror/language": "^6.8.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.2.1",
+        "@lezer/python": "^1.1.4"
+      }
+    },
+    "node_modules/@codemirror/lang-rust": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-rust/-/lang-rust-6.0.2.tgz",
+      "integrity": "sha512-EZaGjCUegtiU7kSMvOfEZpaCReowEf3yNidYu7+vfuGTm9ow4mthAparY5hisJqOHmJowVH3Upu+eJlUji6qqA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/rust": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-sql": {
+      "version": "6.10.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-sql/-/lang-sql-6.10.0.tgz",
+      "integrity": "sha512-6ayPkEd/yRw0XKBx5uAiToSgGECo/GY2NoJIHXIIQh1EVwLuKoU8BP/qK0qH5NLXAbtJRLuT73hx7P9X34iO4w==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.0.0",
+        "@codemirror/state": "^6.0.0",
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-wast": {
+      "version": "6.0.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-wast/-/lang-wast-6.0.2.tgz",
+      "integrity": "sha512-Imi2KTpVGm7TKuUkqyJ5NRmeFWF7aMpNiwHnLQe0x9kmrxElndyH0K6H/gXtWwY6UshMRAhpENsgfpSwsgmC6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/language": "^6.0.0",
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/lang-xml": {
+      "version": "6.1.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/lang-xml/-/lang-xml-6.1.0.tgz",
+      "integrity": "sha512-3z0blhicHLfwi2UgkZYRPioSgVTo9PV5GP5ducFH6FaHy0IAJRg+ixj5gTR1gnT/glAIC8xv4w2VL1LoZfs+Jg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.0.0",
+        "@codemirror/language": "^6.4.0",
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.0.0",
+        "@lezer/common": "^1.0.0",
+        "@lezer/xml": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/language": {
+      "version": "6.13.1",
+      "resolved": "https://registry.npmjs.org/@codemirror/language/-/language-6.13.1.tgz",
+      "integrity": "sha512-zfvU2r3TyylQLMj/te+5CnQ0rSqZi8B1oTCBbQkagcLW4Xc6imab6qN+pEJhsuNOLaJqiRyBXp9UhWA1DhVvDw==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/streamparser": "^6.0.0",
+        "@codemirror/view": "^6.23.0",
+        "@lezer/common": "^1.5.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0",
+        "style-mod": "^4.0.0"
+      }
+    },
+    "node_modules/@codemirror/legacy-modes": {
+      "version": "6.5.5",
+      "resolved": "https://registry.npmjs.org/@codemirror/legacy-modes/-/legacy-modes-6.5.5.tgz",
+      "integrity": "sha512-9ltT214oMb3Y1w5eAZMSigzrjzZnMI2Wa3Feq73rU/i4C56MkwrpfswfQYOr28C5pXr6dWwspNTMyeHXlzWMxg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/streamparser": "^6.0.0"
+      }
+    },
+    "node_modules/@codemirror/lint": {
+      "version": "6.9.7",
+      "resolved": "https://registry.npmjs.org/@codemirror/lint/-/lint-6.9.7.tgz",
+      "integrity": "sha512-28/+iWLYxKxsvGYhSYL7zaCZqLz5+FFFDq9tVsvGv9kv8RY4fFAchJ5WX9M3YrrRlTIsECjsXPqeNgnSmNP2dg==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.42.0",
+        "crelt": "^1.0.5"
+      }
+    },
+    "node_modules/@codemirror/search": {
+      "version": "6.7.2",
+      "resolved": "https://registry.npmjs.org/@codemirror/search/-/search-6.7.2.tgz",
+      "integrity": "sha512-gUYkYhT2+n/+VGZ+8EzE5WFkYZUZYm1VOKDudIsNqh42uRVQJ0a6Yss9sdKT3MeOYfuL1N6AZA57oza0Oyr0LA==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.0.0",
+        "@codemirror/view": "^6.37.0",
+        "crelt": "^1.0.5"
+      }
+    },
+    "node_modules/@codemirror/state": {
+      "version": "6.7.6",
+      "resolved": "https://registry.npmjs.org/@codemirror/state/-/state-6.7.6.tgz",
+      "integrity": "sha512-kAz+AncRtKuIknedxT1bq4XwXv4UowhbkHU1myPrtVb/jZtImWuV5BXzv5vK6i3kYACsdiZiQKFQQ5Mq7elW8w==",
+      "license": "MIT",
+      "dependencies": {
+        "@marijn/find-cluster-break": "^1.0.0"
+      }
+    },
+    "node_modules/@codemirror/streamparser": {
+      "version": "6.0.0",
+      "resolved": "https://registry.npmjs.org/@codemirror/streamparser/-/streamparser-6.0.0.tgz",
+      "integrity": "sha512-JTFPF6xrfjt0mnfGPgzcLiMwYmvIyNaoizp8BYzv8FE8KrT6GBGDZ190rtt+O7Wke3gG/MFHyiY9YGNeimof4w==",
+      "license": "MIT"
+    },
+    "node_modules/@codemirror/view": {
+      "version": "6.43.14",
+      "resolved": "https://registry.npmjs.org/@codemirror/view/-/view-6.43.14.tgz",
+      "integrity": "sha512-hC45YnmJNR1rz42OF57BLoQNFMV12/13drnvibDsR2quNDmldcb4WvYVV81hFQg56i9lcqQMEDqilhX2QDcGQQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@codemirror/state": "^6.7.0",
+        "crelt": "^1.0.6",
+        "style-mod": "^4.1.0",
+        "w3c-keyname": "^2.2.4"
+      }
+    },
+    "node_modules/@emnapi/core": {
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/core/-/core-1.11.3.tgz",
+      "integrity": "sha512-zLpS5asjEb7lq8jYLq37N6XKaE41DIexlY1rF/z4/tIl3wo13Sqm28fRyfIsKZD+NZ8mM5RoKkpW/rBcuoSZSg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/wasi-threads": "1.2.3",
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/core/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/runtime/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@emnapi/wasi-threads": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/wasi-threads/-/wasi-threads-1.2.3.tgz",
+      "integrity": "sha512-ELEBe8PsLvvJ6QMr0zLt8ffvOHW/dc1m3CEzNMg7aJUv3bMaoDtw2TXyDAwkYBuroxxuHEwhRTLJSe5sya547g==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@emnapi/wasi-threads/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@fortawesome/fontawesome-free": {
+      "version": "5.15.4",
+      "resolved": "https://registry.npmjs.org/@fortawesome/fontawesome-free/-/fontawesome-free-5.15.4.tgz",
+      "integrity": "sha512-eYm8vijH/hpzr/6/1CJ/V/Eb1xQFW2nnUKArb3z+yUWv7HTwj6M7SP957oMjfZjAHU6qpoNc2wQvIxBLWYa/Jg==",
+      "hasInstallScript": true,
+      "license": "(CC-BY-4.0 AND OFL-1.1 AND MIT)",
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/@jridgewell/gen-mapping": {
+      "version": "0.3.13",
+      "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",
+      "integrity": "sha512-2kkt/7niJ6MgEPxF0bYdQ6etZaA+fQvDcLKckhy1yIQOzaoKjBBjSj63/aLVjYE3qhRt5dvM+uUyfCg6UKCBbA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/sourcemap-codec": "^1.5.0",
+        "@jridgewell/trace-mapping": "^0.3.24"
+      }
+    },
+    "node_modules/@jridgewell/resolve-uri": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/@jridgewell/resolve-uri/-/resolve-uri-3.1.2.tgz",
+      "integrity": "sha512-bRISgCIjP20/tbWSPWMEi54QVPRZExkuD9lJL+UIxUKtwVJA8wW1Trb1jMs1RFXo1CBTNZ/5hpC9QvmKWdopKw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/@jridgewell/source-map": {
+      "version": "0.3.11",
+      "resolved": "https://registry.npmjs.org/@jridgewell/source-map/-/source-map-0.3.11.tgz",
+      "integrity": "sha512-ZMp1V8ZFcPG5dIWnQLr3NSI1MiCU7UETdS/A0G8V/XWHvJv3ZsFqutJn1Y5RPmAPX6F3BiE397OqveU/9NCuIA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/gen-mapping": "^0.3.5",
+        "@jridgewell/trace-mapping": "^0.3.25"
+      }
+    },
+    "node_modules/@jridgewell/sourcemap-codec": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/@jridgewell/sourcemap-codec/-/sourcemap-codec-1.6.0.tgz",
+      "integrity": "sha512-T7jf+5zgsZHwNJ4lvQ7/aezbyk0nNX+zJVWpmHA7VYsEx7a7qr5Rg5IbtJFqkgze5Y2sruq1RUY8Q837Od7iFw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@jridgewell/trace-mapping": {
+      "version": "0.3.31",
+      "resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.31.tgz",
+      "integrity": "sha512-zzNR+SdQSDJzc8joaeP8QQoCQr8NuYx2dIIytl1QeBEZHJ9uW6hebsrYgbz8hJwUQao3TWCMtmfV8Nu1twOLAw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/resolve-uri": "^3.1.0",
+        "@jridgewell/sourcemap-codec": "^1.4.14"
+      }
+    },
+    "node_modules/@jupyter/builder": {
+      "version": "1.2.3",
+      "resolved": "https://registry.npmjs.org/@jupyter/builder/-/builder-1.2.3.tgz",
+      "integrity": "sha512-QnST5NZPmYHT7IMfLu1TxQobkxgNbDWULuDQcWRJObxLn6yyZ76hSXkNqlQh7GNLq3MNx3IG54a985ExTwLRDw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/core-meta": "^4.6.1",
+        "@module-federation/runtime-tools": "^2.0.0",
+        "@rspack/core": "^2.1.7",
+        "ajv": "^8.12.0",
+        "commander": "^9.4.1",
+        "css-loader": "^7.1.4",
+        "duplicate-package-checker-webpack-plugin": "^3.0.0",
+        "fs-extra": "^10.1.0",
+        "glob": "^13.0.6",
+        "license-webpack-plugin": "^4.0.2",
+        "mini-svg-data-uri": "^1.4.4",
+        "path-browserify": "^1.0.0",
+        "process": "^0.11.10",
+        "style-loader": "^4.0.0",
+        "supports-color": "^7.2.0",
+        "webpack-merge": "^5.8.0"
+      }
+    },
+    "node_modules/@jupyter/react-components": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@jupyter/react-components/-/react-components-0.16.7.tgz",
+      "integrity": "sha512-BKIPkJ9V011uhtdq1xBOu2M3up59CqsRbDS4aq8XhnHR4pwqfRV6k6irE5YBOETCoIwWZZ5RZO+cJcZ3DcsT5A==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyter/web-components": "^0.16.7",
+        "react": ">=17.0.0 <19.0.0"
+      }
+    },
+    "node_modules/@jupyter/web-components": {
+      "version": "0.16.7",
+      "resolved": "https://registry.npmjs.org/@jupyter/web-components/-/web-components-0.16.7.tgz",
+      "integrity": "sha512-1a8awgvvP9J9pCV5vBRuQxdBk29764qiMJsJYEndrWH3cB/FlaO+sZIBm4OTf56Eqdgl8R3/ZSLM1+3mgXOkPg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@microsoft/fast-colors": "^5.3.1",
+        "@microsoft/fast-element": "^1.12.0",
+        "@microsoft/fast-foundation": "^2.49.4",
+        "@microsoft/fast-web-utilities": "^5.4.1"
+      }
+    },
+    "node_modules/@jupyter/ydoc": {
+      "version": "3.5.0",
+      "resolved": "https://registry.npmjs.org/@jupyter/ydoc/-/ydoc-3.5.0.tgz",
+      "integrity": "sha512-kY/p4vP4tB606AxoEUZDBDKjKLVTF2q6AJE0bMHA5l2lL0SxrjufjkXCK/EEI/vUCOpHRakysNS8644tVAvhDg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/nbformat": "^3.0.0 || ^4.0.0-alpha.21 || ^4.0.0",
+        "@lumino/coreutils": "^1.11.0 || ^2.0.0",
+        "@lumino/disposable": "^1.10.0 || ^2.0.0",
+        "@lumino/signaling": "^1.10.0 || ^2.0.0",
+        "y-protocols": "^1.0.5",
+        "yjs": "^13.5.40"
+      }
+    },
+    "node_modules/@jupyterlab/application": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/application/-/application-4.5.11.tgz",
+      "integrity": "sha512-iG75TqzP1Wvfc5v6aLi2e5NoIkgejjcXNlp73o9B7zSIjgFUg6KkoXSHAMtU9RMhsxHjBLp4O8HxL5ruP+TuoA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@fortawesome/fontawesome-free": "^5.12.0",
+        "@jupyterlab/apputils": "^4.6.11",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/docregistry": "^4.5.11",
+        "@jupyterlab/rendermime": "^4.5.11",
+        "@jupyterlab/rendermime-interfaces": "^3.13.11",
+        "@jupyterlab/services": "^7.5.11",
+        "@jupyterlab/statedb": "^4.5.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@jupyterlab/ui-components": "^4.5.11",
+        "@lumino/algorithm": "^2.0.4",
+        "@lumino/application": "^2.4.8",
+        "@lumino/commands": "^2.3.3",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/polling": "^2.1.5",
+        "@lumino/properties": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/widgets": "^2.7.5"
+      }
+    },
+    "node_modules/@jupyterlab/apputils": {
+      "version": "4.6.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/apputils/-/apputils-4.6.11.tgz",
+      "integrity": "sha512-zNAoOz8uTwdx4ddslDVwknTEQ1XZJCjGNioY9/vReZ1KmyOCmXblMVxc7BrZBoXkRiLbzXTDqSoLO6ALG2R6XQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/observables": "^5.5.11",
+        "@jupyterlab/rendermime-interfaces": "^3.13.11",
+        "@jupyterlab/services": "^7.5.11",
+        "@jupyterlab/settingregistry": "^4.5.11",
+        "@jupyterlab/statedb": "^4.5.11",
+        "@jupyterlab/statusbar": "^4.5.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@jupyterlab/ui-components": "^4.5.11",
+        "@lumino/algorithm": "^2.0.4",
+        "@lumino/commands": "^2.3.3",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/domutils": "^2.0.4",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/virtualdom": "^2.0.4",
+        "@lumino/widgets": "^2.7.5",
+        "@types/react": "^18.0.26",
+        "react": "^18.2.0",
+        "sanitize-html": "~2.12.1"
+      }
+    },
+    "node_modules/@jupyterlab/codeeditor": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/codeeditor/-/codeeditor-4.5.11.tgz",
+      "integrity": "sha512-rZre2Y1KM6xPX9gNmbN/F8DJ2hrmZBWYJxkmqz/xBQQHCQ7M0JXgZEb37iqEOK/S4RNTRWS9r2vIMJk3+KulUA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@codemirror/state": "^6.5.4",
+        "@jupyter/ydoc": "^3.1.0",
+        "@jupyterlab/apputils": "^4.6.11",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/nbformat": "^4.5.11",
+        "@jupyterlab/observables": "^5.5.11",
+        "@jupyterlab/statusbar": "^4.5.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@jupyterlab/ui-components": "^4.5.11",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/dragdrop": "^2.1.8",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/widgets": "^2.7.5",
+        "react": "^18.2.0"
+      }
+    },
+    "node_modules/@jupyterlab/codemirror": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/codemirror/-/codemirror-4.5.11.tgz",
+      "integrity": "sha512-H/OheT4rqkkuAjSVw9owN7o3SuklO/J0fu76d7XArGj+Rw2jtrAbY7Q2vWbDI5OyOS8oWwDdgcjmXOM8znRixA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@codemirror/autocomplete": "^6.20.0",
+        "@codemirror/commands": "^6.10.2",
+        "@codemirror/lang-cpp": "^6.0.3",
+        "@codemirror/lang-css": "^6.3.1",
+        "@codemirror/lang-html": "^6.4.11",
+        "@codemirror/lang-java": "^6.0.2",
+        "@codemirror/lang-javascript": "^6.2.4",
+        "@codemirror/lang-json": "^6.0.2",
+        "@codemirror/lang-markdown": "^6.5.0",
+        "@codemirror/lang-php": "^6.0.2",
+        "@codemirror/lang-python": "^6.2.1",
+        "@codemirror/lang-rust": "^6.0.2",
+        "@codemirror/lang-sql": "^6.10.0",
+        "@codemirror/lang-wast": "^6.0.2",
+        "@codemirror/lang-xml": "^6.1.0",
+        "@codemirror/language": "^6.12.1",
+        "@codemirror/legacy-modes": "^6.5.2",
+        "@codemirror/search": "^6.6.0",
+        "@codemirror/state": "^6.5.4",
+        "@codemirror/view": "^6.39.14",
+        "@jupyter/ydoc": "^3.1.0",
+        "@jupyterlab/codeeditor": "^4.5.11",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/documentsearch": "^4.5.11",
+        "@jupyterlab/nbformat": "^4.5.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@lezer/common": "^1.2.1",
+        "@lezer/generator": "^1.7.0",
+        "@lezer/highlight": "^1.2.0",
+        "@lezer/markdown": "^1.3.0",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/signaling": "^2.1.5",
+        "yjs": "^13.5.40"
+      }
+    },
+    "node_modules/@jupyterlab/core-meta": {
+      "version": "4.6.4",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/core-meta/-/core-meta-4.6.4.tgz",
+      "integrity": "sha512-tcjDx4TxJXAZndeLPzTZzZh/KV37cWFBVwH+DYT62T82aIPp5T7wBENSDp2clJDu70N1V+m6vJnRpUqmeooAVA==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@jupyterlab/coreutils": {
+      "version": "6.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/coreutils/-/coreutils-6.5.11.tgz",
+      "integrity": "sha512-IXcXPSO2z68WQ+GL6qakGsuxc+9zdQnn6d/XioGxrSDzvkflloNgBTKyKOo71nTegyRQyvNaKl3nqliIuVWF4w==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/signaling": "^2.1.5",
+        "minimist": "~1.2.0",
+        "path-browserify": "^1.0.0",
+        "url-parse": "~1.5.4"
+      }
+    },
+    "node_modules/@jupyterlab/docregistry": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/docregistry/-/docregistry-4.5.11.tgz",
+      "integrity": "sha512-K/IxeYEVZ2izwhNCRYE7eBYIuBVGF2yEuruJ8QXcNrTlmsvzuMoiejgWB4qVGXee7FO8lnGqQ61V/2TXI8OPKQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyter/ydoc": "^3.1.0",
+        "@jupyterlab/apputils": "^4.6.11",
+        "@jupyterlab/codeeditor": "^4.5.11",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/observables": "^5.5.11",
+        "@jupyterlab/rendermime": "^4.5.11",
+        "@jupyterlab/rendermime-interfaces": "^3.13.11",
+        "@jupyterlab/services": "^7.5.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@jupyterlab/ui-components": "^4.5.11",
+        "@lumino/algorithm": "^2.0.4",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/properties": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/widgets": "^2.7.5",
+        "react": "^18.2.0"
+      }
+    },
+    "node_modules/@jupyterlab/documentsearch": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/documentsearch/-/documentsearch-4.5.11.tgz",
+      "integrity": "sha512-aCuu9XeGVrDDh/cPSKzOudK3wjvo5Mra5c839+naQUIhKVLSIrpecXUv/xe+fXGId8EdJLxK9CJ8I07I3tsrsA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/apputils": "^4.6.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@jupyterlab/ui-components": "^4.5.11",
+        "@lumino/commands": "^2.3.3",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/polling": "^2.1.5",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/widgets": "^2.7.5",
+        "react": "^18.2.0"
+      }
+    },
+    "node_modules/@jupyterlab/nbformat": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/nbformat/-/nbformat-4.5.11.tgz",
+      "integrity": "sha512-i4cAYClq+zmMCccCfkuQEmXGbrwfO9Agi/mYTij52dlnhXSnHVO64fZ1udmUrve8iJ1ZN/fo33bbyieJJPw3qQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/coreutils": "^2.2.2"
+      }
+    },
+    "node_modules/@jupyterlab/observables": {
+      "version": "5.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/observables/-/observables-5.5.11.tgz",
+      "integrity": "sha512-UT5uyc9utbUgTo3Pl0msIuuvJW6OH2p1TXnOVL1kaDSz9b4S9F+Ix6q52ualZ5RIlm2dSJpBQAoV9h/U6rLWKQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.4",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/signaling": "^2.1.5"
+      }
+    },
+    "node_modules/@jupyterlab/rendermime": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/rendermime/-/rendermime-4.5.11.tgz",
+      "integrity": "sha512-86XH8XdsU/sQvOg6Nk+s6O/B1mv8TQcuvzWl0De9fRawWzEUHWIXZQkPSQCdOVHvWZmpZgNipKVPTc8uTqYXzA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/apputils": "^4.6.11",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/nbformat": "^4.5.11",
+        "@jupyterlab/observables": "^5.5.11",
+        "@jupyterlab/rendermime-interfaces": "^3.13.11",
+        "@jupyterlab/services": "^7.5.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/widgets": "^2.7.5",
+        "lodash.escape": "^4.0.1"
+      }
+    },
+    "node_modules/@jupyterlab/rendermime-interfaces": {
+      "version": "3.13.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/rendermime-interfaces/-/rendermime-interfaces-3.13.11.tgz",
+      "integrity": "sha512-AlFcgHCTxB1TmHhttW1VnSV9+wRe1SYoKRtQ5QRL4XKp3nuYYFapFT2YPQ5Lnfknxq7klx7UEZrCY+0iCmTRfA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/coreutils": "^1.11.0 || ^2.2.2",
+        "@lumino/widgets": "^1.37.2 || ^2.7.5"
+      }
+    },
+    "node_modules/@jupyterlab/services": {
+      "version": "7.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/services/-/services-7.5.11.tgz",
+      "integrity": "sha512-O7DvGOl1EJfsa1aHOQP/+LEODh1AnNQ9OLBK7XEpC1QuDaGeaYP/gHReLkN3SQeRDCZqKqL7HkWb21H7xMllUw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyter/ydoc": "^3.1.0",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/nbformat": "^4.5.11",
+        "@jupyterlab/settingregistry": "^4.5.11",
+        "@jupyterlab/statedb": "^4.5.11",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/polling": "^2.1.5",
+        "@lumino/properties": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "ws": "^8.11.0"
+      }
+    },
+    "node_modules/@jupyterlab/settingregistry": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/settingregistry/-/settingregistry-4.5.11.tgz",
+      "integrity": "sha512-cCzblxxYIsr6lJ9zit1YNq/a1cRt0p4d3UT2pMvK5i1vTOphvsJJ1gvPfaFy7ivOShb9+hs+ZAIzOcZPGo5KAg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/nbformat": "^4.5.11",
+        "@jupyterlab/statedb": "^4.5.11",
+        "@lumino/commands": "^2.3.3",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/signaling": "^2.1.5",
+        "@rjsf/utils": "^5.13.4",
+        "ajv": "^8.12.0",
+        "json5": "^2.2.3"
+      },
+      "peerDependencies": {
+        "react": ">=16"
+      }
+    },
+    "node_modules/@jupyterlab/statedb": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/statedb/-/statedb-4.5.11.tgz",
+      "integrity": "sha512-9MCmn39OftRBv0DOX/OqlHGGq5eH9wgjhanYBrGEFb4Vg0kthyCauRkkmK6+Ku8vtkWZi0CAzQCIMiQCbr99Xg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/commands": "^2.3.3",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/properties": "^2.0.4",
+        "@lumino/signaling": "^2.1.5"
+      }
+    },
+    "node_modules/@jupyterlab/statusbar": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/statusbar/-/statusbar-4.5.11.tgz",
+      "integrity": "sha512-5dtd20wUR1OctmZdGRRvGaB83XDvfV7+yynNzECbFOUl6Qj7r5l2aIKAvIX/33ihZLpxMfjo6EatREnnT86KFQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/ui-components": "^4.5.11",
+        "@lumino/algorithm": "^2.0.4",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/widgets": "^2.7.5",
+        "react": "^18.2.0"
+      }
+    },
+    "node_modules/@jupyterlab/translation": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/translation/-/translation-4.5.11.tgz",
+      "integrity": "sha512-3Vo/M7Pdvr7v15X24Z5ZQ8sRHcY0mRqjTuutSe193QBzVom+mEga3QBobJRJO7KQKms7Ri8DVkVhi5x1IacIIA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/rendermime-interfaces": "^3.13.11",
+        "@jupyterlab/services": "^7.5.11",
+        "@jupyterlab/statedb": "^4.5.11",
+        "@lumino/coreutils": "^2.2.2"
+      }
+    },
+    "node_modules/@jupyterlab/ui-components": {
+      "version": "4.5.11",
+      "resolved": "https://registry.npmjs.org/@jupyterlab/ui-components/-/ui-components-4.5.11.tgz",
+      "integrity": "sha512-YoUhiVDr6yOGnhpvehZlcn0bIxC1PXBBL0ohucfrPdhBxpHUDA5AW3TIHavK+KwJZIGt1yVnnKdW9+tIRD4xFg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@jupyter/react-components": "^0.16.6",
+        "@jupyter/web-components": "^0.16.6",
+        "@jupyterlab/coreutils": "^6.5.11",
+        "@jupyterlab/observables": "^5.5.11",
+        "@jupyterlab/rendermime-interfaces": "^3.13.11",
+        "@jupyterlab/translation": "^4.5.11",
+        "@lumino/algorithm": "^2.0.4",
+        "@lumino/commands": "^2.3.3",
+        "@lumino/coreutils": "^2.2.2",
+        "@lumino/disposable": "^2.1.5",
+        "@lumino/messaging": "^2.0.4",
+        "@lumino/polling": "^2.1.5",
+        "@lumino/properties": "^2.0.4",
+        "@lumino/signaling": "^2.1.5",
+        "@lumino/virtualdom": "^2.0.4",
+        "@lumino/widgets": "^2.7.5",
+        "@rjsf/core": "^5.13.4",
+        "@rjsf/utils": "^5.13.4",
+        "react": "^18.2.0",
+        "react-dom": "^18.2.0",
+        "typestyle": "^2.0.4"
+      },
+      "peerDependencies": {
+        "react": "^18.2.0"
+      }
+    },
+    "node_modules/@lezer/common": {
+      "version": "1.5.3",
+      "resolved": "https://registry.npmjs.org/@lezer/common/-/common-1.5.3.tgz",
+      "integrity": "sha512-H0iErY4e43LpXbYDyBci5W4v/RwTgGV3YzYOlJPiGZ8RY8w51kVE+xLn1tg3Z6UmSfyETvtsUK3r7YsgDQEI7Q==",
+      "license": "MIT"
+    },
+    "node_modules/@lezer/cpp": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@lezer/cpp/-/cpp-1.1.6.tgz",
+      "integrity": "sha512-vh9gWWJOXFVY8HBHK3Twzq8MgwG2iN4GSyzBP9sCGTe37P15x2R14VaBQk0VA0ezTRN1KHYBBsHhvpGZ2Xy/pA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/css": {
+      "version": "1.3.9",
+      "resolved": "https://registry.npmjs.org/@lezer/css/-/css-1.3.9.tgz",
+      "integrity": "sha512-ZmzgvTOBdJWGIsY/ItAfN7UW8DV802oZG+jeG6E508SwEzz5YhuAajptpWPICvIyqYAD2+VjMdOS40GgGkyEOQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/generator": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/@lezer/generator/-/generator-1.8.1.tgz",
+      "integrity": "sha512-7q7szXqT7EPTs6SODBl58Qoz/4OrhNvm5pW4lbu1ZDnG5e0nn7drLzeN9Nxkm8j/1iMs5QZ9j3i4SV+W4Z6SQA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.1.0",
+        "@lezer/lr": "^1.3.0"
+      },
+      "bin": {
+        "lezer-generator": "src/lezer-generator.cjs"
+      }
+    },
+    "node_modules/@lezer/highlight": {
+      "version": "1.2.5",
+      "resolved": "https://registry.npmjs.org/@lezer/highlight/-/highlight-1.2.5.tgz",
+      "integrity": "sha512-O1GMVKgtf5YspFaRzpmqkVgMtIk2HG9uMAbH6wdAIdNh3TVzCsch/+cRi+6l2//UGDKe6NB9BW3cvuR5ezMQ0w==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/html": {
+      "version": "1.3.13",
+      "resolved": "https://registry.npmjs.org/@lezer/html/-/html-1.3.13.tgz",
+      "integrity": "sha512-oI7n6NJml729m7pjm9lvLvmXbdoMoi2f+1pwSDJkl9d68zGr7a9Btz8NdHTGQZtW2DA25ybeuv/SyDb9D5tseg==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/java": {
+      "version": "1.1.5",
+      "resolved": "https://registry.npmjs.org/@lezer/java/-/java-1.1.5.tgz",
+      "integrity": "sha512-JppTd1iKHpeNlLYw/Zl8JX7zSY5HqAzK4zZ05lpn8l8Sk7Fo5KAKiDiMiezKoT5lfeC2xZf8HeKp1tSctj4G6Q==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/javascript": {
+      "version": "1.5.6",
+      "resolved": "https://registry.npmjs.org/@lezer/javascript/-/javascript-1.5.6.tgz",
+      "integrity": "sha512-sEvOqpl4vJQca0NugSQK02vQPbc5KrvoojnYGoqqFgFO0MtcYhwGiHKVEB+LuXYJnfyXo4QPA8ztbrEa4Fw5NA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.1.3",
+        "@lezer/lr": "^1.3.0"
+      }
+    },
+    "node_modules/@lezer/json": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@lezer/json/-/json-1.0.3.tgz",
+      "integrity": "sha512-BP9KzdF9Y35PDpv04r0VeSTKDeox5vVr3efE7eBbx3r4s3oNLfunchejZhjArmeieBH+nVOpgIiBJpEAv8ilqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/lr": {
+      "version": "1.4.11",
+      "resolved": "https://registry.npmjs.org/@lezer/lr/-/lr-1.4.11.tgz",
+      "integrity": "sha512-UwgZcl1R66H2hDzBrA7kWyYmX6s8p5TQ+e/t7CuvgCtBEPxbEPaHYHu+pJBvTvDotEJpuQkJjbXuHiw5Cixxgw==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/markdown": {
+      "version": "1.8.0",
+      "resolved": "https://registry.npmjs.org/@lezer/markdown/-/markdown-1.8.0.tgz",
+      "integrity": "sha512-X6w3A2NpyhdtGqTWRJB8gR4QDXBaFMbTOs780ZdZ15KKCfBXOQTKcB3Vr+W6tqJHVlealt53tLmHRvOqPTQgYA==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.5.0",
+        "@lezer/highlight": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/php": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@lezer/php/-/php-1.0.6.tgz",
+      "integrity": "sha512-QJ2xNXPmsm/Z3IpThq8fnJrEIVpxhsIoj6GZBW0JYEd/l9zxpJZW216X4fzqQY4vgpdGIumypvI4uQjd4tnYtw==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.1.0"
+      }
+    },
+    "node_modules/@lezer/python": {
+      "version": "1.1.19",
+      "resolved": "https://registry.npmjs.org/@lezer/python/-/python-1.1.19.tgz",
+      "integrity": "sha512-MhQIURHRytsNzP/YXnqpYKW6la6voAH3kyplTOOiCdjyFY6cWWGFVmYVdHIPrElqSDf4iCDktQCockB9FxuhzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/rust": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/@lezer/rust/-/rust-1.0.3.tgz",
+      "integrity": "sha512-XxErOjZzQ7yJt1agUT4fu9qQvESZ3acgoxpPaPTPOiUx+duCjaVAtZGFIgphkHxlN05djdVAIOy/wItShMEjqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lezer/xml": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/@lezer/xml/-/xml-1.0.6.tgz",
+      "integrity": "sha512-CdDwirL0OEaStFue/66ZmFSeppuL6Dwjlk8qk153mSQwiSH/Dlri4GNymrNWnUmPl2Um7QfV1FO9KFUyX3Twww==",
+      "license": "MIT",
+      "dependencies": {
+        "@lezer/common": "^1.2.0",
+        "@lezer/highlight": "^1.0.0",
+        "@lezer/lr": "^1.0.0"
+      }
+    },
+    "node_modules/@lumino/algorithm": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/algorithm/-/algorithm-2.0.5.tgz",
+      "integrity": "sha512-yW5k0IRrNlNDL9/hLOPr0XaMYf7YSZ5a/uJ++a92ziBe7v7a3xzBJ1+Awhb6fMyanE0Mz97UOQIsHa3vWB0UQA==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@lumino/application": {
+      "version": "2.4.11",
+      "resolved": "https://registry.npmjs.org/@lumino/application/-/application-2.4.11.tgz",
+      "integrity": "sha512-mBdalG0W/42Suw8JXygjqdbsuHpDWujxmHTS2Ck7hM7wY3ahrsvW4Qe3Jp76BXruK4jeil9kkDWNRIfw0FdKDQ==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/commands": "^2.3.4",
+        "@lumino/coreutils": "^2.2.3",
+        "@lumino/widgets": "^2.10.0"
+      }
+    },
+    "node_modules/@lumino/collections": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/collections/-/collections-2.0.5.tgz",
+      "integrity": "sha512-iRthCb6cMoq1rcd4OC8dNFU7v/YbJOw647kzqrMxLPlQmMeeY5wHxF/W9qCb01VUI3zyxvh0/ND4DHB4mruJfA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5"
+      }
+    },
+    "node_modules/@lumino/commands": {
+      "version": "2.3.4",
+      "resolved": "https://registry.npmjs.org/@lumino/commands/-/commands-2.3.4.tgz",
+      "integrity": "sha512-bmCdM7jxX25s9ydKZcWmF7xL051MsG5fJ9IyCHoOPcKm3keuwX3wY1PpVERuooUvU6zZfI7+LFaolWX0eCs2Hw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5",
+        "@lumino/coreutils": "^2.2.3",
+        "@lumino/disposable": "^2.1.6",
+        "@lumino/domutils": "^2.0.5",
+        "@lumino/keyboard": "^2.0.5",
+        "@lumino/signaling": "^2.1.6",
+        "@lumino/virtualdom": "^2.0.5"
+      }
+    },
+    "node_modules/@lumino/coreutils": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/@lumino/coreutils/-/coreutils-2.2.3.tgz",
+      "integrity": "sha512-YxmayMeq8VJCPqo1okpsA3oOoz0eZeG5qedOLmopm+N/GwQT7S34QPPts49omVUwTJ0Xo8fGzOsxnS/LwnVl1Q==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5"
+      }
+    },
+    "node_modules/@lumino/disposable": {
+      "version": "2.1.6",
+      "resolved": "https://registry.npmjs.org/@lumino/disposable/-/disposable-2.1.6.tgz",
+      "integrity": "sha512-mTDBsftt+dWkP3MeeLuYjJ7mtOcrMld6Pq4h7EY6HzhPSdPXzvQELZ29vpc1lq6EWz/fzCfpoE+W8AzNUCHTLg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/signaling": "^2.1.6"
+      }
+    },
+    "node_modules/@lumino/domutils": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/domutils/-/domutils-2.0.5.tgz",
+      "integrity": "sha512-4zsSqWqAHvOFJTtvyAZsQu7qL5ZZRu37mTzppZNAI3a91jlIben3NbAMGZiyZeAnv3b9Z7S5sPOVWZKkJyhegg==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@lumino/dragdrop": {
+      "version": "2.1.9",
+      "resolved": "https://registry.npmjs.org/@lumino/dragdrop/-/dragdrop-2.1.9.tgz",
+      "integrity": "sha512-gwkdJNLrRE8GVh4Z70Yj5fhpasQNDkt8Z/aOneQbL4T1bpsMTwzdn3t/2pIZaWngrEqCGnj0ofUUuQAYZuQMyw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/coreutils": "^2.2.3",
+        "@lumino/disposable": "^2.1.6"
+      }
+    },
+    "node_modules/@lumino/keyboard": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/keyboard/-/keyboard-2.0.5.tgz",
+      "integrity": "sha512-YB7kmE0+ZeZ6oN/Qps6Ln8MXe4rZQh+27ex4GTJuxTMvvbqFhDW6mc/zN6av22HYxDlOF55YlzNhjk2LpD8k7A==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@lumino/messaging": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/messaging/-/messaging-2.0.5.tgz",
+      "integrity": "sha512-LNvV9xW6pkVuW8n4vFYxboJFOtt2WRJZMrg3Ta6C6LcfazVQy+ubiC8GRqBMq2ufZ1zclOWQII5QFC1wxFm6dg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5",
+        "@lumino/collections": "^2.0.5"
+      }
+    },
+    "node_modules/@lumino/polling": {
+      "version": "2.1.6",
+      "resolved": "https://registry.npmjs.org/@lumino/polling/-/polling-2.1.6.tgz",
+      "integrity": "sha512-q1+Ii2AH8rdLoeJvvjpNnmQU0PcDSXLVm0+XO447eJwYFRg56zjvZ/ZrbFUwPA0jz0xf2hbeHkdyAkmcVI4Qcw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/coreutils": "^2.2.3",
+        "@lumino/disposable": "^2.1.6",
+        "@lumino/signaling": "^2.1.6"
+      }
+    },
+    "node_modules/@lumino/properties": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/properties/-/properties-2.0.5.tgz",
+      "integrity": "sha512-+Yoo9lb/hzNKFXpkRaEC4r7aMe8prbEhscAbA/vyzqmY4NYjZsiqhxHUgyKgtGHosrrpY59Qv4ha+5csU08zsw==",
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@lumino/signaling": {
+      "version": "2.1.6",
+      "resolved": "https://registry.npmjs.org/@lumino/signaling/-/signaling-2.1.6.tgz",
+      "integrity": "sha512-PEB2nuNyippF/vj28oiDm7Zy8vAeVq07NE59L79GhaTe9i37TCjtA3+67DJnVGn1+fQPfexs6HdrY/90JFFwiw==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5",
+        "@lumino/coreutils": "^2.2.3"
+      }
+    },
+    "node_modules/@lumino/virtualdom": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@lumino/virtualdom/-/virtualdom-2.0.5.tgz",
+      "integrity": "sha512-Qgvtv9Iruny+p2y/jPWo9tOcUqS+Nlcwg14+m+xJEclFyVTpY8gGJKTDY8Y1wVO5PpQjRPNdbF8lxzrGR/89IA==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5"
+      }
+    },
+    "node_modules/@lumino/widgets": {
+      "version": "2.10.0",
+      "resolved": "https://registry.npmjs.org/@lumino/widgets/-/widgets-2.10.0.tgz",
+      "integrity": "sha512-8fQOw9/nD909CwiIVPa4VkvWFYWnCaD8IuPckR+7lBdGsx6bdZVfepHmH8o2dJaz+1BRxwKdy+RLsryqAofQug==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@lumino/algorithm": "^2.0.5",
+        "@lumino/commands": "^2.3.4",
+        "@lumino/coreutils": "^2.2.3",
+        "@lumino/disposable": "^2.1.6",
+        "@lumino/domutils": "^2.0.5",
+        "@lumino/dragdrop": "^2.1.9",
+        "@lumino/keyboard": "^2.0.5",
+        "@lumino/messaging": "^2.0.5",
+        "@lumino/properties": "^2.0.5",
+        "@lumino/signaling": "^2.1.6",
+        "@lumino/virtualdom": "^2.0.5"
+      }
+    },
+    "node_modules/@marijn/find-cluster-break": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/@marijn/find-cluster-break/-/find-cluster-break-1.0.4.tgz",
+      "integrity": "sha512-Wy0V7+SGUjnF9/TkiM1hKVDPj7jKXduPNboMVtHTA8dySMURWqfg/JZ9E2Sq8JgSJmkl7k7Qe9FLeMSrSraWmQ==",
+      "license": "MIT"
+    },
+    "node_modules/@microsoft/fast-colors": {
+      "version": "5.3.1",
+      "resolved": "https://registry.npmjs.org/@microsoft/fast-colors/-/fast-colors-5.3.1.tgz",
+      "integrity": "sha512-72RZXVfCbwQzvo5sXXkuLXLT7rMeYaSf5r/6ewQiv/trBtqpWRm4DEH2EilHw/iWTBKOXs1qZNQndgUMa5n4LA==",
+      "license": "MIT"
+    },
+    "node_modules/@microsoft/fast-element": {
+      "version": "1.14.0",
+      "resolved": "https://registry.npmjs.org/@microsoft/fast-element/-/fast-element-1.14.0.tgz",
+      "integrity": "sha512-zXvuSOzvsu8zDTy9eby8ix8VqLop2rwKRgp++ZN2kTCsoB3+QJVoaGD2T/Cyso2ViZQFXNpiNCVKfnmxBvmWkQ==",
+      "license": "MIT"
+    },
+    "node_modules/@microsoft/fast-foundation": {
+      "version": "2.50.0",
+      "resolved": "https://registry.npmjs.org/@microsoft/fast-foundation/-/fast-foundation-2.50.0.tgz",
+      "integrity": "sha512-8mFYG88Xea1jZf2TI9Lm/jzZ6RWR8x29r24mGuLojNYqIR2Bl8+hnswoV6laApKdCbGMPKnsAL/O68Q0sRxeVg==",
+      "license": "MIT",
+      "dependencies": {
+        "@microsoft/fast-element": "^1.14.0",
+        "@microsoft/fast-web-utilities": "^5.4.1",
+        "tabbable": "^5.2.0",
+        "tslib": "^1.13.0"
+      }
+    },
+    "node_modules/@microsoft/fast-web-utilities": {
+      "version": "5.4.1",
+      "resolved": "https://registry.npmjs.org/@microsoft/fast-web-utilities/-/fast-web-utilities-5.4.1.tgz",
+      "integrity": "sha512-ReWYncndjV3c8D8iq9tp7NcFNc1vbVHvcBFPME2nNFKNbS1XCesYZGlIlf3ot5EmuOXPlrzUHOWzQ2vFpIkqDg==",
+      "license": "MIT",
+      "dependencies": {
+        "exenv-es6": "^1.1.1"
+      }
+    },
+    "node_modules/@module-federation/error-codes": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/@module-federation/error-codes/-/error-codes-2.9.2.tgz",
+      "integrity": "sha512-MTpKubqsJSBgnuw+2Pli1kHL4INeHD5cGnHL84oRANwQAWK7b6lN3ZZTmL3FL6lYn65ImineqZNqGWBv5GQVLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@module-federation/runtime": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/@module-federation/runtime/-/runtime-2.9.2.tgz",
+      "integrity": "sha512-1lPZVy7TkMTTBMkkjgQt7jA+9FAx226yQqEz+X0lFAIbpxIWfpzNQLD+7IydEe83ZhDJpK3cv/9bn3jjQBZeqQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@module-federation/error-codes": "2.9.2",
+        "@module-federation/runtime-core": "2.9.2",
+        "@module-federation/sdk": "2.9.2"
+      }
+    },
+    "node_modules/@module-federation/runtime-core": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/@module-federation/runtime-core/-/runtime-core-2.9.2.tgz",
+      "integrity": "sha512-S9roTDqLtAWaaDBuug69ZnXXGEx0pUq/yG06J759bjRgfAg2P9+dWEv1q7rB2eMIp7HH4L6s3ColDRYdL6tJ9w==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@module-federation/error-codes": "2.9.2",
+        "@module-federation/sdk": "2.9.2"
+      }
+    },
+    "node_modules/@module-federation/runtime-tools": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/@module-federation/runtime-tools/-/runtime-tools-2.9.2.tgz",
+      "integrity": "sha512-rhOvimSLLnnocfOVUfAzH2xDq1pHMw4f/nSC+JQhSztEgP/1UslPPvcBcenx3B8/6CoYmBbGa2OIBTJ225ZHAg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@module-federation/runtime": "2.9.2",
+        "@module-federation/webpack-bundler-runtime": "2.9.2"
+      }
+    },
+    "node_modules/@module-federation/sdk": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/@module-federation/sdk/-/sdk-2.9.2.tgz",
+      "integrity": "sha512-ILtBFPuYpVcRA/Qay1lJ2hMtZI8fDE/v1n7xiN17e5qx5rSBR3FaamTsmRpN1hIt+gVnoa76CzOP/Y73d8hHNg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/@module-federation/webpack-bundler-runtime": {
+      "version": "2.9.2",
+      "resolved": "https://registry.npmjs.org/@module-federation/webpack-bundler-runtime/-/webpack-bundler-runtime-2.9.2.tgz",
+      "integrity": "sha512-dDtWiYcCWWgm/mCS7L4KfDHsyr7HwDRnHHS2bgl1H7RQfH4WAi706gT2hhzmV272PI33V7qJHN7Go1d/BamN0Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@module-federation/error-codes": "2.9.2",
+        "@module-federation/runtime": "2.9.2",
+        "@module-federation/sdk": "2.9.2"
+      }
+    },
+    "node_modules/@napi-rs/wasm-runtime": {
+      "version": "1.1.6",
+      "resolved": "https://registry.npmjs.org/@napi-rs/wasm-runtime/-/wasm-runtime-1.1.6.tgz",
+      "integrity": "sha512-ZLv/JdUfkvOy9eCnnBaGfiO+XimbjebAeO+MRQqD/B+FR1tnRN0tpKSJHRbE8sFfS6aqsXZ67TQjfwfsxULVbg==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@tybys/wasm-util": "^0.10.3"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/Brooooooklyn"
+      },
+      "peerDependencies": {
+        "@emnapi/core": "^1.7.1",
+        "@emnapi/runtime": "^1.7.1"
+      }
+    },
+    "node_modules/@rjsf/core": {
+      "version": "5.24.13",
+      "resolved": "https://registry.npmjs.org/@rjsf/core/-/core-5.24.13.tgz",
+      "integrity": "sha512-ONTr14s7LFIjx2VRFLuOpagL76sM/HPy6/OhdBfq6UukINmTIs6+aFN0GgcR0aXQHFDXQ7f/fel0o/SO05Htdg==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "lodash": "^4.17.21",
+        "lodash-es": "^4.17.21",
+        "markdown-to-jsx": "^7.4.1",
+        "prop-types": "^15.8.1"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "peerDependencies": {
+        "@rjsf/utils": "^5.24.x",
+        "react": "^16.14.0 || >=17"
+      }
+    },
+    "node_modules/@rjsf/utils": {
+      "version": "5.24.13",
+      "resolved": "https://registry.npmjs.org/@rjsf/utils/-/utils-5.24.13.tgz",
+      "integrity": "sha512-rNF8tDxIwTtXzz5O/U23QU73nlhgQNYJ+Sv5BAwQOIyhIE2Z3S5tUiSVMwZHt0julkv/Ryfwi+qsD4FiE5rOuw==",
+      "license": "Apache-2.0",
+      "dependencies": {
+        "json-schema-merge-allof": "^0.8.1",
+        "jsonpointer": "^5.0.1",
+        "lodash": "^4.17.21",
+        "lodash-es": "^4.17.21",
+        "react-is": "^18.2.0"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "peerDependencies": {
+        "react": "^16.14.0 || >=17"
+      }
+    },
+    "node_modules/@rspack/binding": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding/-/binding-2.2.8.tgz",
+      "integrity": "sha512-c9flkSua3khHnOKBCRk8BkHGOwU9YB7niv+5JfQXiLZIvJmgKsZ7PD8QrFklMhsJT3oVAc6c9GN7/wy1YkACjA==",
+      "dev": true,
+      "license": "MIT",
+      "optionalDependencies": {
+        "@rspack/binding-darwin-arm64": "2.2.8",
+        "@rspack/binding-darwin-x64": "2.2.8",
+        "@rspack/binding-linux-arm64-gnu": "2.2.8",
+        "@rspack/binding-linux-arm64-musl": "2.2.8",
+        "@rspack/binding-linux-ppc64-gnu": "2.2.8",
+        "@rspack/binding-linux-riscv64-gnu": "2.2.8",
+        "@rspack/binding-linux-riscv64-musl": "2.2.8",
+        "@rspack/binding-linux-s390x-gnu": "2.2.8",
+        "@rspack/binding-linux-x64-gnu": "2.2.8",
+        "@rspack/binding-linux-x64-musl": "2.2.8",
+        "@rspack/binding-wasm32-wasi": "2.2.8",
+        "@rspack/binding-win32-arm64-msvc": "2.2.8",
+        "@rspack/binding-win32-ia32-msvc": "2.2.8",
+        "@rspack/binding-win32-x64-msvc": "2.2.8"
+      }
+    },
+    "node_modules/@rspack/binding-darwin-arm64": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-arm64/-/binding-darwin-arm64-2.2.8.tgz",
+      "integrity": "sha512-d6GuY/k7kJk7SOXmruIz0m+2fIXaLv2SnBHEYsbvBzE7ZO6QXq7fSABWFWNnSnNu+brYHA5Dr/skV81bXgTTCw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rspack/binding-darwin-x64": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-darwin-x64/-/binding-darwin-x64-2.2.8.tgz",
+      "integrity": "sha512-xCVou/jJASjEAjwy1T3hPJcJqA5QZASJfUwHqEk+nA0v44MagwH8tM8lsOvRfhzR7N2+YFac1rfZOUT8uM3awg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "darwin"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-arm64-gnu": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-arm64-gnu/-/binding-linux-arm64-gnu-2.2.8.tgz",
+      "integrity": "sha512-Zy/ss6YAQTjOWKDkcWrbKtu+pySltqT22wn68nlrWKygPWLNmMdU5anlsnwRTIuQ3MF0YJRS42ARauVtlqvRQw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-arm64-musl": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-arm64-musl/-/binding-linux-arm64-musl-2.2.8.tgz",
+      "integrity": "sha512-lxgp5O8PhL3St9p82llHoNoeWzp9jltW5S9F00p00XPJZHUIuxbwfLSzn/6Wg86USEmafLoBkyD9CM8rBd3SNQ==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-ppc64-gnu": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-ppc64-gnu/-/binding-linux-ppc64-gnu-2.2.8.tgz",
+      "integrity": "sha512-MY+YqpT02tcDCMgHy+IewQsaz7ql4mbJaAqqMlTIqvQwAUl9dXEP7BL352OgCxm9VRebTldE5lK99A3wVd3zqA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-riscv64-gnu": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-riscv64-gnu/-/binding-linux-riscv64-gnu-2.2.8.tgz",
+      "integrity": "sha512-wmN9OigSGNGCKY+AOYaWI8LJcIi8qvs5KjueBueCKOnTV6MPIEujA75QZH1pehTTYKvdGv7r2EtUXUmWpn7/SQ==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-riscv64-musl": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-riscv64-musl/-/binding-linux-riscv64-musl-2.2.8.tgz",
+      "integrity": "sha512-ZcQMYR10hLh581zs9MFnFFn0F7wyt5fkDffyukeMHJEoPJrbkfl6cQtsUdpQnZ+mYGYS5KydD1DT9/eMH65jjw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-s390x-gnu": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-s390x-gnu/-/binding-linux-s390x-gnu-2.2.8.tgz",
+      "integrity": "sha512-ahBiE+Ir1FMYvStYicihhSJlS2YRagxtry0jWH8zW287o7C0eiHJ+pteJHHC15T5RJqm0j6w5TuwYe+F9AYxxg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-x64-gnu": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-x64-gnu/-/binding-linux-x64-gnu-2.2.8.tgz",
+      "integrity": "sha512-dncEI515NoPXh3zzWk06Rb3mhSV76myiFKqXiJ8K4fVAe5x/RlweMhvPhHhm7RnIMeBld7BeStzOqj38XFsWGA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-linux-x64-musl": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-linux-x64-musl/-/binding-linux-x64-musl-2.2.8.tgz",
+      "integrity": "sha512-pfFyU03PjD0GaQG8zOQOHwq51rrJZetXjTGpMmz7iA1hq/f9lChJsDWrC8/7VXeQLwBofLZlOODqe8OM8OBzgA==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "linux"
+      ]
+    },
+    "node_modules/@rspack/binding-wasm32-wasi": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-wasm32-wasi/-/binding-wasm32-wasi-2.2.8.tgz",
+      "integrity": "sha512-3mOJuZTrF56jOh/GD9chLMJKbzPZ6Ty2OIML7+lLz0Yk2XS/xWRfLn85Dmnkb/O6UF65x7+p8VPAIZlBtLTclw==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/core": "1.11.3",
+        "@emnapi/runtime": "1.11.3",
+        "@napi-rs/wasm-runtime": "1.1.6"
+      }
+    },
+    "node_modules/@rspack/binding-win32-arm64-msvc": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-win32-arm64-msvc/-/binding-win32-arm64-msvc-2.2.8.tgz",
+      "integrity": "sha512-Cu/RMZT/16s+67xhl6X1pswetL3GLSQl+LnugKRh08Ul21A/tR7vxC4g4aih4u9k5SXCAngxFUt8zAjKnHIBqA==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rspack/binding-win32-ia32-msvc": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-win32-ia32-msvc/-/binding-win32-ia32-msvc-2.2.8.tgz",
+      "integrity": "sha512-H/erd6di8OapZhhM0raA/7XduPn9jusfLMeO1XF+AmF9WF3HzHgMjha1j+KwtPgQnaH69w6AhY+G2472VIwQmw==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rspack/binding-win32-x64-msvc": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/binding-win32-x64-msvc/-/binding-win32-x64-msvc-2.2.8.tgz",
+      "integrity": "sha512-BziHSUlIQM0MliCqdcHuBXSkQGtPoHQTXJce7fsgnTAzQFgPeog92qTNezYI4IrQ7pQouyiVJ2HPieUbVPRKQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "os": [
+        "win32"
+      ]
+    },
+    "node_modules/@rspack/core": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/@rspack/core/-/core-2.2.8.tgz",
+      "integrity": "sha512-JugsVrnbMGNYzMH++7gR9enygpP/lAo9PbVRq3XmJg0ryIvCpST0XJjBcccaSjYaaPamsjrddihmgVLMFp+yXw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@rspack/binding": "2.2.8"
+      },
+      "engines": {
+        "node": "^20.19.0 || >=22.12.0"
+      },
+      "peerDependencies": {
+        "@module-federation/runtime-tools": "^0.24.1 || ^2.0.0",
+        "@swc/helpers": "^0.5.23"
+      },
+      "peerDependenciesMeta": {
+        "@module-federation/runtime-tools": {
+          "optional": true
+        },
+        "@swc/helpers": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/@tybys/wasm-util": {
+      "version": "0.10.4",
+      "resolved": "https://registry.npmjs.org/@tybys/wasm-util/-/wasm-util-0.10.4.tgz",
+      "integrity": "sha512-W3c4gRigFS0T/Ma4qIYF3GDAc5AQdHb1yL5znJT1Zv1YaD9Kitx656wBjvr19qbiosmZT8lWDM5BEMynUqX65A==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@tybys/wasm-util/node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/@types/estree": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/@types/estree/-/estree-1.0.9.tgz",
+      "integrity": "sha512-GhdPgy1el4/ImP05X05Uw4cw2/M93BCUmnEvWZNStlCzEKME4Fkk+YpoA5OiHNQmoS7Cafb8Xa3Pya8m1Qrzeg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/json-schema": {
+      "version": "7.0.15",
+      "resolved": "https://registry.npmjs.org/@types/json-schema/-/json-schema-7.0.15.tgz",
+      "integrity": "sha512-5+fP8P8MFNC+AyZCDxrB2pkZFPGzqQWUzpSeuuVLvm8VMcorNYavBqoFcxK8bQz4Qsbn4oUEEem4wDLfcysGHA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@types/node": {
+      "version": "22.20.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-22.20.5.tgz",
+      "integrity": "sha512-U2+DNr+wSjpsTS/wZGYHq7GcwfuSmKiKvoPvK22zwTlRhU91yOniN4qRR5KhIjvif7ysw/dz/hKmfDH0Ris4aA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~6.21.0"
+      }
+    },
+    "node_modules/@types/prop-types": {
+      "version": "15.7.15",
+      "resolved": "https://registry.npmjs.org/@types/prop-types/-/prop-types-15.7.15.tgz",
+      "integrity": "sha512-F6bEyamV9jKGAFBEmlQnesRPGOQqS2+Uwi0Em15xenOxHaf2hv6L8YCVn3rPdPJOiJfPiCnLIRyvwVaqMY3MIw==",
+      "license": "MIT"
+    },
+    "node_modules/@types/react": {
+      "version": "18.3.31",
+      "resolved": "https://registry.npmjs.org/@types/react/-/react-18.3.31.tgz",
+      "integrity": "sha512-vfEqpXTvwT91yhmwdfouStN2hSKwTvyRs8qpLfADyrq/kxDw0hZM7Wk9Ug1FELj8hIby+S/+kQCSRFF32nv2Qw==",
+      "license": "MIT",
+      "dependencies": {
+        "@types/prop-types": "*",
+        "csstype": "^3.2.2"
+      }
+    },
+    "node_modules/@webassemblyjs/ast": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.14.1.tgz",
+      "integrity": "sha512-nuBEDgQfm1ccRp/8bCQrx1frohyufl4JlbMMZ4P1wpeOfDhF6FQkxZJ1b/e+PLwr6X1Nhw6OLme5usuBWYBvuQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/helper-numbers": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2"
+      }
+    },
+    "node_modules/@webassemblyjs/floating-point-hex-parser": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/floating-point-hex-parser/-/floating-point-hex-parser-1.13.2.tgz",
+      "integrity": "sha512-6oXyTOzbKxGH4steLbLNOu71Oj+C8Lg34n6CqRvqfS2O71BxY6ByfMDRhBytzknj9yGUPVJ1qIKhRlAwO1AovA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@webassemblyjs/helper-api-error": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-api-error/-/helper-api-error-1.13.2.tgz",
+      "integrity": "sha512-U56GMYxy4ZQCbDZd6JuvvNV/WFildOjsaWD3Tzzvmw/mas3cXzRJPMjP83JqEsgSbyrmaGjBfDtV7KDXV9UzFQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@webassemblyjs/helper-buffer": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-buffer/-/helper-buffer-1.14.1.tgz",
+      "integrity": "sha512-jyH7wtcHiKssDtFPRB+iQdxlDf96m0E39yb0k5uJVhFGleZFoNw1c4aeIcVUPPbXUVJ94wwnMOAqUHyzoEPVMA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@webassemblyjs/helper-numbers": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-numbers/-/helper-numbers-1.13.2.tgz",
+      "integrity": "sha512-FE8aCmS5Q6eQYcV3gI35O4J789wlQA+7JrqTTpJqn5emA4U2hvwJmvFRC0HODS+3Ye6WioDklgd6scJ3+PLnEA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/floating-point-hex-parser": "1.13.2",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "node_modules/@webassemblyjs/helper-wasm-bytecode": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-bytecode/-/helper-wasm-bytecode-1.13.2.tgz",
+      "integrity": "sha512-3QbLKy93F0EAIXLh0ogEVR6rOubA9AoZ+WRYhNbFyuB70j3dRdwH9g+qXhLAO0kiYGlg3TxDV+I4rQTr/YNXkA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@webassemblyjs/helper-wasm-section": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/helper-wasm-section/-/helper-wasm-section-1.14.1.tgz",
+      "integrity": "sha512-ds5mXEqTJ6oxRoqjhWDU83OgzAYjwsCV8Lo/N+oRsNDmx/ZDpqalmrtgOMkHwxsG0iI//3BwWAErYRHtgn0dZw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/wasm-gen": "1.14.1"
+      }
+    },
+    "node_modules/@webassemblyjs/ieee754": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/ieee754/-/ieee754-1.13.2.tgz",
+      "integrity": "sha512-4LtOzh58S/5lX4ITKxnAK2USuNEvpdVV9AlgGQb8rJDHaLeHciwG4zlGr0j/SNWlr7x3vO1lDEsuePvtcDNCkw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@xtuc/ieee754": "^1.2.0"
+      }
+    },
+    "node_modules/@webassemblyjs/leb128": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/leb128/-/leb128-1.13.2.tgz",
+      "integrity": "sha512-Lde1oNoIdzVzdkNEAWZ1dZ5orIbff80YPdHx20mrHwHrVNNTjNr8E3xz9BdpcGqRQbAEa+fkrCb+fRFTl/6sQw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "dependencies": {
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "node_modules/@webassemblyjs/utf8": {
+      "version": "1.13.2",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/utf8/-/utf8-1.13.2.tgz",
+      "integrity": "sha512-3NQWGjKTASY1xV5m7Hr0iPeXD9+RDobLll3T9d2AO+g3my8xy5peVyjSag4I50mR1bBSN/Ct12lo+R9tJk0NZQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/@webassemblyjs/wasm-edit": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-edit/-/wasm-edit-1.14.1.tgz",
+      "integrity": "sha512-RNJUIQH/J8iA/1NzlE4N7KtyZNHi3w7at7hDjvRNm5rcUXa00z1vRz3glZoULfJ5mpvYhLybmVcwcjGrC1pRrQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/helper-wasm-section": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-opt": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1",
+        "@webassemblyjs/wast-printer": "1.14.1"
+      }
+    },
+    "node_modules/@webassemblyjs/wasm-gen": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-gen/-/wasm-gen-1.14.1.tgz",
+      "integrity": "sha512-AmomSIjP8ZbfGQhumkNvgC33AY7qtMCXnN6bL2u2Js4gVCg8fp735aEiMSBbDR7UQIj90n4wKAFUSEd0QN2Ukg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
+      }
+    },
+    "node_modules/@webassemblyjs/wasm-opt": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-opt/-/wasm-opt-1.14.1.tgz",
+      "integrity": "sha512-PTcKLUNvBqnY2U6E5bdOQcSM+oVP/PmrDY9NzowJjislEjwP/C4an2303MCVS2Mg9d3AJpIGdUFIQQWbPds0Sw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-buffer": "1.14.1",
+        "@webassemblyjs/wasm-gen": "1.14.1",
+        "@webassemblyjs/wasm-parser": "1.14.1"
+      }
+    },
+    "node_modules/@webassemblyjs/wasm-parser": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wasm-parser/-/wasm-parser-1.14.1.tgz",
+      "integrity": "sha512-JLBl+KZ0R5qB7mCnud/yyX08jWFw5MsoalJ1pQ4EdFlgj9VdXKGuENGsiCIjegI1W7p91rUlcB/LB5yRJKNTcQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@webassemblyjs/helper-api-error": "1.13.2",
+        "@webassemblyjs/helper-wasm-bytecode": "1.13.2",
+        "@webassemblyjs/ieee754": "1.13.2",
+        "@webassemblyjs/leb128": "1.13.2",
+        "@webassemblyjs/utf8": "1.13.2"
+      }
+    },
+    "node_modules/@webassemblyjs/wast-printer": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/@webassemblyjs/wast-printer/-/wast-printer-1.14.1.tgz",
+      "integrity": "sha512-kPSSXE6De1XOR820C90RIo2ogvZG+c3KiHzqUoO/F34Y2shGzesfqv7o57xrxovZJH/MetF5UjroJ/R/3isoiw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@webassemblyjs/ast": "1.14.1",
+        "@xtuc/long": "4.2.2"
+      }
+    },
+    "node_modules/@xtuc/ieee754": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/@xtuc/ieee754/-/ieee754-1.2.0.tgz",
+      "integrity": "sha512-DX8nKgqcGwsc0eJSqYt5lwP4DH5FlHnmuWWBRy7X0NcaGR0ZtuyeESgMwTYVEtxmsNGY+qit4QYT/MIYTOTPeA==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "peer": true
+    },
+    "node_modules/@xtuc/long": {
+      "version": "4.2.2",
+      "resolved": "https://registry.npmjs.org/@xtuc/long/-/long-4.2.2.tgz",
+      "integrity": "sha512-NuHqBY1PB/D8xU6s/thBgOAiAP7HOYDQ32+BFZILJ8ivkUkAHQnWfn6WhL79Owj1qmUnoN/YPhktdIoucipkAQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true
+    },
+    "node_modules/acorn": {
+      "version": "8.19.0",
+      "resolved": "https://registry.npmjs.org/acorn/-/acorn-8.19.0.tgz",
+      "integrity": "sha512-oJlA3XiRm7Cyk6qFD2Jn8ak9B7jSy0qy00ADO3+8dpT0LSjFihQYv4C02LFCSYJV3Q37xYwwRy5m+IpIiUzqWw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "bin": {
+        "acorn": "bin/acorn"
+      },
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/ajv": {
+      "version": "8.20.0",
+      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
+      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
+      "license": "MIT",
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3",
+        "fast-uri": "^3.0.1",
+        "json-schema-traverse": "^1.0.0",
+        "require-from-string": "^2.0.2"
+      },
+      "funding": {
+        "type": "github",
+        "url": "https://github.com/sponsors/epoberezkin"
+      }
+    },
+    "node_modules/ajv-formats": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
+      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependencies": {
+        "ajv": "^8.0.0"
+      },
+      "peerDependenciesMeta": {
+        "ajv": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/ajv-keywords": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/ajv-keywords/-/ajv-keywords-5.1.0.tgz",
+      "integrity": "sha512-YCS/JNFAUyr5vAuhk1DWm1CBxRHW9LbJ2ozWeemrIqpbsqKjHVxYPyi5GC0rjZIT5JxJ3virVTS8wk4i/Z+krw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "fast-deep-equal": "^3.1.3"
+      },
+      "peerDependencies": {
+        "ajv": "^8.8.2"
+      }
+    },
+    "node_modules/ansi-styles": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-3.2.1.tgz",
+      "integrity": "sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^1.9.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/balanced-match": {
+      "version": "4.0.4",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+      "integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "18 || 20 || >=22"
+      }
+    },
+    "node_modules/baseline-browser-mapping": {
+      "version": "2.11.27",
+      "resolved": "https://registry.npmjs.org/baseline-browser-mapping/-/baseline-browser-mapping-2.11.27.tgz",
+      "integrity": "sha512-ElY12DaROGuan+lMmZ8Cvo/ZUbXPe7Enc/9VU/b1T3Kp4dwytRcNdR8DoSJN5SNJT/CuvcCA0DHDVmMOCePdRQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "peer": true,
+      "bin": {
+        "baseline-browser-mapping": "dist/cli.cjs"
+      },
+      "engines": {
+        "node": ">=6.0.0"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "5.0.12",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.12.tgz",
+      "integrity": "sha512-YovQ3rzhaLMIrDjNDMkNS01tea93qhEhG5xy8f6+R0l+dw3Ki+5sCoIoI942iuLZTHWogWktgwVDhU09iNEimQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^4.0.2"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/browserslist": {
+      "version": "4.29.3",
+      "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.29.3.tgz",
+      "integrity": "sha512-1R4kiYKXGViqEN0CnoDrXc1StD9niAwu+j2dukWzrD4bJgsD4lDmEp0CRbc6E/vYJIfTHwPmwyaKtVSudICdPA==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "baseline-browser-mapping": "^2.11.26",
+        "caniuse-lite": "^1.0.30001813",
+        "electron-to-chromium": "^1.5.439",
+        "node-releases": "^2.0.57",
+        "update-browserslist-db": "^1.3.3"
+      },
+      "bin": {
+        "browserslist": "cli.js"
+      },
+      "engines": {
+        "node": "^6 || ^7 || ^8 || ^9 || ^10 || ^11 || ^12 || >=13.7"
+      }
+    },
+    "node_modules/buffer-from": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/buffer-from/-/buffer-from-1.1.2.tgz",
+      "integrity": "sha512-E+XQCRwSbaaiChtv6k6Dwgc+bx+Bs6vuKJHHl5kox/BaKbhiXzqQOwK4cO22yElGp2OCmjwVhT3HmxgyPGnJfQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/caniuse-lite": {
+      "version": "1.0.30001815",
+      "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001815.tgz",
+      "integrity": "sha512-uDybUEyfgbyJJ93J1vikTylBX31AkdVYeVPeffMQpf8XN7hSfr0oZOn4VFOIMNvtU5+rHvC5Udg2TgtJKHm23Q==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/caniuse-lite"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "CC-BY-4.0",
+      "peer": true
+    },
+    "node_modules/chalk": {
+      "version": "2.4.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-2.4.2.tgz",
+      "integrity": "sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^3.2.1",
+        "escape-string-regexp": "^1.0.5",
+        "supports-color": "^5.3.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chalk/node_modules/has-flag": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-3.0.0.tgz",
+      "integrity": "sha512-sKJf1+ceQBr4SMkvQnBDNDtf4TXpVhVGateu0t918bl30FnbE2m4vNLX+VWe/dpjlb+HugGYzW7uQXH98HPEYw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chalk/node_modules/supports-color": {
+      "version": "5.5.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-5.5.0.tgz",
+      "integrity": "sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/chrome-trace-event": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/chrome-trace-event/-/chrome-trace-event-1.0.4.tgz",
+      "integrity": "sha512-rNjApaLzuwaOTjCiT8lSDdGN1APCiqkChLMJxJPWLunPAt5fy8xgU9/jNOchV84wfIxrA0lRQB7oCT8jrn/wrQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6.0"
+      }
+    },
+    "node_modules/clone-deep": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/clone-deep/-/clone-deep-4.0.1.tgz",
+      "integrity": "sha512-neHB9xuzh/wk0dIHweyAXv2aPGZIVk3pLMe+/RNzINf17fe0OG96QroktYAUm7SM1PBnzTabaLboqqxDyMU+SQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "is-plain-object": "^2.0.4",
+        "kind-of": "^6.0.2",
+        "shallow-clone": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/clone-deep/node_modules/is-plain-object": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-2.0.4.tgz",
+      "integrity": "sha512-h5PpgXkWitc38BBMYawTYMWJHFZJVnBquFE57xFpjB8pJFiF6gZ+bU+WyI/yqXiFR5mdLsgYNaPe8uao6Uv9Og==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "isobject": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/color-convert": {
+      "version": "1.9.3",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-1.9.3.tgz",
+      "integrity": "sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "1.1.3"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.3.tgz",
+      "integrity": "sha512-72fSenhMw2HZMTVHeCA9KCmpEIbzWiQsjN+BHcBbS9vr1mtt+vJjPdksIBNUmKAW8TFUDPJK5SUU3QhE9NEXDw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || >=14"
+      }
+    },
+    "node_modules/compute-gcd": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/compute-gcd/-/compute-gcd-1.2.1.tgz",
+      "integrity": "sha512-TwMbxBNz0l71+8Sc4czv13h4kEqnchV9igQZBi6QUaz09dnz13juGnnaWWJTRsP3brxOoxeB4SA2WELLw1hCtg==",
+      "dependencies": {
+        "validate.io-array": "^1.0.3",
+        "validate.io-function": "^1.0.2",
+        "validate.io-integer-array": "^1.0.0"
+      }
+    },
+    "node_modules/compute-lcm": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/compute-lcm/-/compute-lcm-1.1.2.tgz",
+      "integrity": "sha512-OFNPdQAXnQhDSKioX8/XYT6sdUlXwpeMjfd6ApxMJfyZ4GxmLR1xvMERctlYhlHwIiz6CSpBc2+qYKjHGZw4TQ==",
+      "dependencies": {
+        "compute-gcd": "^1.2.1",
+        "validate.io-array": "^1.0.3",
+        "validate.io-function": "^1.0.2",
+        "validate.io-integer-array": "^1.0.0"
+      }
+    },
+    "node_modules/crelt": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/crelt/-/crelt-1.0.7.tgz",
+      "integrity": "sha512-aK6BbWfhf4U/wCcLHKPJl/xa6VkVstRaPywWtMKGwuOLc/wZTyQYuoxgvZnNsBvv7Kg3YTBQYYBCggcviQczuA==",
+      "license": "MIT"
+    },
+    "node_modules/css-loader": {
+      "version": "7.1.5",
+      "resolved": "https://registry.npmjs.org/css-loader/-/css-loader-7.1.5.tgz",
+      "integrity": "sha512-Q7iAfQkU2twNBryKX/vGAlE+GAmkF7quhSzAGNK8fBimxk3+tqg245rH52UPb9dioBolBc8rP0ihmHBaDTJQBA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "icss-utils": "^5.1.0",
+        "postcss": "^8.4.40",
+        "postcss-modules-extract-imports": "^3.1.0",
+        "postcss-modules-local-by-default": "^4.0.5",
+        "postcss-modules-scope": "^3.2.0",
+        "postcss-modules-values": "^4.0.0",
+        "postcss-value-parser": "^4.2.0",
+        "semver": "^7.6.3"
+      },
+      "engines": {
+        "node": ">= 18.12.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "@rspack/core": "0.x || ^1.0.0 || ^2.0.0-0",
+        "webpack": "^5.27.0"
+      },
+      "peerDependenciesMeta": {
+        "@rspack/core": {
+          "optional": true
+        },
+        "webpack": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/cssesc": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/cssesc/-/cssesc-3.0.0.tgz",
+      "integrity": "sha512-/Tb/JcjK111nNScGob5MNtsntNM1aCNUDipB/TkwZFhyDrrE47SOx/18wF2bbjgc3ZzCSKW1T5nt5EbFoAz/Vg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "cssesc": "bin/cssesc"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/csstype": {
+      "version": "3.2.3",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.2.3.tgz",
+      "integrity": "sha512-z1HGKcYy2xA8AGQfwrn0PAy+PB7X/GSj3UVJW9qKyn43xWa+gl5nXmU4qqLMRzWVLFC8KusUX8T/0kCiOYpAIQ==",
+      "license": "MIT"
+    },
+    "node_modules/deepmerge": {
+      "version": "4.3.1",
+      "resolved": "https://registry.npmjs.org/deepmerge/-/deepmerge-4.3.1.tgz",
+      "integrity": "sha512-3sUqbMEc77XqpdNO7FRyRog+eW3ph+GYCbj+rK+uYyRMuwsVy0rMiVtPn+QJlKFvWP/1PYpapqYn0Me2knFn+A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/dom-serializer": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/dom-serializer/-/dom-serializer-2.0.0.tgz",
+      "integrity": "sha512-wIkAryiqt/nV5EQKqQpo3SToSOV9J0DnbJqwK7Wv/Trc92zIAYZ4FlMu+JPFW1DfGFt81ZTCGgDEabffXeLyJg==",
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.2",
+        "entities": "^4.2.0"
+      },
+      "funding": {
+        "url": "https://github.com/cheeriojs/dom-serializer?sponsor=1"
+      }
+    },
+    "node_modules/domelementtype": {
+      "version": "2.3.0",
+      "resolved": "https://registry.npmjs.org/domelementtype/-/domelementtype-2.3.0.tgz",
+      "integrity": "sha512-OLETBj6w0OsagBwdXnPdN0cnMfF9opN69co+7ZrbfPGrdpPVNBUj02spi6B1N7wChLQiPn4CSH/zJvXw56gmHw==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "BSD-2-Clause"
+    },
+    "node_modules/domhandler": {
+      "version": "5.0.3",
+      "resolved": "https://registry.npmjs.org/domhandler/-/domhandler-5.0.3.tgz",
+      "integrity": "sha512-cgwlv/1iFQiFnU96XXgROh8xTeetsnJiDsTc7TYCLFd9+/WNkIqPTxiM/8pSd8VIrhXGTf1Ny1q1hquVqDJB5w==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "domelementtype": "^2.3.0"
+      },
+      "engines": {
+        "node": ">= 4"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domhandler?sponsor=1"
+      }
+    },
+    "node_modules/domutils": {
+      "version": "3.2.2",
+      "resolved": "https://registry.npmjs.org/domutils/-/domutils-3.2.2.tgz",
+      "integrity": "sha512-6kZKyUajlDuqlHKVX1w7gyslj9MPIXzIFiz/rGu35uC1wMi+kMhQwGhl4lt9unC9Vb9INnY9Z3/ZA3+FhASLaw==",
+      "license": "BSD-2-Clause",
+      "dependencies": {
+        "dom-serializer": "^2.0.0",
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/domutils?sponsor=1"
+      }
+    },
+    "node_modules/duplicate-package-checker-webpack-plugin": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/duplicate-package-checker-webpack-plugin/-/duplicate-package-checker-webpack-plugin-3.0.0.tgz",
+      "integrity": "sha512-aO50/qPC7X2ChjRFniRiscxBLT/K01bALqfcDaf8Ih5OqQ1N4iT/Abx9Ofu3/ms446vHTm46FACIuJUmgUQcDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "chalk": "^2.3.0",
+        "find-root": "^1.0.0",
+        "lodash": "^4.17.4",
+        "semver": "^5.4.1"
+      }
+    },
+    "node_modules/duplicate-package-checker-webpack-plugin/node_modules/semver": {
+      "version": "5.7.2",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-5.7.2.tgz",
+      "integrity": "sha512-cBznnQ9KjJqU67B52RMC65CMarK2600WFnbkcaiwWq3xy/5haFJlshgnpjovMVJ+Hff49d8GEn0b87C5pDQ10g==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver"
+      }
+    },
+    "node_modules/electron-to-chromium": {
+      "version": "1.5.451",
+      "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.451.tgz",
+      "integrity": "sha512-vUNKPrUzw8ByEMOxloq0a71iD/mPuPxVkbDm3G5YhnxTzOw/I6qAg2MUS0cYj/c267lWmw26yW4Vv7foxTxPLg==",
+      "dev": true,
+      "license": "ISC",
+      "peer": true
+    },
+    "node_modules/enhanced-resolve": {
+      "version": "5.26.0",
+      "resolved": "https://registry.npmjs.org/enhanced-resolve/-/enhanced-resolve-5.26.0.tgz",
+      "integrity": "sha512-9vhedylFonb2YGogzUKX6+Ja72gOJbN1QHAqdrvqLwhdl/QWbKopzoUC9EbQNVsAns/bx/4uyqalrQAoy1IByw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "graceful-fs": "^4.2.4",
+        "tapable": "^2.3.3"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/entities": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/entities/-/entities-4.5.0.tgz",
+      "integrity": "sha512-V0hjH4dGPh9Ao5p0MoRY6BVqtwCjhz6vI5LT8AJ55H+4g9/4vbHx1I54fS0XuclLhDHArPQCiMjDxjaL8fPxhw==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=0.12"
+      },
+      "funding": {
+        "url": "https://github.com/fb55/entities?sponsor=1"
+      }
+    },
+    "node_modules/es-module-lexer": {
+      "version": "2.3.2",
+      "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz",
+      "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/escalade": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/escalade/-/escalade-3.2.0.tgz",
+      "integrity": "sha512-WUj2qlxaQtO4g6Pq5c29GTcWGDyd8itL8zTlipgECz3JesAiiOKotd8JU6otB3PACgG6xkJUyVhboMS+bje/jA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz",
+      "integrity": "sha512-vbRorB5FUQWvla16U8R/qgaFIya2qGzwDrNmCZuYKrbdSUMG6I1ZCGQRefkRVhuOkIGVne7BQ35DSfo1qvJqFg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.8.0"
+      }
+    },
+    "node_modules/events": {
+      "version": "3.3.0",
+      "resolved": "https://registry.npmjs.org/events/-/events-3.3.0.tgz",
+      "integrity": "sha512-mQw+2fkQbALzQ7V0MY0IqdnXNOeTtP4r0lN9z7AAawCXgqea7bDii20AYrIBrFd/Hx0M2Ocz6S111CaFkUcb0Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=0.8.x"
+      }
+    },
+    "node_modules/exenv-es6": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/exenv-es6/-/exenv-es6-1.1.1.tgz",
+      "integrity": "sha512-vlVu3N8d6yEMpMsEm+7sUBAI81aqYYuEvfK0jNqmdb/OPXzzH7QWDDnVjMvDSY47JdHEqx/dfC/q8WkfoTmpGQ==",
+      "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+      "license": "MIT"
+    },
+    "node_modules/fast-deep-equal": {
+      "version": "3.1.3",
+      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
+      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
+      "license": "MIT"
+    },
+    "node_modules/fast-uri": {
+      "version": "3.1.8",
+      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.8.tgz",
+      "integrity": "sha512-GZMtZUTNRpOVIECoXwLNZS5xUGE+mVNbTB8h/7Rwh2TFWcBQiPzTgyZi05BF9UMZKkLJv8XBRJTlU7zg8+ZfMg==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fastify"
+        },
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/fastify"
+        }
+      ],
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/find-root": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/find-root/-/find-root-1.1.0.tgz",
+      "integrity": "sha512-NKfW6bec6GfKc0SGx1e07QZY9PE99u0Bft/0rzSD5k3sO/vwkVUpDUKVm5Gpp5Ue3YfShPFTX2070tDs5kB9Ng==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/flat": {
+      "version": "5.0.2",
+      "resolved": "https://registry.npmjs.org/flat/-/flat-5.0.2.tgz",
+      "integrity": "sha512-b6suED+5/3rTpUBdG1gupIl8MPFCAMA0QXwmljLhvCUKcUvdE4gWky9zpuGCcXHOsz4J9wPGNWq6OKpmIzz3hQ==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "bin": {
+        "flat": "cli.js"
+      }
+    },
+    "node_modules/free-style": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/free-style/-/free-style-3.1.0.tgz",
+      "integrity": "sha512-vJujYSIyT30iDoaoeigNAxX4yB1RUrh+N2ZMhIElMr3BvCuGXOw7XNJMEEJkDUeamK2Rnb/IKFGKRKlTWIGRWA==",
+      "license": "MIT"
+    },
+    "node_modules/fs-extra": {
+      "version": "10.1.0",
+      "resolved": "https://registry.npmjs.org/fs-extra/-/fs-extra-10.1.0.tgz",
+      "integrity": "sha512-oRXApq54ETRj4eMiFzGnHWGy+zo5raudjuxN0b8H7s/RU2oW0Wvsx9O0ACRN/kRq9E8Vu/ReskGB5o3ji+FzHQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "graceful-fs": "^4.2.0",
+        "jsonfile": "^6.0.1",
+        "universalify": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/glob": {
+      "version": "13.0.6",
+      "resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
+      "integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "minimatch": "^10.2.2",
+        "minipass": "^7.1.3",
+        "path-scurry": "^2.0.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/graceful-fs": {
+      "version": "4.2.11",
+      "resolved": "https://registry.npmjs.org/graceful-fs/-/graceful-fs-4.2.11.tgz",
+      "integrity": "sha512-RbJ5/jmFcNNCcDV5o9eTnBLJ/HszWV0P73bc+Ff4nS/rJj+YaS6IGyiOL0VoBYX+l1Wrl3k63h/KrH+nhJ0XvQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/htmlparser2": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/htmlparser2/-/htmlparser2-8.0.2.tgz",
+      "integrity": "sha512-GYdjWKDkbRLkZ5geuHs5NY1puJ+PXwP7+fHPRz06Eirsb9ugf6d8kkXav6ADhcODhFFPMIXyxkxSuMf3D6NCFA==",
+      "funding": [
+        "https://github.com/fb55/htmlparser2?sponsor=1",
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/fb55"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "domelementtype": "^2.3.0",
+        "domhandler": "^5.0.3",
+        "domutils": "^3.0.1",
+        "entities": "^4.4.0"
+      }
+    },
+    "node_modules/icss-utils": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/icss-utils/-/icss-utils-5.1.0.tgz",
+      "integrity": "sha512-soFhflCVWLfRNOPU3iv5Z9VUdT44xFRbzjLsEzSr5AQmgqPMTHdU3PMT1Cf1ssx8fLNJDA1juftYl+PUcv3MqA==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^10 || ^12 || >= 14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/is-plain-object": {
+      "version": "5.1.0",
+      "resolved": "https://registry.npmjs.org/is-plain-object/-/is-plain-object-5.1.0.tgz",
+      "integrity": "sha512-bUi/yjmtKYcRVUtWRGr0UA6xEFh2I6zWUwMrUXB3s7bmYCaZ8a+0ZsTRkrawh/mzlSD1Y0Ph8bp/U+TvBpWDNw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/isobject": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/isobject/-/isobject-3.0.1.tgz",
+      "integrity": "sha512-WhB9zCku7EGTj/HQQRz5aUQEUeoQZH2bWcltRErOpymJ4boYE6wL9Tbr23krRPSZ+C5zqNSrSw+Cc7sZZ4b7vg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/isomorphic.js": {
+      "version": "0.2.5",
+      "resolved": "https://registry.npmjs.org/isomorphic.js/-/isomorphic.js-0.2.5.tgz",
+      "integrity": "sha512-PIeMbHqMt4DnUP3MA/Flc0HElYjMXArsw1qwJZcm9sqR8mq3l8NYizFMty0pWwE/tzIGH3EKK5+jes5mAr85yw==",
+      "license": "MIT",
+      "funding": {
+        "type": "GitHub Sponsors ❤",
+        "url": "https://github.com/sponsors/dmonad"
+      }
+    },
+    "node_modules/jest-worker": {
+      "version": "27.5.1",
+      "resolved": "https://registry.npmjs.org/jest-worker/-/jest-worker-27.5.1.tgz",
+      "integrity": "sha512-7vuh85V5cdDofPyxn58nrPjBktZo0u9x1g8WtjQol+jZDaE+fhN+cIvTj11GndBnMnyfrUOG1sZQxCdjKh+DKg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/node": "*",
+        "merge-stream": "^2.0.0",
+        "supports-color": "^8.0.0"
+      },
+      "engines": {
+        "node": ">= 10.13.0"
+      }
+    },
+    "node_modules/jest-worker/node_modules/supports-color": {
+      "version": "8.1.1",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-8.1.1.tgz",
+      "integrity": "sha512-MpUEN2OodtUzxvKQl72cUF7RQ5EiHsGvSsVG0ia9c5RbWGL2CI4C7EpPS8UTBIplnlzZiNuV56w+FuNxy3ty2Q==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/supports-color?sponsor=1"
+      }
+    },
+    "node_modules/js-tokens": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-4.0.0.tgz",
+      "integrity": "sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==",
+      "license": "MIT"
+    },
+    "node_modules/json-schema-compare": {
+      "version": "0.2.2",
+      "resolved": "https://registry.npmjs.org/json-schema-compare/-/json-schema-compare-0.2.2.tgz",
+      "integrity": "sha512-c4WYmDKyJXhs7WWvAWm3uIYnfyWFoIp+JEoX34rctVvEkMYCPGhXtvmFFXiffBbxfZsvQ0RNnV5H7GvDF5HCqQ==",
+      "license": "MIT",
+      "dependencies": {
+        "lodash": "^4.17.4"
+      }
+    },
+    "node_modules/json-schema-merge-allof": {
+      "version": "0.8.1",
+      "resolved": "https://registry.npmjs.org/json-schema-merge-allof/-/json-schema-merge-allof-0.8.1.tgz",
+      "integrity": "sha512-CTUKmIlPJbsWfzRRnOXz+0MjIqvnleIXwFTzz+t9T86HnYX/Rozria6ZVGLktAU9e+NygNljveP+yxqtQp/Q4w==",
+      "license": "MIT",
+      "dependencies": {
+        "compute-lcm": "^1.1.2",
+        "json-schema-compare": "^0.2.2",
+        "lodash": "^4.17.20"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/json-schema-traverse": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
+      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
+      "license": "MIT"
+    },
+    "node_modules/json5": {
+      "version": "2.2.3",
+      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
+      "integrity": "sha512-XmOWe7eyHYH14cLdVPoyg+GOH3rYX++KpzrylJwSW98t3Nk+U8XOl8FWKOgwtzdb8lXGf6zYwDUzeHMWfxasyg==",
+      "license": "MIT",
+      "bin": {
+        "json5": "lib/cli.js"
+      },
+      "engines": {
+        "node": ">=6"
+      }
+    },
+    "node_modules/jsonfile": {
+      "version": "6.2.1",
+      "resolved": "https://registry.npmjs.org/jsonfile/-/jsonfile-6.2.1.tgz",
+      "integrity": "sha512-zwOTdL3rFQ/lRdBnntKVOX6k5cKJwEc1HdilT71BWEu7J41gXIB2MRp+vxduPSwZJPWBxEzv4yH1wYLJGUHX4Q==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "universalify": "^2.0.0"
+      },
+      "optionalDependencies": {
+        "graceful-fs": "^4.1.6"
+      }
+    },
+    "node_modules/jsonpointer": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/jsonpointer/-/jsonpointer-5.0.1.tgz",
+      "integrity": "sha512-p/nXbhSEcu3pZRdkW1OfJhpsVtW1gd4Wa1fnQc9YLiTfAjn0312eMKimbdIQzuZl9aa9xUGaRlP9T/CJE/ditQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/kind-of": {
+      "version": "6.0.3",
+      "resolved": "https://registry.npmjs.org/kind-of/-/kind-of-6.0.3.tgz",
+      "integrity": "sha512-dcS1ul+9tmeD95T+x28/ehLgd9mENa3LsvDTtzm3vyBEO7RPptvAD+t44WVXaUjTBRcrpFeFlC8WCruUR456hw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/lib0": {
+      "version": "0.2.119",
+      "resolved": "https://registry.npmjs.org/lib0/-/lib0-0.2.119.tgz",
+      "integrity": "sha512-vh+TiejVy8Xm+hCdnRfn9BthGNvNUZdEXltNjVZL3TzRIKP3s1lnQh8pWd/Q0wCgY0FPAGVVjFF4ZiHUV3LFgA==",
+      "license": "MIT",
+      "dependencies": {
+        "isomorphic.js": "^0.2.4"
+      },
+      "bin": {
+        "0ecdsa-generate-keypair": "bin/0ecdsa-generate-keypair.js",
+        "0gentesthtml": "bin/gentesthtml.js",
+        "0serve": "bin/0serve.js"
+      },
+      "engines": {
+        "node": ">=16"
+      },
+      "funding": {
+        "type": "GitHub Sponsors ❤",
+        "url": "https://github.com/sponsors/dmonad"
+      }
+    },
+    "node_modules/license-webpack-plugin": {
+      "version": "4.0.2",
+      "resolved": "https://registry.npmjs.org/license-webpack-plugin/-/license-webpack-plugin-4.0.2.tgz",
+      "integrity": "sha512-771TFWFD70G1wLTC4oU2Cw4qvtmNrIw+wRvBtn+okgHl7slJVi7zfNcdmqDL72BojM30VNJ2UHylr1o77U37Jw==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "webpack-sources": "^3.0.0"
+      },
+      "peerDependenciesMeta": {
+        "webpack": {
+          "optional": true
+        },
+        "webpack-sources": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/lodash": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash/-/lodash-4.18.1.tgz",
+      "integrity": "sha512-dMInicTPVE8d1e5otfwmmjlxkZoUpiVLwyeTdUsi/Caj/gfzzblBcCE5sRHV/AsjuCmxWrte2TNGSYuCeCq+0Q==",
+      "license": "MIT"
+    },
+    "node_modules/lodash-es": {
+      "version": "4.18.1",
+      "resolved": "https://registry.npmjs.org/lodash-es/-/lodash-es-4.18.1.tgz",
+      "integrity": "sha512-J8xewKD/Gk22OZbhpOVSwcs60zhd95ESDwezOFuA3/099925PdHJ7OFHNTGtajL3AlZkykD32HykiMo+BIBI8A==",
+      "license": "MIT"
+    },
+    "node_modules/lodash.escape": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/lodash.escape/-/lodash.escape-4.0.1.tgz",
+      "integrity": "sha512-nXEOnb/jK9g0DYMr1/Xvq6l5xMD7GDG55+GSYIYmS0G4tBk/hURD4JR9WCavs04t33WmJx9kCyp9vJ+mr4BOUw==",
+      "license": "MIT"
+    },
+    "node_modules/loose-envify": {
+      "version": "1.4.0",
+      "resolved": "https://registry.npmjs.org/loose-envify/-/loose-envify-1.4.0.tgz",
+      "integrity": "sha512-lyuxPGr/Wfhrlem2CL/UcnUc1zcqKAImBDzukY7Y5F/yQiNdko6+fRLevlw1HgMySw7f611UIY408EtxRSoK3Q==",
+      "license": "MIT",
+      "dependencies": {
+        "js-tokens": "^3.0.0 || ^4.0.0"
+      },
+      "bin": {
+        "loose-envify": "cli.js"
+      }
+    },
+    "node_modules/lru-cache": {
+      "version": "11.5.3",
+      "resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.5.3.tgz",
+      "integrity": "sha512-U4N8FgzmWxc8k1VH8Kr6lQg18U7Fjvby6wXHVRX/ZZ7IwWbRMgrRbP0Wrb5q5NVinryp4SQampHKdvtecItxUg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": "20 || >=22"
+      }
+    },
+    "node_modules/markdown-to-jsx": {
+      "version": "7.7.17",
+      "resolved": "https://registry.npmjs.org/markdown-to-jsx/-/markdown-to-jsx-7.7.17.tgz",
+      "integrity": "sha512-7mG/1feQ0TX5I7YyMZVDgCC/y2I3CiEhIRQIhyov9nGBP5eoVrOXXHuL5ZP8GRfxVZKRiXWJgwXkb9It+nQZfQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10"
+      },
+      "peerDependencies": {
+        "react": ">= 0.14.0"
+      },
+      "peerDependenciesMeta": {
+        "react": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/merge-stream": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/merge-stream/-/merge-stream-2.0.0.tgz",
+      "integrity": "sha512-abv/qOcuPfk3URPfDzmZU1LKmuw8kT+0nIHvKrKgFrwifol/doWcdA4ZqsWQ8ENrFKkd67Mfpo/LovbIUsbt3w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/mime-db": {
+      "version": "1.54.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.54.0.tgz",
+      "integrity": "sha512-aU5EJuIN2WDemCcAp2vFBfp/m4EAhWJnUNSSw0ixs7/kXbd6Pg64EmwJkNdFhB8aWt1sH2CTXrLxo/iAGV3oPQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mini-svg-data-uri": {
+      "version": "1.4.4",
+      "resolved": "https://registry.npmjs.org/mini-svg-data-uri/-/mini-svg-data-uri-1.4.4.tgz",
+      "integrity": "sha512-r9deDe9p5FJUPZAk3A59wGH7Ii9YrjjWw0jmw/liSbHl2CHiyXj6FcDXDu2K3TjVAXqiJdaw3xxwlZZr9E6nHg==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "mini-svg-data-uri": "cli.js"
+      }
+    },
+    "node_modules/minimatch": {
+      "version": "10.2.6",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.6.tgz",
+      "integrity": "sha512-vpLQEs+VLCr1nU0BXS07maYoFwlDAH0gngQuuttxIwutDFEMHq2blX+8vpgxDdK3J1PwjCJiep77OitTZ4Ll1A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "brace-expansion": "^5.0.8"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/minimist": {
+      "version": "1.2.8",
+      "resolved": "https://registry.npmjs.org/minimist/-/minimist-1.2.8.tgz",
+      "integrity": "sha512-2yyAR8qBkN3YuheJanUpWC5U3bb5osDywNB8RzDVlDwDHbocAJveqqj1u8+SVD7jkWT4yvsHCpWqqWqAxb0zCA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/minimizer-webpack-plugin": {
+      "version": "5.13.0",
+      "resolved": "https://registry.npmjs.org/minimizer-webpack-plugin/-/minimizer-webpack-plugin-5.13.0.tgz",
+      "integrity": "sha512-OO1NF2zHj6sf4CNv2AsUWYcS8WEwkVKQDXxxKzlOxx1Xl+WlqYtVC+oNlGNwGkLAOnpj277BSHypWwRtd9w4JQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/trace-mapping": "^0.3.31",
+        "jest-worker": "^27.4.5",
+        "schema-utils": "^4.3.3",
+        "terser": "^5.51.0"
+      },
+      "engines": {
+        "node": ">= 10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^5.1.0"
+      },
+      "peerDependenciesMeta": {
+        "@minify-html/node": {
+          "optional": true
+        },
+        "@napi-rs/image": {
+          "optional": true
+        },
+        "@swc/core": {
+          "optional": true
+        },
+        "@swc/css": {
+          "optional": true
+        },
+        "@swc/html": {
+          "optional": true
+        },
+        "clean-css": {
+          "optional": true
+        },
+        "cssnano": {
+          "optional": true
+        },
+        "csso": {
+          "optional": true
+        },
+        "esbuild": {
+          "optional": true
+        },
+        "html-minifier-terser": {
+          "optional": true
+        },
+        "imagemin": {
+          "optional": true
+        },
+        "lightningcss": {
+          "optional": true
+        },
+        "postcss": {
+          "optional": true
+        },
+        "sharp": {
+          "optional": true
+        },
+        "svgo": {
+          "optional": true
+        },
+        "uglify-js": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/nanoid": {
+      "version": "3.3.20",
+      "resolved": "https://registry.npmjs.org/nanoid/-/nanoid-3.3.20.tgz",
+      "integrity": "sha512-uKdg2G3GNCKQn9byYOpxbGqrT2fGO5KRt5J/8b3pok8rT6qxGWF6hxMyJiEYtAf+FVyYuD9hRaDqX5uPFYJ4ZQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "bin": {
+        "nanoid": "bin/nanoid.cjs"
+      },
+      "engines": {
+        "node": "^10 || ^12 || ^13.7 || ^14 || >=15.0.1"
+      }
+    },
+    "node_modules/node-releases": {
+      "version": "2.0.58",
+      "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.58.tgz",
+      "integrity": "sha512-BdiKAgbfRlvfMq/XzO/AF9NPmaA8a+YpLAyAFTVFBj3gARrAIfWvNq7Q7NE4se3KgFu0KkrvQMxTS0XVnsGzHg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/package-json-from-dist": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/package-json-from-dist/-/package-json-from-dist-1.0.1.tgz",
+      "integrity": "sha512-UEZIS3/by4OC8vL3P2dTXRETpebLI2NiI5vIrjaD/5UtrkFX/tNbwjTSRAGC/+7CAo2pIcBaRgWmcBBHcsaCIw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0"
+    },
+    "node_modules/parse-srcset": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/parse-srcset/-/parse-srcset-1.0.2.tgz",
+      "integrity": "sha512-/2qh0lav6CmI15FzA3i/2Bzk2zCgQhGMkvhOhKNcBVQ1ldgpbfiNTVslmooUmWJcADi1f1kIeynbDRVzNlfR6Q==",
+      "license": "MIT"
+    },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "license": "MIT"
+    },
+    "node_modules/path-scurry": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+      "integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "lru-cache": "^11.0.0",
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": "18 || 20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/picocolors": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
+      "integrity": "sha512-xceH2snhtb5M9liqDsmEw56le376mTZkEX/jEb/RxNFyegNul7eNslCXP9FDj/Lcu0X8KEyMceP2ntpaHrDEVA==",
+      "license": "ISC"
+    },
+    "node_modules/postcss": {
+      "version": "8.5.29",
+      "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.29.tgz",
+      "integrity": "sha512-49cGhUbXj8Qenv0iTMxA1cFBzxXoctpC9Ujd77t1WcbJIr6nF/eI7g/8MgxrYldFRuAXvja7xQRwavoW7kgrxQ==",
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/postcss/"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/postcss"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "dependencies": {
+        "nanoid": "^3.3.19",
+        "picocolors": "^1.1.1",
+        "source-map-js": "^1.2.2"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/postcss-modules-extract-imports": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/postcss-modules-extract-imports/-/postcss-modules-extract-imports-3.1.0.tgz",
+      "integrity": "sha512-k3kNe0aNFQDAZGbin48pL2VNidTF0w4/eASDsxlyspobzU3wZQLOGj7L9gfRe0Jo9/4uud09DsjFNH7winGv8Q==",
+      "dev": true,
+      "license": "ISC",
+      "engines": {
+        "node": "^10 || ^12 || >= 14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/postcss-modules-local-by-default": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-modules-local-by-default/-/postcss-modules-local-by-default-4.2.0.tgz",
+      "integrity": "sha512-5kcJm/zk+GJDSfw+V/42fJ5fhjL5YbFDl8nVdXkJPLLW+Vf9mTD5Xe0wqIaDnLuL2U6cDNpTr+UQ+v2HWIBhzw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "icss-utils": "^5.0.0",
+        "postcss-selector-parser": "^7.0.0",
+        "postcss-value-parser": "^4.1.0"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >= 14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/postcss-modules-scope": {
+      "version": "3.2.1",
+      "resolved": "https://registry.npmjs.org/postcss-modules-scope/-/postcss-modules-scope-3.2.1.tgz",
+      "integrity": "sha512-m9jZstCVaqGjTAuny8MdgE88scJnCiQSlSrOWcTQgM2t32UBe+MUmFSO5t7VMSfAf/FJKImAxBav8ooCHJXCJA==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "postcss-selector-parser": "^7.0.0"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >= 14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/postcss-modules-values": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/postcss-modules-values/-/postcss-modules-values-4.0.0.tgz",
+      "integrity": "sha512-RDxHkAiEGI78gS2ofyvCsu7iycRv7oqw5xMWn9iMoR0N/7mf9D50ecQqUo5BZ9Zh2vH4bCUR/ktCqbB9m8vJjQ==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "icss-utils": "^5.0.0"
+      },
+      "engines": {
+        "node": "^10 || ^12 || >= 14"
+      },
+      "peerDependencies": {
+        "postcss": "^8.1.0"
+      }
+    },
+    "node_modules/postcss-selector-parser": {
+      "version": "7.1.6",
+      "resolved": "https://registry.npmjs.org/postcss-selector-parser/-/postcss-selector-parser-7.1.6.tgz",
+      "integrity": "sha512-7qASPzhKF2l2KLboRZux8CCTRMdGiV08vWmyKzPz22qZ7ZjQBOeY7rNzNoCLSUiftJ7HUq0GERHmxw/t0dCdMw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "cssesc": "^3.0.0",
+        "util-deprecate": "^1.0.2"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/postcss-value-parser": {
+      "version": "4.2.0",
+      "resolved": "https://registry.npmjs.org/postcss-value-parser/-/postcss-value-parser-4.2.0.tgz",
+      "integrity": "sha512-1NNCs6uurfkVbeXG4S8JFT9t19m45ICnif8zWLd5oPSZ50QnwMfK+H3jv408d4jw/7Bttv5axS5IiHoLaVNHeQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/process": {
+      "version": "0.11.10",
+      "resolved": "https://registry.npmjs.org/process/-/process-0.11.10.tgz",
+      "integrity": "sha512-cdGef/drWFoydD1JsMzuFf8100nZl+GT+yacc2bEced5f9Rjk4z+WtFUTBu9PhOi9j/jfmBPu0mMEY4wIdAF8A==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6.0"
+      }
+    },
+    "node_modules/prop-types": {
+      "version": "15.8.1",
+      "resolved": "https://registry.npmjs.org/prop-types/-/prop-types-15.8.1.tgz",
+      "integrity": "sha512-oj87CgZICdulUohogVAR7AjlC0327U4el4L6eAvOqCeudMDVU0NThNaV+b9Df4dXgSP1gXMTnPdhfe/2qDH5cg==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.4.0",
+        "object-assign": "^4.1.1",
+        "react-is": "^16.13.1"
+      }
+    },
+    "node_modules/prop-types/node_modules/react-is": {
+      "version": "16.13.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-16.13.1.tgz",
+      "integrity": "sha512-24e6ynE2H+OKt4kqsOvNd8kBpV65zoxbA4BVsEOB3ARVWQki/DHzaUoC5KuON/BiccDaCCTZBuOcfZs70kR8bQ==",
+      "license": "MIT"
+    },
+    "node_modules/querystringify": {
+      "version": "2.2.0",
+      "resolved": "https://registry.npmjs.org/querystringify/-/querystringify-2.2.0.tgz",
+      "integrity": "sha512-FIqgj2EUvTa7R50u0rGsyTftzjYmv/a3hO345bZNrqabNqjtgiDMgmo4mkUjd+nzU5oF3dClKqFIPUKybUyqoQ==",
+      "license": "MIT"
+    },
+    "node_modules/react": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react/-/react-18.3.1.tgz",
+      "integrity": "sha512-wS+hAgJShR0KhEvPJArfuPVN1+Hz1t0Y6n5jLrGQbkb4urgPE/0Rve+1kMB1v/oWgHgm4WIcV+i7F2pTVj+2iQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/react-dom": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-dom/-/react-dom-18.3.1.tgz",
+      "integrity": "sha512-5m4nQKp+rZRb09LNH59GM4BxTh9251/ylbKIbpe7TpGxfJ+9kv6BLkLBXIjjspbgbnIBNqlI23tRnTWT0snUIw==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0",
+        "scheduler": "^0.23.2"
+      },
+      "peerDependencies": {
+        "react": "^18.3.1"
+      }
+    },
+    "node_modules/react-is": {
+      "version": "18.3.1",
+      "resolved": "https://registry.npmjs.org/react-is/-/react-is-18.3.1.tgz",
+      "integrity": "sha512-/LLMVyas0ljjAtoYiPqYiL8VWXzUUdThrmU5+n20DZv+a+ClRoevUzw5JxU+Ieh5/c87ytoTBV9G1FiKfNJdmg==",
+      "license": "MIT"
+    },
+    "node_modules/require-from-string": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
+      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/requires-port": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/requires-port/-/requires-port-1.0.0.tgz",
+      "integrity": "sha512-KigOCHcocU3XODJxsu8i/j8T9tzT4adHiecwORRQ0ZZFcp7ahwXuRU1m+yuO90C5ZUyGeGfocHDI14M3L3yDAQ==",
+      "license": "MIT"
+    },
+    "node_modules/rimraf": {
+      "version": "6.1.3",
+      "resolved": "https://registry.npmjs.org/rimraf/-/rimraf-6.1.3.tgz",
+      "integrity": "sha512-LKg+Cr2ZF61fkcaK1UdkH2yEBBKnYjTyWzTJT6KNPcSPaiT7HSdhtMXQuN5wkTX0Xu72KQ1l8S42rlmexS2hSA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "glob": "^13.0.3",
+        "package-json-from-dist": "^1.0.1"
+      },
+      "bin": {
+        "rimraf": "dist/esm/bin.mjs"
+      },
+      "engines": {
+        "node": "20 || >=22"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
+    "node_modules/sanitize-html": {
+      "version": "2.12.1",
+      "resolved": "https://registry.npmjs.org/sanitize-html/-/sanitize-html-2.12.1.tgz",
+      "integrity": "sha512-Plh+JAn0UVDpBRP/xEjsk+xDCoOvMBwQUf/K+/cBAVuTbtX8bj2VB7S1sL1dssVpykqp0/KPSesHrqXtokVBpA==",
+      "license": "MIT",
+      "dependencies": {
+        "deepmerge": "^4.2.2",
+        "escape-string-regexp": "^4.0.0",
+        "htmlparser2": "^8.0.0",
+        "is-plain-object": "^5.0.0",
+        "parse-srcset": "^1.0.2",
+        "postcss": "^8.3.11"
+      }
+    },
+    "node_modules/sanitize-html/node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/scheduler": {
+      "version": "0.23.2",
+      "resolved": "https://registry.npmjs.org/scheduler/-/scheduler-0.23.2.tgz",
+      "integrity": "sha512-UOShsPwz7NrMUqhR6t0hWjFduvOzbtv7toDH1/hIrfRNIDBnnBWd0CwJTGvTpngVlmwGCdP9/Zl/tVrDqcuYzQ==",
+      "license": "MIT",
+      "dependencies": {
+        "loose-envify": "^1.1.0"
+      }
+    },
+    "node_modules/schema-utils": {
+      "version": "4.5.0",
+      "resolved": "https://registry.npmjs.org/schema-utils/-/schema-utils-4.5.0.tgz",
+      "integrity": "sha512-zJlMCZ0cAR5p/Y4oVpRoqioDMJcGxaXRrQ/4rP4WyR84vc5z/DolXdbvXeDpTwbtocDFr2rhPqHPErDCUtz2kA==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/json-schema": "^7.0.15",
+        "ajv": "^8.20.0",
+        "ajv-formats": "^3.0.1",
+        "ajv-keywords": "^5.1.0"
+      },
+      "engines": {
+        "node": ">= 10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/shallow-clone": {
+      "version": "3.0.1",
+      "resolved": "https://registry.npmjs.org/shallow-clone/-/shallow-clone-3.0.1.tgz",
+      "integrity": "sha512-/6KqX+GVUdqPuPPd2LxDDxzX6CAbjJehAAOKlNpqqUpAqPM6HeL8f+o3a+JsyGjn2lv0WY8UsTgUJjU9Ok55NA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "kind-of": "^6.0.2"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/source-map": {
+      "version": "0.6.1",
+      "resolved": "https://registry.npmjs.org/source-map/-/source-map-0.6.1.tgz",
+      "integrity": "sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "peer": true,
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-js": {
+      "version": "1.2.2",
+      "resolved": "https://registry.npmjs.org/source-map-js/-/source-map-js-1.2.2.tgz",
+      "integrity": "sha512-KGj/8Y43x35aZVDtt+J4mK1hoLGHULMYfSkODJNQjNDC3oW1PqPoxMwo0pLUsWM/UEGzON/NxeHywEfNXNP3Vw==",
+      "license": "BSD-3-Clause",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/source-map-support": {
+      "version": "0.5.21",
+      "resolved": "https://registry.npmjs.org/source-map-support/-/source-map-support-0.5.21.tgz",
+      "integrity": "sha512-uBHU3L3czsIyYXKX88fdrGovxdSCoTGDRZ6SYXtSRxLZUzHg5P/66Ht6uoUlHu9EZod+inXhKo3qQgwXUT/y1w==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "buffer-from": "^1.0.0",
+        "source-map": "^0.6.0"
+      }
+    },
+    "node_modules/style-loader": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/style-loader/-/style-loader-4.0.0.tgz",
+      "integrity": "sha512-1V4WqhhZZgjVAVJyt7TdDPZoPBPNHbekX4fWnCJL1yQukhCeZhJySUL+gL9y6sNdN95uEOS83Y55SqHcP7MzLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 18.12.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependencies": {
+        "webpack": "^5.27.0"
+      }
+    },
+    "node_modules/style-mod": {
+      "version": "4.1.4",
+      "resolved": "https://registry.npmjs.org/style-mod/-/style-mod-4.1.4.tgz",
+      "integrity": "sha512-XXWIQt633/EpAFx8aZDOTjBzrCaGmhvEQlQo6MVPfa2OzO2cWo+4hV9h+6UkHYlXGfy+ODXKUdP7Pthmcu5ATw==",
+      "license": "MIT"
+    },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/tabbable": {
+      "version": "5.3.3",
+      "resolved": "https://registry.npmjs.org/tabbable/-/tabbable-5.3.3.tgz",
+      "integrity": "sha512-QD9qKY3StfbZqWOPLp0++pOrAVb/HbUi5xCc8cUo4XjP19808oaMiDzn0leBY5mCespIBM0CIZePzZjgzR83kA==",
+      "license": "MIT"
+    },
+    "node_modules/tapable": {
+      "version": "2.3.3",
+      "resolved": "https://registry.npmjs.org/tapable/-/tapable-2.3.3.tgz",
+      "integrity": "sha512-uxc/zpqFg6x7C8vOE7lh6Lbda8eEL9zmVm/PLeTPBRhh1xCgdWaQ+J1CUieGpIfm2HdtsUpRv+HshiasBMcc6A==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "engines": {
+        "node": ">=6"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      }
+    },
+    "node_modules/terser": {
+      "version": "5.51.2",
+      "resolved": "https://registry.npmjs.org/terser/-/terser-5.51.2.tgz",
+      "integrity": "sha512-bWnjSNscmuI+GJze6ZupnHP8G/cTcsJF+bXCeQknk2SHQsgbNJnLrqiH9jZ2W4STPVXH2mDKKRX3iwPhc9Cn/Q==",
+      "dev": true,
+      "license": "BSD-2-Clause",
+      "peer": true,
+      "dependencies": {
+        "@jridgewell/source-map": "^0.3.3",
+        "acorn": "^8.15.0",
+        "commander": "^2.20.0",
+        "source-map-support": "~0.5.20"
+      },
+      "bin": {
+        "terser": "bin/terser"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/terser/node_modules/commander": {
+      "version": "2.20.3",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-2.20.3.tgz",
+      "integrity": "sha512-GpVkmM8vF2vQUkj2LvZmD35JxeJOLCwJ9cUkugyk2nuhbv3+mJvpLYYt+0+USMxE+oj+ey/lJEnhZw75x/OMcQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true
+    },
+    "node_modules/tslib": {
+      "version": "1.14.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-1.14.1.tgz",
+      "integrity": "sha512-Xni35NKzjgMrwevysHTCArtLDpPvye8zV/0E4EyYn43P7/7qvQwPh9BGkHewbMulVntbigmcT7rdX3BNo9wRJg==",
+      "license": "0BSD"
+    },
+    "node_modules/typescript": {
+      "version": "5.7.3",
+      "resolved": "https://registry.npmjs.org/typescript/-/typescript-5.7.3.tgz",
+      "integrity": "sha512-84MVSjMEHP+FQRPy3pX9sTVV/INIex71s9TL2Gm5FG/WG1SqXeKyZ0k7/blY/4FdOzI12CBy1vGc4og/eus0fw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "bin": {
+        "tsc": "bin/tsc",
+        "tsserver": "bin/tsserver"
+      },
+      "engines": {
+        "node": ">=14.17"
+      }
+    },
+    "node_modules/typestyle": {
+      "version": "2.4.0",
+      "resolved": "https://registry.npmjs.org/typestyle/-/typestyle-2.4.0.tgz",
+      "integrity": "sha512-/d1BL6Qi+YlMLEydnUEB8KL/CAjAN8cyt3/UyGnOyBrWf7bLGcR/6yhmsaUstO2IcYwZfagjE7AIzuI2vUW9mg==",
+      "license": "MIT",
+      "dependencies": {
+        "csstype": "3.0.10",
+        "free-style": "3.1.0"
+      }
+    },
+    "node_modules/typestyle/node_modules/csstype": {
+      "version": "3.0.10",
+      "resolved": "https://registry.npmjs.org/csstype/-/csstype-3.0.10.tgz",
+      "integrity": "sha512-2u44ZG2OcNUO9HDp/Jl8C07x6pU/eTR3ncV91SiK3dhG9TWvRVsCoJw14Ckx5DgWkzGA3waZWO3d7pgqpUI/XA==",
+      "license": "MIT"
+    },
+    "node_modules/undici-types": {
+      "version": "6.21.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/universalify": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/universalify/-/universalify-2.0.1.tgz",
+      "integrity": "sha512-gptHNQghINnc/vTGIk0SOFGFNXw7JVrlRUtConJRlvaw6DuX0wO5Jeko9sWrMBhh+PsYAZ7oXAiOnf/UKogyiw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 10.0.0"
+      }
+    },
+    "node_modules/update-browserslist-db": {
+      "version": "1.3.4",
+      "resolved": "https://registry.npmjs.org/update-browserslist-db/-/update-browserslist-db-1.3.4.tgz",
+      "integrity": "sha512-t8wonIOdQyOjtPd2VktlBu6QjTVTks6v8bSi7kd0r2Vll8TK1JYDZtRRdbmCHOAMphkZgrzK+L+vXK4pyZ8t4A==",
+      "dev": true,
+      "funding": [
+        {
+          "type": "opencollective",
+          "url": "https://opencollective.com/browserslist"
+        },
+        {
+          "type": "tidelift",
+          "url": "https://tidelift.com/funding/github/npm/browserslist"
+        },
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/ai"
+        }
+      ],
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "escalade": "^3.2.0",
+        "picocolors": "^1.1.1"
+      },
+      "bin": {
+        "update-browserslist-db": "cli.js"
+      },
+      "peerDependencies": {
+        "browserslist": ">= 4.21.0"
+      }
+    },
+    "node_modules/url-parse": {
+      "version": "1.5.10",
+      "resolved": "https://registry.npmjs.org/url-parse/-/url-parse-1.5.10.tgz",
+      "integrity": "sha512-WypcfiRhfeUP9vvF0j6rw0J3hrWrw6iZv3+22h6iRMJ/8z1Tj6XfLP4DsUix5MhMPnXpiHDoKyoZ/bdCkwBCiQ==",
+      "license": "MIT",
+      "dependencies": {
+        "querystringify": "^2.1.1",
+        "requires-port": "^1.0.0"
+      }
+    },
+    "node_modules/util-deprecate": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/util-deprecate/-/util-deprecate-1.0.2.tgz",
+      "integrity": "sha512-EPD5q1uXyFxJpCrLnCc1nHnq3gOa6DZBocAIiI2TaSCA7VCJ1UJDMagCzIkXNsUYfD1daK//LTEQ8xiIbrHtcw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/validate.io-array": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/validate.io-array/-/validate.io-array-1.0.6.tgz",
+      "integrity": "sha512-DeOy7CnPEziggrOO5CZhVKJw6S3Yi7e9e65R1Nl/RTN1vTQKnzjfvks0/8kQ40FP/dsjRAOd4hxmJ7uLa6vxkg==",
+      "license": "MIT"
+    },
+    "node_modules/validate.io-function": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/validate.io-function/-/validate.io-function-1.0.2.tgz",
+      "integrity": "sha512-LlFybRJEriSuBnUhQyG5bwglhh50EpTL2ul23MPIuR1odjO7XaMLFV8vHGwp7AZciFxtYOeiSCT5st+XSPONiQ=="
+    },
+    "node_modules/validate.io-integer": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/validate.io-integer/-/validate.io-integer-1.0.5.tgz",
+      "integrity": "sha512-22izsYSLojN/P6bppBqhgUDjCkr5RY2jd+N2a3DCAUey8ydvrZ/OkGvFPR7qfOpwR2LC5p4Ngzxz36g5Vgr/hQ==",
+      "dependencies": {
+        "validate.io-number": "^1.0.3"
+      }
+    },
+    "node_modules/validate.io-integer-array": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/validate.io-integer-array/-/validate.io-integer-array-1.0.0.tgz",
+      "integrity": "sha512-mTrMk/1ytQHtCY0oNO3dztafHYyGU88KL+jRxWuzfOmQb+4qqnWmI+gykvGp8usKZOM0H7keJHEbRaFiYA0VrA==",
+      "dependencies": {
+        "validate.io-array": "^1.0.3",
+        "validate.io-integer": "^1.0.4"
+      }
+    },
+    "node_modules/validate.io-number": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/validate.io-number/-/validate.io-number-1.0.3.tgz",
+      "integrity": "sha512-kRAyotcbNaSYoDnXvb4MHg/0a1egJdLwS6oJ38TJY7aw9n93Fl/3blIXdyYvPOp55CNxywooG/3BcrwNrBpcSg=="
+    },
+    "node_modules/w3c-keyname": {
+      "version": "2.2.8",
+      "resolved": "https://registry.npmjs.org/w3c-keyname/-/w3c-keyname-2.2.8.tgz",
+      "integrity": "sha512-dpojBhNsCNN7T82Tm7k26A6G9ML3NkhDsnw9n/eoxSRlVBB4CEtIQ/KTCLI2Fwf3ataSXRhYFkQi3SlnFwPvPQ==",
+      "license": "MIT"
+    },
+    "node_modules/watchpack": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/watchpack/-/watchpack-2.5.2.tgz",
+      "integrity": "sha512-6i/00NBjP4yGPs+caKSyRfpTF/8Torsu0MOW3mMzIbhgISFder8i7xbqgHlLMwJrdiN8ndBV3UA1/AfzPSr+jg==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "graceful-fs": "^4.1.2"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/webpack": {
+      "version": "5.111.1",
+      "resolved": "https://registry.npmjs.org/webpack/-/webpack-5.111.1.tgz",
+      "integrity": "sha512-cNypaz0RP+S4cvQVi1M/3bRUkvNP0xZpL0TjFx+c6jg64VbxD+2weWDgY9UnjRI6dhZgtaj8DU76GGFcJ79xPQ==",
+      "dev": true,
+      "license": "MIT",
+      "peer": true,
+      "dependencies": {
+        "@types/estree": "^1.0.8",
+        "@types/json-schema": "^7.0.15",
+        "@webassemblyjs/ast": "^1.14.1",
+        "@webassemblyjs/wasm-edit": "^1.14.1",
+        "@webassemblyjs/wasm-parser": "^1.14.1",
+        "browserslist": "^4.28.1",
+        "chrome-trace-event": "^1.0.2",
+        "enhanced-resolve": "^5.25.0",
+        "es-module-lexer": "^2.1.0",
+        "events": "^3.2.0",
+        "graceful-fs": "^4.2.11",
+        "mime-db": "^1.54.0",
+        "minimizer-webpack-plugin": "^5.7.0",
+        "schema-utils": "^4.5.0",
+        "tapable": "^2.3.0",
+        "watchpack": "^2.5.2",
+        "webpack-sources": "^3.5.1"
+      },
+      "bin": {
+        "webpack": "bin/webpack.js"
+      },
+      "engines": {
+        "node": ">=10.13.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/webpack"
+      },
+      "peerDependenciesMeta": {
+        "webpack-cli": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/webpack-merge": {
+      "version": "5.10.0",
+      "resolved": "https://registry.npmjs.org/webpack-merge/-/webpack-merge-5.10.0.tgz",
+      "integrity": "sha512-+4zXKdx7UnO+1jaN4l2lHVD+mFvnlZQP/6ljaJVb4SZiwIKeUnrT5l0gkT8z+n4hKpC+jpOv6O9R+gLtag7pSA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "clone-deep": "^4.0.1",
+        "flat": "^5.0.2",
+        "wildcard": "^2.0.0"
+      },
+      "engines": {
+        "node": ">=10.0.0"
+      }
+    },
+    "node_modules/webpack-sources": {
+      "version": "3.6.0",
+      "resolved": "https://registry.npmjs.org/webpack-sources/-/webpack-sources-3.6.0.tgz",
+      "integrity": "sha512-EIMmPVvNI0CYXyRPp34F2Qk7W37/BZVZIofS6LAUnrNjCVahS+hO4mxwFJDjQjODTGZDtVzLYoN2+1dYkhk9qA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.13.0"
+      }
+    },
+    "node_modules/wildcard": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/wildcard/-/wildcard-2.0.1.tgz",
+      "integrity": "sha512-CC1bOL87PIWSBhDcTrdeLo6eGT7mCFtrg0uIJtqJUFyK+eJnzl8A1niH56uu7KMa5XFrtiV+AQuHO3n7DsHnLQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/ws": {
+      "version": "8.22.0",
+      "resolved": "https://registry.npmjs.org/ws/-/ws-8.22.0.tgz",
+      "integrity": "sha512-Ydggc987+RO0AnWtZ/7Wq9FtNvcrL1b/RO0ud9mWjUPgDrsAAwQSF51sm2hm1XofbU/4jkpGEsLFsZZxU+1DOg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=10.0.0"
+      },
+      "peerDependencies": {
+        "bufferutil": "^4.0.1",
+        "utf-8-validate": ">=5.0.2"
+      },
+      "peerDependenciesMeta": {
+        "bufferutil": {
+          "optional": true
+        },
+        "utf-8-validate": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/y-protocols": {
+      "version": "1.0.7",
+      "resolved": "https://registry.npmjs.org/y-protocols/-/y-protocols-1.0.7.tgz",
+      "integrity": "sha512-YSVsLoXxO67J6eE/nV4AtFtT3QEotZf5sK5BHxFBXso7VDUT3Tx07IfA6hsu5Q5OmBdMkQVmFZ9QOA7fikWvnw==",
+      "license": "MIT",
+      "dependencies": {
+        "lib0": "^0.2.85"
+      },
+      "engines": {
+        "node": ">=16.0.0",
+        "npm": ">=8.0.0"
+      },
+      "funding": {
+        "type": "GitHub Sponsors ❤",
+        "url": "https://github.com/sponsors/dmonad"
+      },
+      "peerDependencies": {
+        "yjs": "^13.0.0"
+      }
+    },
+    "node_modules/yjs": {
+      "version": "13.6.33",
+      "resolved": "https://registry.npmjs.org/yjs/-/yjs-13.6.33.tgz",
+      "integrity": "sha512-q/UYvr1gOk4XII+Cu1CW2dINjYqJJFifTzogEaIARznrvX7uOlHsdTEXcnOBMuIsrCGEEKdNxi74kyMLZlKVfw==",
+      "license": "MIT",
+      "dependencies": {
+        "lib0": "^0.2.99"
+      },
+      "engines": {
+        "node": ">=16.0.0",
+        "npm": ">=8.0.0"
+      },
+      "funding": {
+        "type": "GitHub Sponsors ❤",
+        "url": "https://github.com/sponsors/dmonad"
+      }
+    }
+  }
+}
diff --git a/editors/jupyterlab/package.json b/editors/jupyterlab/package.json
new file mode 100644
index 0000000000..93d453c4e5
--- /dev/null
+++ b/editors/jupyterlab/package.json
@@ -0,0 +1,55 @@
+{
+  "name": "jupyterlab-opensysml",
+  "version": "0.10.0",
+  "description": "SysML v2 and KerML syntax highlighting for JupyterLab and Notebook, matching the OpenSysML sysml kernel.",
+  "keywords": [
+    "jupyter",
+    "jupyterlab",
+    "jupyterlab-extension",
+    "sysml",
+    "kerml"
+  ],
+  "homepage": "https://github.com/Open-MBEE/OpenSysML",
+  "bugs": {
+    "url": "https://github.com/Open-MBEE/OpenSysML/issues"
+  },
+  "license": "Apache-2.0",
+  "author": {
+    "name": "Open-MBEE"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Open-MBEE/OpenSysML.git",
+    "directory": "editors/jupyterlab"
+  },
+  "private": true,
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "files": [
+    "lib/**/*.{js,d.ts,json}"
+  ],
+  "scripts": {
+    "build": "npm run build:lib && npm run build:labextension",
+    "build:lib": "tsc -p tsconfig.json",
+    "build:labextension": "jupyter labextension build .",
+    "clean": "rimraf lib out tsconfig.tsbuildinfo tsconfig.test.tsbuildinfo ../../client/jupyter-kernel/labextension",
+    "test": "tsc -p tsconfig.test.json && node --test out/test/*.test.js"
+  },
+  "dependencies": {
+    "@codemirror/language": "^6.0.0",
+    "@codemirror/state": "^6.0.0",
+    "@jupyterlab/application": "^4.0.0",
+    "@jupyterlab/codemirror": "^4.0.0"
+  },
+  "devDependencies": {
+    "@jupyter/builder": "^1.2.3",
+    "@jupyterlab/core-meta": "~4.6.4",
+    "@types/node": "^22.0.0",
+    "rimraf": "^6.0.0",
+    "typescript": "~5.7.3"
+  },
+  "jupyterlab": {
+    "extension": true,
+    "outputDir": "../../client/jupyter-kernel/labextension"
+  }
+}
diff --git a/editors/jupyterlab/src/index.ts b/editors/jupyterlab/src/index.ts
new file mode 100644
index 0000000000..b47f258e7e
--- /dev/null
+++ b/editors/jupyterlab/src/index.ts
@@ -0,0 +1,35 @@
+import { JupyterFrontEnd, JupyterFrontEndPlugin } from '@jupyterlab/application';
+import { IEditorLanguageRegistry } from '@jupyterlab/codemirror';
+import { LanguageSupport, StreamLanguage } from '@codemirror/language';
+
+import { kerml, sysml } from './sysml';
+
+/**
+ * Registers the sysml and kerml CodeMirror languages, under the names, MIME
+ * types and file extensions the sysml kernel's language_info reports, so
+ * notebook cells, .sysml/.kerml files and ```sysml Markdown blocks are highlighted.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: 'jupyterlab-opensysml:languages',
+  description: 'SysML v2 and KerML syntax highlighting.',
+  autoStart: true,
+  requires: [IEditorLanguageRegistry],
+  activate: (_app: JupyterFrontEnd, languages: IEditorLanguageRegistry): void => {
+    languages.addLanguage({
+      name: 'sysml',
+      displayName: 'SysML v2',
+      mime: 'text/x-sysml',
+      extensions: ['sysml'],
+      support: new LanguageSupport(StreamLanguage.define(sysml))
+    });
+    languages.addLanguage({
+      name: 'kerml',
+      displayName: 'KerML',
+      mime: 'text/x-kerml',
+      extensions: ['kerml'],
+      support: new LanguageSupport(StreamLanguage.define(kerml))
+    });
+  }
+};
+
+export default plugin;
diff --git a/editors/jupyterlab/src/syntax.json b/editors/jupyterlab/src/syntax.json
new file mode 100644
index 0000000000..80c4aa9648
--- /dev/null
+++ b/editors/jupyterlab/src/syntax.json
@@ -0,0 +1,222 @@
+{
+  "comment": "Generated by editors/vscode/tools/gengrammar from internal/syntax/source.Keywords() and lexer.ContextualWords(); do not edit by hand.",
+  "keywords": {
+    "control": [
+      "accept",
+      "after",
+      "assert",
+      "assign",
+      "at",
+      "decide",
+      "do",
+      "else",
+      "entry",
+      "exhibit",
+      "exit",
+      "first",
+      "for",
+      "fork",
+      "if",
+      "include",
+      "join",
+      "loop",
+      "merge",
+      "parallel",
+      "perform",
+      "render",
+      "require",
+      "return",
+      "satisfy",
+      "send",
+      "succession",
+      "terminate",
+      "then",
+      "to",
+      "transition",
+      "until",
+      "via",
+      "when",
+      "while"
+    ],
+    "declaration": [
+      "action",
+      "allocation",
+      "analysis",
+      "assoc",
+      "attribute",
+      "behavior",
+      "binding",
+      "calc",
+      "case",
+      "class",
+      "classifier",
+      "comment",
+      "concern",
+      "connection",
+      "connector",
+      "constraint",
+      "datatype",
+      "def",
+      "dependency",
+      "doc",
+      "enum",
+      "event",
+      "expr",
+      "feature",
+      "flow",
+      "function",
+      "interaction",
+      "interface",
+      "item",
+      "language",
+      "metaclass",
+      "metadata",
+      "multiplicity",
+      "namespace",
+      "occurrence",
+      "package",
+      "part",
+      "port",
+      "predicate",
+      "rendering",
+      "rep",
+      "requirement",
+      "state",
+      "step",
+      "struct",
+      "type",
+      "verification",
+      "view",
+      "viewpoint"
+    ],
+    "modifier": [
+      "abstract",
+      "all",
+      "composite",
+      "const",
+      "constant",
+      "default",
+      "derived",
+      "end",
+      "in",
+      "individual",
+      "inout",
+      "library",
+      "member",
+      "new",
+      "nonunique",
+      "ordered",
+      "out",
+      "portion",
+      "private",
+      "protected",
+      "public",
+      "ref",
+      "snapshot",
+      "standard",
+      "timeslice",
+      "variant",
+      "variation"
+    ],
+    "operator": [
+      "and",
+      "as",
+      "chains",
+      "defined",
+      "hastype",
+      "implies",
+      "istype",
+      "meta",
+      "not",
+      "or",
+      "xor"
+    ],
+    "other": [
+      "about",
+      "actor",
+      "allocate",
+      "assume",
+      "bind",
+      "bool",
+      "by",
+      "connect",
+      "expose",
+      "filter",
+      "frame",
+      "from",
+      "inv",
+      "locale",
+      "message",
+      "objective",
+      "of",
+      "stakeholder",
+      "subject",
+      "use",
+      "verify"
+    ],
+    "relationship": [
+      "alias",
+      "conjugate",
+      "conjugates",
+      "conjugation",
+      "crosses",
+      "differences",
+      "disjoining",
+      "disjoint",
+      "featured",
+      "featuring",
+      "import",
+      "inverse",
+      "inverting",
+      "intersects",
+      "redefines",
+      "redefinition",
+      "references",
+      "specialization",
+      "specializes",
+      "subclassifier",
+      "subset",
+      "subsets",
+      "subtype",
+      "typed",
+      "typing",
+      "unions"
+    ]
+  },
+  "constants": [
+    "false",
+    "null",
+    "true"
+  ],
+  "contextual": {
+    "kerml": [
+      "chain",
+      "choice",
+      "deep",
+      "done",
+      "history",
+      "junction",
+      "shallow",
+      "var"
+    ],
+    "sysml": [
+      "chain",
+      "choice",
+      "deep",
+      "done",
+      "history",
+      "junction",
+      "shallow"
+    ]
+  },
+  "operators": [
+    ":>>",
+    "::>",
+    ":>",
+    "=>",
+    "->",
+    "..",
+    "**"
+  ],
+  "operatorChars": "=+\\-*/<>!&|^~?@"
+}
diff --git a/editors/jupyterlab/src/sysml.ts b/editors/jupyterlab/src/sysml.ts
new file mode 100644
index 0000000000..2989b5de10
--- /dev/null
+++ b/editors/jupyterlab/src/sysml.ts
@@ -0,0 +1,169 @@
+import { StreamParser, StringStream } from '@codemirror/language';
+
+import table from './syntax.json';
+
+/** Which of the two languages a parser reads; KerML has a few more contextual words. */
+export type Kind = 'sysml' | 'kerml';
+
+/** The tokenizer's state between lines: an open block comment or an awaited annotation body. */
+export interface State {
+  /** Inside a `/* ... *\/` block: the token it produces, or null when not in one. */
+  block: 'comment' | 'docComment' | null;
+  /** A `doc` or `comment` keyword has been read and its body is still to come. */
+  expectBody: boolean;
+  /** No token has been produced yet on the current line. */
+  lineStart: boolean;
+}
+
+/** The CodeMirror highlighting tag each generated keyword group takes. */
+const groupTokens: Record<string, string> = {
+  declaration: 'definitionKeyword',
+  control: 'controlKeyword',
+  modifier: 'modifier',
+  relationship: 'keyword',
+  operator: 'operatorKeyword',
+  other: 'keyword'
+};
+
+function keywordTokens(kind: Kind): Map<string, string> {
+  const tokens = new Map<string, string>();
+  for (const [group, words] of Object.entries(table.keywords)) {
+    const token = groupTokens[group];
+    if (token === undefined) {
+      throw new Error(`syntax.json has a keyword group ${group} the tokenizer does not know`);
+    }
+    for (const word of words) {
+      tokens.set(word, token);
+    }
+  }
+  for (const word of table.constants) {
+    tokens.set(word, word === 'null' ? 'null' : 'bool');
+  }
+  for (const word of table.contextual[kind]) {
+    tokens.set(word, 'keyword');
+  }
+  return tokens;
+}
+
+const operators = table.operators.map(escapeRegExp).join('|');
+const operatorPattern = new RegExp(`^(?:${operators}|[${escapeRegExp(table.operatorChars)}])`);
+const metaCommandPattern = /^%[A-Za-z][\w-]*/;
+const identifierPattern = /^[A-Za-z_][A-Za-z0-9_]*/;
+const numberPattern = /^(?:\d+\.\d+(?:[eE][+-]?\d+)?|\d+[eE][+-]?\d+|\d+)/;
+const qualifierPattern = /^\s*::(?!>)/;
+const punctuationPattern = /^[;,.:{}()\[\]#]/;
+
+function escapeRegExp(text: string): string {
+  return text.replace(/[.*+?^${}()|[\]\\\-]/g, '\\$&');
+}
+
+function readBlock(stream: StringStream, state: State): string {
+  const token = state.block as string;
+  while (!stream.eol()) {
+    if (stream.match('*/')) {
+      state.block = null;
+      return token;
+    }
+    stream.next();
+  }
+  return token;
+}
+
+function readString(stream: StringStream, quote: string): void {
+  while (!stream.eol()) {
+    const ch = stream.next();
+    if (ch === '\\') {
+      stream.next();
+    } else if (ch === quote) {
+      return;
+    }
+  }
+}
+
+/** A name qualifying what follows `::` takes the special-name tag; themes color it, unlike `namespace`. */
+function nameToken(stream: StringStream): string {
+  return stream.match(qualifierPattern, false) ? 'variableName.special' : 'variableName';
+}
+
+/** A CodeMirror stream parser for SysML v2 or KerML text. */
+export function parser(kind: Kind): StreamParser<State> {
+  const keywords = keywordTokens(kind);
+  return {
+    name: kind,
+    startState: () => ({ block: null, expectBody: false, lineStart: true }),
+    copyState: (state) => ({ ...state }),
+    token(stream, state) {
+      if (stream.sol()) {
+        state.lineStart = true;
+      }
+      if (state.block !== null) {
+        state.lineStart = false;
+        return readBlock(stream, state);
+      }
+      if (stream.eatSpace()) {
+        return null;
+      }
+      const lineStart = state.lineStart;
+      state.lineStart = false;
+      if (lineStart && stream.match(metaCommandPattern)) {
+        return 'meta';
+      }
+      if (stream.match('//*')) {
+        state.block = 'comment';
+        return readBlock(stream, state);
+      }
+      if (stream.match('//')) {
+        stream.skipToEnd();
+        return 'comment';
+      }
+      if (stream.match('/*')) {
+        state.block = state.expectBody ? 'docComment' : 'comment';
+        state.expectBody = false;
+        return readBlock(stream, state);
+      }
+      if (stream.match('"')) {
+        readString(stream, '"');
+        return 'string';
+      }
+      if (stream.match("'")) {
+        readString(stream, "'");
+        return nameToken(stream);
+      }
+      if (stream.match(numberPattern)) {
+        return 'number';
+      }
+      const word = stream.match(identifierPattern);
+      if (word) {
+        const text = (word as RegExpMatchArray)[0];
+        const token = keywords.get(text);
+        if (token === undefined) {
+          return nameToken(stream);
+        }
+        if (text === 'doc' || text === 'comment') {
+          state.expectBody = true;
+        }
+        return token;
+      }
+      if (stream.match(operatorPattern) || stream.match('::')) {
+        return stream.current() === '::' ? 'punctuation' : 'operator';
+      }
+      const punctuation = stream.match(punctuationPattern);
+      if (punctuation) {
+        const text = (punctuation as RegExpMatchArray)[0];
+        if (text === ';' || text === '{' || text === '}') {
+          state.expectBody = false;
+        }
+        return 'punctuation';
+      }
+      stream.next();
+      return null;
+    },
+    languageData: {
+      commentTokens: { line: '//', block: { open: '/*', close: '*/' } },
+      closeBrackets: { brackets: ['(', '[', '{', "'", '"'] }
+    }
+  };
+}
+
+export const sysml = parser('sysml');
+export const kerml = parser('kerml');
diff --git a/editors/jupyterlab/test/sysml.test.ts b/editors/jupyterlab/test/sysml.test.ts
new file mode 100644
index 0000000000..bdf687ee41
--- /dev/null
+++ b/editors/jupyterlab/test/sysml.test.ts
@@ -0,0 +1,241 @@
+import assert from 'node:assert/strict';
+import { test } from 'node:test';
+
+import { StreamLanguage, StringStream } from '@codemirror/language';
+import { EditorState } from '@codemirror/state';
+
+import { kerml, parser, State, sysml } from '../src/sysml';
+import table from '../src/syntax.json';
+
+type Token = [string, string | null];
+
+/** Tokenizes text the way the editor does: line by line, carrying the state across lines. */
+function tokenize(language: typeof sysml, text: string): Token[] {
+  const tokens: Token[] = [];
+  const state: State = language.startState!(2);
+  for (const line of text.split('\n')) {
+    const stream = new StringStream(line, 2, 2);
+    if (line === '') {
+      language.blankLine?.(state, 2);
+      continue;
+    }
+    while (!stream.eol()) {
+      const token = language.token(stream, state);
+      const text = stream.current();
+      if (text.trim() !== '') {
+        tokens.push([text, token]);
+      }
+      stream.start = stream.pos;
+    }
+  }
+  return tokens;
+}
+
+test('keywords take the generated group tags', () => {
+  const tokens = tokenize(sysml, 'part def Vehicle :> Base { attribute mass : Real = 1.5; }');
+  assert.deepEqual(tokens, [
+    ['part', 'definitionKeyword'],
+    ['def', 'definitionKeyword'],
+    ['Vehicle', 'variableName'],
+    [':>', 'operator'],
+    ['Base', 'variableName'],
+    ['{', 'punctuation'],
+    ['attribute', 'definitionKeyword'],
+    ['mass', 'variableName'],
+    [':', 'punctuation'],
+    ['Real', 'variableName'],
+    ['=', 'operator'],
+    ['1.5', 'number'],
+    [';', 'punctuation'],
+    ['}', 'punctuation']
+  ]);
+});
+
+test('every keyword of the table is a keyword token in both languages', () => {
+  const groups = Object.values(table.keywords).flat();
+  assert.ok(groups.length > 100, `only ${groups.length} keywords`);
+  for (const language of [sysml, kerml]) {
+    for (const word of groups) {
+      const [[, token]] = tokenize(language, word);
+      assert.ok((token ?? '').toLowerCase().includes('keyword') || token === 'modifier', `${word}: ${token}`);
+    }
+    for (const word of table.constants) {
+      const [[, token]] = tokenize(language, word);
+      assert.ok(token === 'bool' || token === 'null', `${word}: ${token}`);
+    }
+  }
+});
+
+test('contextual words follow the language', () => {
+  for (const word of table.contextual.sysml) {
+    assert.deepEqual(tokenize(sysml, word), [[word, 'keyword']]);
+  }
+  assert.deepEqual(tokenize(kerml, 'var'), [['var', 'keyword']]);
+  assert.deepEqual(tokenize(sysml, 'var'), [['var', 'variableName']]);
+  assert.ok(!table.contextual.sysml.includes('var'));
+});
+
+test('an identifier that merely starts with a keyword is a name', () => {
+  assert.deepEqual(tokenize(sysml, 'partial parts'), [
+    ['partial', 'variableName'],
+    ['parts', 'variableName']
+  ]);
+});
+
+test('line and block comments, across lines', () => {
+  assert.deepEqual(tokenize(sysml, 'part p; // trailing\n/* a\nb */ part q;'), [
+    ['part', 'definitionKeyword'],
+    ['p', 'variableName'],
+    [';', 'punctuation'],
+    ['// trailing', 'comment'],
+    ['/* a', 'comment'],
+    ['b */', 'comment'],
+    ['part', 'definitionKeyword'],
+    ['q', 'variableName'],
+    [';', 'punctuation']
+  ]);
+});
+
+test('a //* note is a comment until */, however many lines it spans', () => {
+  assert.deepEqual(tokenize(sysml, '//* note\npart def Vehicle;\n*/ part p; //*/ still a note'), [
+    ['//* note', 'comment'],
+    ['part def Vehicle;', 'comment'],
+    ['*/', 'comment'],
+    ['part', 'definitionKeyword'],
+    ['p', 'variableName'],
+    [';', 'punctuation'],
+    ['//*/ still a note', 'comment']
+  ]);
+});
+
+test('doc and comment bodies are documentation, not comments', () => {
+  assert.deepEqual(tokenize(sysml, 'doc /* The vehicle. */'), [
+    ['doc', 'definitionKeyword'],
+    ['/* The vehicle. */', 'docComment']
+  ]);
+  assert.deepEqual(tokenize(sysml, "comment Note about Vehicle locale \"en\"\n/* Multi\nline */"), [
+    ['comment', 'definitionKeyword'],
+    ['Note', 'variableName'],
+    ['about', 'keyword'],
+    ['Vehicle', 'variableName'],
+    ['locale', 'keyword'],
+    ['"en"', 'string'],
+    ['/* Multi', 'docComment'],
+    ['line */', 'docComment']
+  ]);
+  assert.deepEqual(tokenize(sysml, 'doc; /* plain */'), [
+    ['doc', 'definitionKeyword'],
+    [';', 'punctuation'],
+    ['/* plain */', 'comment']
+  ]);
+});
+
+test('strings keep their escapes', () => {
+  assert.deepEqual(tokenize(sysml, 'attribute s = "say \\"hi\\" \\\\";'), [
+    ['attribute', 'definitionKeyword'],
+    ['s', 'variableName'],
+    ['=', 'operator'],
+    ['"say \\"hi\\" \\\\"', 'string'],
+    [';', 'punctuation']
+  ]);
+});
+
+test('numbers', () => {
+  for (const literal of ['0', '42', '3.14', '1e10', '2.5E-3']) {
+    assert.deepEqual(tokenize(sysml, literal), [[literal, 'number']]);
+  }
+  assert.deepEqual(tokenize(sysml, '1..3'), [
+    ['1', 'number'],
+    ['..', 'operator'],
+    ['3', 'number']
+  ]);
+});
+
+test('unrestricted and qualified names', () => {
+  assert.deepEqual(tokenize(sysml, "part 'Front Wheel' : Wheels::'Road Wheel';"), [
+    ['part', 'definitionKeyword'],
+    ["'Front Wheel'", 'variableName'],
+    [':', 'punctuation'],
+    ['Wheels', 'variableName.special'],
+    ['::', 'punctuation'],
+    ["'Road Wheel'", 'variableName'],
+    [';', 'punctuation']
+  ]);
+  assert.deepEqual(tokenize(sysml, 'import ISQ::*; import A::B::**;'), [
+    ['import', 'keyword'],
+    ['ISQ', 'variableName.special'],
+    ['::', 'punctuation'],
+    ['*', 'operator'],
+    [';', 'punctuation'],
+    ['import', 'keyword'],
+    ['A', 'variableName.special'],
+    ['::', 'punctuation'],
+    ['B', 'variableName.special'],
+    ['::', 'punctuation'],
+    ['**', 'operator'],
+    [';', 'punctuation']
+  ]);
+});
+
+test('operators and punctuation', () => {
+  assert.deepEqual(tokenize(sysml, 'ref :>> x = a -> select { in y; y > 0 } ::> b; #m @M;'), [
+    ['ref', 'modifier'],
+    [':>>', 'operator'],
+    ['x', 'variableName'],
+    ['=', 'operator'],
+    ['a', 'variableName'],
+    ['->', 'operator'],
+    ['select', 'variableName'],
+    ['{', 'punctuation'],
+    ['in', 'modifier'],
+    ['y', 'variableName'],
+    [';', 'punctuation'],
+    ['y', 'variableName'],
+    ['>', 'operator'],
+    ['0', 'number'],
+    ['}', 'punctuation'],
+    ['::>', 'operator'],
+    ['b', 'variableName'],
+    [';', 'punctuation'],
+    ['#', 'punctuation'],
+    ['m', 'variableName'],
+    ['@', 'operator'],
+    ['M', 'variableName'],
+    [';', 'punctuation']
+  ]);
+  for (const op of table.operators) {
+    assert.deepEqual(tokenize(sysml, op), [[op, 'operator']], op);
+  }
+});
+
+test('kernel meta-commands are the first token of a line', () => {
+  assert.deepEqual(tokenize(sysml, '%help\n  %show Vehicle\npart p; %eval 1'), [
+    ['%help', 'meta'],
+    ['%show', 'meta'],
+    ['Vehicle', 'variableName'],
+    ['part', 'definitionKeyword'],
+    ['p', 'variableName'],
+    [';', 'punctuation'],
+    ['%', null],
+    ['eval', 'variableName'],
+    ['1', 'number']
+  ]);
+  assert.deepEqual(tokenize(sysml, '%'), [['%', null]]);
+  assert.deepEqual(tokenize(sysml, '/* note\nend */ %help\n%help'), [
+    ['/* note', 'comment'],
+    ['end */', 'comment'],
+    ['%', null],
+    ['help', 'variableName'],
+    ['%help', 'meta']
+  ]);
+});
+
+test('the parsers define languages whose comment tokens the editor can read', () => {
+  for (const kind of ['sysml', 'kerml'] as const) {
+    const language = StreamLanguage.define(parser(kind));
+    assert.equal(language.name, kind);
+    const state = EditorState.create({ doc: 'part def P { attribute a : Real; }', extensions: [language] });
+    assert.deepEqual(state.languageDataAt('commentTokens', 0), [{ line: '//', block: { open: '/*', close: '*/' } }]);
+    assert.equal(language.parser.parse(state.doc.toString()).length, state.doc.length);
+  }
+});
diff --git a/editors/jupyterlab/tsconfig.json b/editors/jupyterlab/tsconfig.json
new file mode 100644
index 0000000000..a407c5a4eb
--- /dev/null
+++ b/editors/jupyterlab/tsconfig.json
@@ -0,0 +1,21 @@
+{
+  "compilerOptions": {
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "target": "ES2018",
+    "lib": ["ES2018", "DOM"],
+    "outDir": "lib",
+    "rootDir": "src",
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "types": []
+  },
+  "include": ["src/**/*.ts", "src/**/*.json"]
+}
diff --git a/editors/jupyterlab/tsconfig.test.json b/editors/jupyterlab/tsconfig.test.json
new file mode 100644
index 0000000000..fa3e6cce9d
--- /dev/null
+++ b/editors/jupyterlab/tsconfig.test.json
@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "out",
+    "rootDir": ".",
+    "declaration": false,
+    "sourceMap": false,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts", "src/**/*.json", "test/**/*.ts"]
+}
diff --git a/editors/vscode/syntaxes/kerml.tmLanguage.json b/editors/vscode/syntaxes/kerml.tmLanguage.json
index f13936e843..a7273e8371 100644
--- a/editors/vscode/syntaxes/kerml.tmLanguage.json
+++ b/editors/vscode/syntaxes/kerml.tmLanguage.json
@@ -59,6 +59,11 @@
   "repository": {
     "comments": {
       "patterns": [
+        {
+          "name": "comment.block.note.source.kerml",
+          "begin": "//\\*",
+          "end": "\\*/"
+        },
         {
           "name": "comment.line.double-slash.source.kerml",
           "match": "//.*$"
diff --git a/editors/vscode/syntaxes/sysml.tmLanguage.json b/editors/vscode/syntaxes/sysml.tmLanguage.json
index 2a548280cf..ed6f50f82d 100644
--- a/editors/vscode/syntaxes/sysml.tmLanguage.json
+++ b/editors/vscode/syntaxes/sysml.tmLanguage.json
@@ -59,6 +59,11 @@
   "repository": {
     "comments": {
       "patterns": [
+        {
+          "name": "comment.block.note.source.sysml",
+          "begin": "//\\*",
+          "end": "\\*/"
+        },
         {
           "name": "comment.line.double-slash.source.sysml",
           "match": "//.*$"
diff --git a/editors/vscode/tools/gengrammar/codemirror.go b/editors/vscode/tools/gengrammar/codemirror.go
new file mode 100644
index 0000000000..63b45ac427
--- /dev/null
+++ b/editors/vscode/tools/gengrammar/codemirror.go
@@ -0,0 +1,95 @@
+package main
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/lexer"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+)
+
+// SyntaxTableFile is where the JupyterLab extension's CodeMirror language reads
+// its keywords, relative to the extension's directory.
+const SyntaxTableFile = "src/syntax.json"
+
+// SyntaxTable is the keyword and operator table the CodeMirror language of
+// editors/jupyterlab consumes: the same groups the TextMate grammars are built
+// from, keyed by the group's short name, so both editors colour one word alike.
+type SyntaxTable struct {
+	Comment       string              `json:"comment"`
+	Keywords      map[string][]string `json:"keywords"`
+	Constants     []string            `json:"constants"`
+	Contextual    map[string][]string `json:"contextual"`
+	Operators     []string            `json:"operators"`
+	OperatorChars string              `json:"operatorChars"`
+}
+
+// syntaxTable builds the table from the keyword groups, after the same checks
+// repository makes: every grouped word is a keyword, none is grouped twice, and
+// no contextual word is reserved.
+func syntaxTable() (*SyntaxTable, error) {
+	known := map[string]bool{}
+	for _, kw := range source.Keywords() {
+		known[kw] = true
+	}
+	table := &SyntaxTable{
+		Comment:       "Generated by editors/vscode/tools/gengrammar from internal/syntax/source.Keywords() and lexer.ContextualWords(); do not edit by hand.",
+		Keywords:      map[string][]string{},
+		Contextual:    map[string][]string{},
+		Operators:     append([]string(nil), multiCharOperators...),
+		OperatorChars: operatorChars,
+	}
+	grouped := map[string]bool{}
+	for _, group := range keywordGroups {
+		words := make([]string, 0, len(group.keywords))
+		for _, kw := range group.keywords {
+			if !known[kw] {
+				return nil, fmt.Errorf("grammar group %q names %q, which the lexer no longer knows", group.rule, kw)
+			}
+			if grouped[kw] {
+				return nil, fmt.Errorf("keyword %q appears in more than one grammar group", kw)
+			}
+			grouped[kw] = true
+			words = append(words, kw)
+		}
+		if group.rule == "constants" {
+			table.Constants = words
+			continue
+		}
+		table.Keywords[strings.TrimPrefix(group.rule, "keywords-")] = words
+	}
+	var rest []string
+	for _, kw := range source.Keywords() {
+		if !grouped[kw] {
+			rest = append(rest, kw)
+		}
+	}
+	table.Keywords["other"] = append([]string{}, rest...)
+	for _, g := range Grammars() {
+		contextual := lexer.ContextualWords(g.Kind)
+		if err := checkUnreserved(contextual, known); err != nil {
+			return nil, err
+		}
+		table.Contextual[g.FileTypes[0]] = contextual
+	}
+	return table, nil
+}
+
+// RenderSyntaxTable returns the JSON text of the CodeMirror syntax table,
+// ending in a newline.
+func RenderSyntaxTable() ([]byte, error) {
+	table, err := syntaxTable()
+	if err != nil {
+		return nil, err
+	}
+	var buf bytes.Buffer
+	enc := json.NewEncoder(&buf)
+	enc.SetIndent("", "  ")
+	enc.SetEscapeHTML(false)
+	if err := enc.Encode(table); err != nil {
+		return nil, err
+	}
+	return buf.Bytes(), nil
+}
diff --git a/editors/vscode/tools/gengrammar/grammar.go b/editors/vscode/tools/gengrammar/grammar.go
index 30cb1e207b..ace7850ec9 100644
--- a/editors/vscode/tools/gengrammar/grammar.go
+++ b/editors/vscode/tools/gengrammar/grammar.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"encoding/json"
 	"fmt"
+	"regexp"
 	"sort"
 	"strings"
 
@@ -224,10 +225,26 @@ func qualifyMap(m map[string]pattern, scopeName string) map[string]pattern {
 
 const identifier = `[A-Za-z_][A-Za-z0-9_]*`
 
+// The operators both editors colour: the multi-character ones, longest first so
+// `:>>` is not read as `:>` then `>`, and the single characters.
+var multiCharOperators = []string{":>>", "::>", ":>", "=>", "->", "..", "**"}
+
+const operatorChars = `=+\-*/<>!&|^~?@`
+
+// operatorPattern is the TextMate regex over the operator tables.
+func operatorPattern() string {
+	quoted := make([]string, 0, len(multiCharOperators))
+	for _, op := range multiCharOperators {
+		quoted = append(quoted, regexp.QuoteMeta(op))
+	}
+	return strings.Join(quoted, "|") + "|[" + operatorChars + "]"
+}
+
 func repository(kind source.Kind) (map[string]pattern, error) {
 	repo := map[string]pattern{
 		"comments": {
 			Patterns: []pattern{
+				{Name: "comment.block.note", Begin: `//\*`, End: `\*/`},
 				{Name: "comment.line.double-slash", Match: `//.*$`},
 				{Name: "comment.block", Begin: `/\*`, End: `\*/`},
 			},
@@ -276,7 +293,7 @@ func repository(kind source.Kind) (map[string]pattern, error) {
 		},
 		"operators": {
 			Name:  "keyword.operator",
-			Match: `:>>|::>|:>|=>|->|\.\.|\*\*|[=+\-*/<>!&|^~?@]`,
+			Match: operatorPattern(),
 		},
 	}
 
diff --git a/editors/vscode/tools/gengrammar/grammar_test.go b/editors/vscode/tools/gengrammar/grammar_test.go
index 76ca994679..ba17cff5db 100644
--- a/editors/vscode/tools/gengrammar/grammar_test.go
+++ b/editors/vscode/tools/gengrammar/grammar_test.go
@@ -170,3 +170,56 @@ func TestScopesAreQualifiedPerLanguage(t *testing.T) {
 		}
 	}
 }
+
+func TestCommittedSyntaxTableIsCurrent(t *testing.T) {
+	want, err := RenderSyntaxTable()
+	if err != nil {
+		t.Fatalf("RenderSyntaxTable() err = %v", err)
+	}
+	path := filepath.Join("..", "..", "..", "jupyterlab", SyntaxTableFile)
+	got, err := os.ReadFile(filepath.Clean(path))
+	if err != nil {
+		t.Fatalf("read %s: %v", path, err)
+	}
+	if string(got) != string(want) {
+		t.Errorf("%s is stale; regenerate it with `make vscode-grammar`", path)
+	}
+}
+
+func TestSyntaxTableCoversEveryKeywordOnce(t *testing.T) {
+	table, err := syntaxTable()
+	if err != nil {
+		t.Fatalf("syntaxTable() err = %v", err)
+	}
+	seen := map[string]string{}
+	note := func(group string, words []string) {
+		for _, w := range words {
+			if prev, dup := seen[w]; dup {
+				t.Errorf("%q is in both %s and %s", w, prev, group)
+			}
+			seen[w] = group
+		}
+	}
+	for group, words := range table.Keywords {
+		note(group, words)
+	}
+	note("constants", table.Constants)
+	for _, kw := range source.Keywords() {
+		if _, ok := seen[kw]; !ok {
+			t.Errorf("keyword %q is missing from the syntax table", kw)
+		}
+	}
+	for kind, words := range table.Contextual {
+		for _, w := range words {
+			if group, reserved := seen[w]; reserved {
+				t.Errorf("contextual %s word %q is also in group %s", kind, w, group)
+			}
+		}
+	}
+	if len(table.Contextual["kerml"]) <= len(table.Contextual["sysml"]) {
+		t.Errorf("kerml contextual words %v should extend sysml's %v", table.Contextual["kerml"], table.Contextual["sysml"])
+	}
+	if len(table.Operators) == 0 || table.OperatorChars == "" {
+		t.Error("operator tables are empty")
+	}
+}
diff --git a/editors/vscode/tools/gengrammar/main.go b/editors/vscode/tools/gengrammar/main.go
index d3a00e649c..5ceb250469 100644
--- a/editors/vscode/tools/gengrammar/main.go
+++ b/editors/vscode/tools/gengrammar/main.go
@@ -1,5 +1,6 @@
-// Command gengrammar writes the VS Code extension's TextMate grammars from
-// the lexer's keyword list, so highlighting cannot drift from the language.
+// Command gengrammar writes the VS Code extension's TextMate grammars and the
+// JupyterLab extension's CodeMirror syntax table from the lexer's keyword list,
+// so highlighting cannot drift from the language.
 package main
 
 import (
@@ -11,6 +12,7 @@ import (
 
 func main() {
 	dir := flag.String("out", ".", "directory to write the grammar files into")
+	table := flag.String("codemirror-out", "", "file to write the CodeMirror syntax table into (none when empty)")
 	flag.Parse()
 
 	for _, g := range Grammars() {
@@ -26,4 +28,17 @@ func main() {
 		}
 		fmt.Printf("wrote %s\n", path)
 	}
+	if *table == "" {
+		return
+	}
+	data, err := RenderSyntaxTable()
+	if err != nil {
+		fmt.Fprintf(os.Stderr, "gengrammar: %v\n", err)
+		os.Exit(1)
+	}
+	if err := os.WriteFile(*table, data, 0o600); err != nil {
+		fmt.Fprintf(os.Stderr, "gengrammar: %v\n", err)
+		os.Exit(1)
+	}
+	fmt.Printf("wrote %s\n", *table)
 }
diff --git a/internal/doc/docrender/artwork.go b/internal/doc/docrender/artwork.go
index 37e46ebca6..042bd3e82e 100644
--- a/internal/doc/docrender/artwork.go
+++ b/internal/doc/docrender/artwork.go
@@ -137,7 +137,7 @@ func Diagrams(document *docir.Document, opts DiagramOptions) ([]Diagram, error)
 			if rendering.Kind.Tabular() {
 				continue
 			}
-			if !rendering.Kind.Supported() {
+			if !rendering.Kind.GraphShaped() {
 				return &Error{Kind: ErrorUnrenderableDiagram, Content: node.Name(), Actual: string(rendering.Kind)}
 			}
 			form, fallback := opts.formFor(rendering)
diff --git a/internal/exec/runtime/action_control_objects.go b/internal/exec/runtime/action_control_objects.go
index 1797694c8c..097949987b 100644
--- a/internal/exec/runtime/action_control_objects.go
+++ b/internal/exec/runtime/action_control_objects.go
@@ -134,7 +134,7 @@ func arrivingObject(frame *actionFrame, graph *lower.ActionGraph, node ast.Node,
 func (e *performances) queueControlObject(frame *actionFrame, graph *lower.ActionGraph, flow lower.ObjectFlow, value Value) error {
 	for _, f := range graph.Features[flow.Target] {
 		if f.Name == flow.TargetPin && f.Direction == ast.DirIn {
-			if err := e.ctx.checkNamedWrite(graph.Scopes[flow.Target], nodeDescription(flow.Target), f.Name, &value); err != nil {
+			if err := e.ctx.checkNamedWriteAs(graph.Scopes[flow.Target], func() string { return nodeDescription(flow.Target) }, f.Name, &value); err != nil {
 				return fmt.Errorf("%s: %w", flowDescription(flow), err)
 			}
 			frame.hold(flow.Target, f.Name, nodeObject{value: value, flow: flow.Decl, carried: flow.Kind == lower.FlowSuccession})
diff --git a/internal/exec/runtime/action_executor.go b/internal/exec/runtime/action_executor.go
index a6d92c2fb3..55dfcbd49c 100644
--- a/internal/exec/runtime/action_executor.go
+++ b/internal/exec/runtime/action_executor.go
@@ -1537,7 +1537,7 @@ func (e *ActionExecutor) setFeature(name string, value Value) error {
 		if value, err = e.mirrorOccurrence(name, value); err != nil {
 			return err
 		}
-	} else if err := e.ctx.checkNamedWrite(e.graph.Scope, actionLabelPrefix+symbolText(e.action), name, &value); err != nil {
+	} else if err := e.ctx.checkNamedWriteAs(e.graph.Scope, func() string { return actionLabelPrefix + symbolText(e.action) }, name, &value); err != nil {
 		// No occurrence holds this feature, so its declaration is checked here
 		// rather than by the write to that occurrence.
 		return err
diff --git a/internal/exec/runtime/action_frame.go b/internal/exec/runtime/action_frame.go
index d52fd2307d..42e4d9d7d8 100644
--- a/internal/exec/runtime/action_frame.go
+++ b/internal/exec/runtime/action_frame.go
@@ -422,7 +422,7 @@ func (e *performances) seedPerformance(parent *actionFrame, flow *lower.ActionGr
 			continue
 		}
 		check := func(value *Value) error {
-			return e.ctx.checkBodyDeclaration(feature.Scope, perf.describe(), feature.Name, value)
+			return e.ctx.checkBodyDeclarationAs(feature.Scope, perf.describe, feature.Name, value)
 		}
 		context := func(scope *symbols.Scope) *EvalContext {
 			return e.evalBindingContext(perf, scope, feature.Name, activation)
@@ -497,7 +497,7 @@ func (e *performances) seedDeclaredValues(perf *actionFrame, features []lower.Fe
 		if feature.Binding {
 			cells := e.bodyCells(perf)
 			check := func(value *Value) error {
-				return e.ctx.checkBodyDeclaration(feature.Scope, perf.describe(), feature.Name, value)
+				return e.ctx.checkBodyDeclarationAs(feature.Scope, perf.describe, feature.Name, value)
 			}
 			name := perf.key(feature.Name)
 			cell := cells.existingCell(name)
@@ -514,7 +514,7 @@ func (e *performances) seedDeclaredValues(perf *actionFrame, features []lower.Fe
 		} else {
 			value, err = ec.Eval(feature.Value)
 			if err == nil {
-				err = e.ctx.checkBodyDeclaration(feature.Scope, perf.describe(), feature.Name, &value)
+				err = e.ctx.checkBodyDeclarationAs(feature.Scope, perf.describe, feature.Name, &value)
 			}
 			if err == nil {
 				e.ctx.writeBodyValue(perf.cells, perf.data, perf.key(feature.Name), value)
@@ -894,7 +894,7 @@ func (e *performances) deliver(f *actionFrame, flow *lower.ActionGraph, node ast
 	if !pins.declares(pin) {
 		return fmt.Errorf("%w: %s declares no %s", ErrNodePin, nodeDescription(node), pin)
 	}
-	if err := e.ctx.checkNamedWrite(flow.Scopes[node], nodeDescription(node), pin, &value); err != nil {
+	if err := e.ctx.checkNamedWriteAs(flow.Scopes[node], func() string { return nodeDescription(node) }, pin, &value); err != nil {
 		return err
 	}
 	f.queue(node, canonical(pins.aliases, pin), value)
@@ -952,7 +952,7 @@ func (e *performances) checkNestedDelivery(flow *lower.ActionGraph, node ast.Nod
 	if !pins.declares(pin) {
 		return fmt.Errorf("%w: %s declares no %s", ErrNodePin, nodeDescription(node), pin)
 	}
-	return e.ctx.checkNamedWrite(flow.Scopes[node], nodeDescription(node), pin, value)
+	return e.ctx.checkNamedWriteAs(flow.Scopes[node], func() string { return nodeDescription(node) }, pin, value)
 }
 
 // takeDeliveries moves the oldest delivery at each pin of node into perf, so that
@@ -1035,7 +1035,7 @@ func (e *performances) setFrameFeature(f *actionFrame, name string, value Value)
 		e.noteFrameWrite(f, name, value)
 		return nil
 	}
-	if err := e.ctx.checkNamedWrite(f.scope, f.describe(), name, &value); err != nil {
+	if err := e.ctx.checkNamedWriteAs(f.scope, f.describe, name, &value); err != nil {
 		return err
 	}
 	e.ctx.writeBodyValue(f.cells, f.data, f.key(name), value)
@@ -1101,7 +1101,7 @@ func (e *performances) streamFlow(
 		if !pins.declares(flow.TargetPin) {
 			return fmt.Errorf("%s: %w: %s declares no %s", flowDescription(flow), ErrNodePin, nodeDescription(flow.Target), flow.TargetPin)
 		}
-		if err := e.ctx.checkNamedWrite(graph.Scopes[flow.Target], nodeDescription(flow.Target), flow.TargetPin, &value); err != nil {
+		if err := e.ctx.checkNamedWriteAs(graph.Scopes[flow.Target], func() string { return nodeDescription(flow.Target) }, flow.TargetPin, &value); err != nil {
 			return fmt.Errorf("%s: %w", flowDescription(flow), err)
 		}
 		pin := canonical(pins.aliases, flow.TargetPin)
diff --git a/internal/exec/runtime/compile.go b/internal/exec/runtime/compile.go
index 4a98ac4a80..864cfa6fbc 100644
--- a/internal/exec/runtime/compile.go
+++ b/internal/exec/runtime/compile.go
@@ -107,21 +107,46 @@ type scalarCheck struct {
 	holdsReal bool
 	// least is the smallest integer a Natural-holding declaration takes: 1 for Positive.
 	least int64
+	// plain has bit 1<<kind set for each constant kind the declaration holds
+	// whatever the value, decided once so accepts answers them with one test.
+	plain uint8
+}
+
+// settle decides plain from the lattice answers.
+func (c *scalarCheck) settle() {
+	c.plain = 0
+	if !c.countOK {
+		return
+	}
+	if c.integerOK {
+		c.plain |= 1 << semantics.ValInt
+	}
+	if c.boolOK {
+		c.plain |= 1 << semantics.ValBool
+	}
+	if c.rationalOK {
+		c.plain |= 1 << semantics.ValRational
+	}
 }
 
 // accepts reports whether the declaration surely holds v, deciding on the
 // scalar lattice alone; a value it declines is left to refuse.
 func (c *scalarCheck) accepts(v scalar) bool {
+	return c.plain&(1<<v.Kind) != 0 || c.acceptsByValue(v)
+}
+
+// acceptsByValue is accepts for the kinds plain does not settle.
+func (c *scalarCheck) acceptsByValue(v scalar) bool {
 	if !c.countOK {
 		return false
 	}
-	switch v.kind {
-	case scalarInt:
-		if v.big != nil {
-			return c.integerOK || (c.naturalOK && v.big.Sign() > 0)
+	switch v.Kind {
+	case semantics.ValInt:
+		if i, ok := v.smallInt(); ok {
+			return c.integerOK || (c.naturalOK && i >= c.least)
 		}
-		return c.integerOK || (c.naturalOK && v.int() >= c.least)
-	case scalarBool:
+		return c.integerOK || (c.naturalOK && v.Unpack().BigIntView().Sign() > 0)
+	case semantics.ValBool:
 		return c.boolOK
 	}
 	return c.acceptsReal(v)
@@ -138,15 +163,21 @@ func (c *scalarCheck) acceptsReal(v scalar) bool {
 	return false
 }
 
+// holds reports whether the declaration takes v as it is, so held has nothing to do.
+func (c *scalarCheck) holds(v scalar) bool {
+	return !c.holdsReal || v.Kind != semantics.ValRational
+}
+
 // held is v as the declaration holds it: a Rational a Real declaration takes as its
 // nearest binary64, refused when no finite Real is; what, if any, names the declaration.
 func (c *scalarCheck) held(v scalar, what func() string) (scalar, error) {
-	if !c.holdsReal || v.kind != scalarRational {
+	if c.holds(v) {
 		return v, nil
 	}
-	real, err := semantics.RealOf(v.exact)
+	exact := v.Unpack()
+	real, err := semantics.RealOf(exact)
 	if err != nil {
-		err = fmt.Errorf("%s as a Real: %w", v.exact.FormatRational(), err)
+		err = fmt.Errorf("%s as a Real: %w", exact.FormatRational(), err)
 		if what != nil {
 			err = fmt.Errorf("%s: %w", what(), err)
 		}
@@ -388,11 +419,13 @@ func (c *calcCompiler) scalarCheckFor(decl *calcMemberDecl) (scalarCheck, bool)
 	check := scalarCheck{decl: decl, countOK: true,
 		boolOK: true, naturalOK: true, integerOK: true, rationalOK: true, realOK: true}
 	if decl.Target == nil {
+		check.settle()
 		return check, true
 	}
 	one := Value{Kind: ValConst}
 	check.countOK = c.ctx.writeCountRefusal(decl.Target, &one) == ""
 	if decl.Target.typ == nil {
+		check.settle()
 		return check, true
 	}
 	if decl.Target.typ.Kind == symbols.SymbolEnumerationDef {
@@ -412,6 +445,7 @@ func (c *calcCompiler) scalarCheckFor(decl *calcMemberDecl) (scalarCheck, bool)
 	if c.ctx.positiveScalar(decl.Target.typ) {
 		check.least = 1
 	}
+	check.settle()
 	return check, true
 }
 
@@ -810,26 +844,19 @@ func (c *compiledCalc) invoke(ctx *Context, base int, bound paramSet) (scalar, e
 	for i := range c.params {
 		p := &c.params[i]
 		v := frame[i]
-		source := "argument"
-		if !bound.has(i) {
+		defaulted := !bound.has(i)
+		if defaulted {
 			var err error
 			if v, err = p.dflt(ctx, frame); err != nil {
 				ctx.leaveCalc()
 				return scalar{}, calcDefaultError(c.kind, c.name, p.name, err)
 			}
-			source = "default"
 			frame[i] = v
 		}
-		what := func() string {
-			return fmt.Sprintf("%s %s: %s for parameter %q", c.kind, c.name, source, p.name)
-		}
-		if !p.check.accepts(v) {
-			if err := p.check.refuse(ctx, v, what); err != nil {
-				ctx.leaveCalc()
-				return scalar{}, err
-			}
+		if p.check.accepts(v) && p.check.holds(v) {
+			continue
 		}
-		held, err := p.check.held(v, what)
+		held, err := c.holdParam(ctx, p, v, defaulted)
 		if err != nil {
 			ctx.leaveCalc()
 			return scalar{}, err
@@ -841,7 +868,7 @@ func (c *compiledCalc) invoke(ctx *Context, base int, bound paramSet) (scalar, e
 	if err != nil {
 		return scalar{}, calcFrame(c.kind, c.name, fmt.Errorf("%s%w", c.bodyErr, err))
 	}
-	if c.result != nil {
+	if c.result != nil && !(c.result.accepts(result) && c.result.holds(result)) {
 		what := func() string { return c.resultWhat }
 		if !c.result.accepts(result) {
 			if err := c.result.refuse(ctx, result, what); err != nil {
@@ -855,6 +882,24 @@ func (c *compiledCalc) invoke(ctx *Context, base int, bound paramSet) (scalar, e
 	return result, nil
 }
 
+// holdParam settles a parameter value its check did not take as it is: the
+// reference's verdict on a value accepts declined, then the declaration's hold.
+func (c *compiledCalc) holdParam(ctx *Context, p *compiledParam, v scalar, defaulted bool) (scalar, error) {
+	source := "argument"
+	if defaulted {
+		source = "default"
+	}
+	what := func() string {
+		return fmt.Sprintf("%s %s: %s for parameter %q", c.kind, c.name, source, p.name)
+	}
+	if !p.check.accepts(v) {
+		if err := p.check.refuse(ctx, v, what); err != nil {
+			return scalar{}, err
+		}
+	}
+	return p.check.held(v, what)
+}
+
 // frameAt extends the scalar stack to hold a frame of size slots at base; the
 // local slots are written by their declarations before any read.
 func (ctx *Context) frameAt(base, size int) []scalar {
diff --git a/internal/exec/runtime/compiled_ops.go b/internal/exec/runtime/compiled_ops.go
index 291b7f11f3..d0f417fbbd 100644
--- a/internal/exec/runtime/compiled_ops.go
+++ b/internal/exec/runtime/compiled_ops.go
@@ -3,93 +3,60 @@ package runtime
 import (
 	"fmt"
 	"math"
-	"math/big"
 	"slices"
 
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/ast"
 )
 
-// scalar is an unboxed Integer, Rational, Real or Boolean, the values the
-// compiled calc tier computes over; it is boxed into a Value only at an
-// invocation boundary. An Integer beyond int64 is held in big, immutable, with
-// bits zero; a Rational is held exactly in exact.
-type scalar struct {
-	kind  scalarKind
-	bits  uint64
-	big   *big.Int
-	exact semantics.Value
-}
-
-type scalarKind uint8
-
-const (
-	scalarInt scalarKind = iota
-	scalarReal
-	scalarBool
-	scalarRational
-)
+// scalar is an Integer, Rational, Real or Boolean constant packed into three
+// words, the value the compiled calc tier passes between nodes and holds in frames.
+type scalar struct{ semantics.Packed }
 
 // #nosec G115 -- the Integer's two's-complement bits are stored, not its magnitude.
-func intScalar(i int64) scalar { return scalar{kind: scalarInt, bits: uint64(i)} }
+func intScalar(i int64) scalar {
+	return scalar{semantics.Packed{Kind: semantics.ValInt, Bits: uint64(i)}}
+}
 
-func realScalar(f float64) scalar { return scalar{kind: scalarReal, bits: math.Float64bits(f)} }
+func realScalar(f float64) scalar {
+	return scalar{semantics.Packed{Kind: semantics.ValReal, Bits: math.Float64bits(f)}}
+}
 
 func boolScalar(b bool) scalar {
 	if b {
-		return scalar{kind: scalarBool, bits: 1}
+		return scalar{semantics.Packed{Kind: semantics.ValBool, Bits: 1}}
 	}
-	return scalar{kind: scalarBool, bits: 0}
+	return scalar{semantics.Packed{Kind: semantics.ValBool}}
 }
 
 // #nosec G115 -- the inverse of intScalar: the same bits read back as an Integer.
-func (s scalar) int() int64 { return int64(s.bits) }
+func (s scalar) int() int64 { return int64(s.Bits) }
 
-func (s scalar) real() float64 { return math.Float64frombits(s.bits) }
+func (s scalar) truth() bool { return s.Bits != 0 }
 
-func (s scalar) truth() bool { return s.bits != 0 }
+// smallInt answers s as an int64 when it is an Integer within int64.
+func (s scalar) smallInt() (int64, bool) {
+	return s.int(), s.Kind == semantics.ValInt && s.Ext == nil
+}
 
-// smallInts reports whether l and r are both Integers within int64.
-func smallInts(l, r scalar) bool {
-	return l.kind == scalarInt && r.kind == scalarInt && l.big == nil && r.big == nil
+// smallInts answers l and r as int64 when both are Integers within int64.
+func smallInts(l, r scalar) (a, b int64, ok bool) {
+	return l.int(), r.int(), l.Kind == semantics.ValInt && r.Kind == semantics.ValInt && l.Ext == nil && r.Ext == nil
 }
 
 // semantic is the constant the scalar stands for.
-func (s scalar) semantic() semantics.Value {
-	switch s.kind {
-	case scalarInt:
-		if s.big != nil {
-			return semantics.BigIntValue(s.big)
-		}
-		return semantics.IntValue(s.int())
-	case scalarReal:
-		return semantics.Value{Kind: semantics.ValReal, Real: s.real()}
-	case scalarRational:
-		return s.exact
-	default:
-		return semantics.Value{Kind: semantics.ValBool, Bool: s.truth()}
-	}
-}
+func (s scalar) semantic() semantics.Value { return s.Unpack() }
 
 // boxed is the scalar as the evaluator's Value.
 func (s scalar) boxed() Value {
-	return Value{Kind: ValConst, Const: s.semantic()}
+	return Value{Kind: ValConst, Const: s.Unpack()}
 }
 
 // scalarOfConst unboxes a scalar constant, declining any other constant kind.
 func scalarOfConst(c semantics.Value) (scalar, bool) {
 	switch c.Kind {
-	case semantics.ValInt:
-		if i, ok := c.Int64(); ok {
-			return intScalar(i), true
-		}
-		return scalar{kind: scalarInt, big: c.BigIntView()}, true
-	case semantics.ValReal:
-		return realScalar(c.Real), true
-	case semantics.ValRational:
-		return scalar{kind: scalarRational, exact: c}, true
-	case semantics.ValBool:
-		return boolScalar(c.Bool), true
+	case semantics.ValInt, semantics.ValReal, semantics.ValRational, semantics.ValBool:
+		return scalar{c.Pack()}, true
 	}
 	return scalar{}, false
 }
@@ -110,16 +77,24 @@ type compiledExpr func(ctx *Context, args []scalar) (scalar, error)
 // which can fail. It leaves the counter where the evaluator's would stop.
 func (ctx *Context) chargeSteps(n int64) error {
 	if n > ctx.maxSteps-ctx.run.steps {
-		ctx.run.steps = ctx.maxSteps
-		if ctx.run.steps < math.MaxInt64 {
-			ctx.run.steps++
-		}
-		return ctx.stepLimitExceeded()
+		return ctx.stepsExhausted()
 	}
 	ctx.run.steps += n
 	return nil
 }
 
+// stepsExhausted is the refusal of a charge the budget cannot meet, kept out
+// of line so chargeSteps inlines into every compiled node.
+//
+//go:noinline
+func (ctx *Context) stepsExhausted() error {
+	ctx.run.steps = ctx.maxSteps
+	if ctx.run.steps < math.MaxInt64 {
+		ctx.run.steps++
+	}
+	return ctx.stepLimitExceeded()
+}
+
 // binaryOp combines two evaluated operands.
 type binaryOp func(ctx *Context, l, r scalar) (scalar, error)
 
@@ -136,8 +111,7 @@ func arithmeticOp(op ast.OperatorKind) binaryOp {
 }
 
 func addScalars(ctx *Context, l, r scalar) (scalar, error) {
-	if smallInts(l, r) {
-		a, b := l.int(), r.int()
+	if a, b, ok := smallInts(l, r); ok {
 		if res := a + b; (b <= 0 || res > a) && (b >= 0 || res < a) {
 			return intScalar(res), nil
 		}
@@ -146,8 +120,7 @@ func addScalars(ctx *Context, l, r scalar) (scalar, error) {
 }
 
 func subScalars(ctx *Context, l, r scalar) (scalar, error) {
-	if smallInts(l, r) {
-		a, b := l.int(), r.int()
+	if a, b, ok := smallInts(l, r); ok {
 		if res := a - b; (b >= 0 || res > a) && (b <= 0 || res < a) {
 			return intScalar(res), nil
 		}
@@ -181,29 +154,29 @@ func comparisonOp(op ast.OperatorKind) binaryOp {
 	switch op {
 	case ast.OpLt:
 		return func(_ *Context, l, r scalar) (scalar, error) {
-			if smallInts(l, r) {
-				return boolScalar(l.int() < r.int()), nil
+			if a, b, ok := smallInts(l, r); ok {
+				return boolScalar(a < b), nil
 			}
 			return compareScalars(op, l, r)
 		}
 	case ast.OpLe:
 		return func(_ *Context, l, r scalar) (scalar, error) {
-			if smallInts(l, r) {
-				return boolScalar(l.int() <= r.int()), nil
+			if a, b, ok := smallInts(l, r); ok {
+				return boolScalar(a <= b), nil
 			}
 			return compareScalars(op, l, r)
 		}
 	case ast.OpGt:
 		return func(_ *Context, l, r scalar) (scalar, error) {
-			if smallInts(l, r) {
-				return boolScalar(l.int() > r.int()), nil
+			if a, b, ok := smallInts(l, r); ok {
+				return boolScalar(a > b), nil
 			}
 			return compareScalars(op, l, r)
 		}
 	case ast.OpGe:
 		return func(_ *Context, l, r scalar) (scalar, error) {
-			if smallInts(l, r) {
-				return boolScalar(l.int() >= r.int()), nil
+			if a, b, ok := smallInts(l, r); ok {
+				return boolScalar(a >= b), nil
 			}
 			return compareScalars(op, l, r)
 		}
@@ -242,7 +215,7 @@ func unaryScalar(op ast.OperatorKind, v scalar) (scalar, error) {
 // scalarTruth reads a Boolean operand, reporting any other scalar as the
 // evaluator's boolOperand does.
 func scalarTruth(what string, v scalar) (bool, error) {
-	if v.kind != scalarBool {
+	if v.Kind != semantics.ValBool {
 		return boolOperand(what, v.boxed())
 	}
 	return v.truth(), nil
diff --git a/internal/exec/runtime/compiled_stmts.go b/internal/exec/runtime/compiled_stmts.go
index 0ebf833bae..51ff74d420 100644
--- a/internal/exec/runtime/compiled_stmts.go
+++ b/internal/exec/runtime/compiled_stmts.go
@@ -4,6 +4,7 @@ import (
 	"fmt"
 
 	"github.com/Open-MBEE/OpenSysML/internal/ir/lower"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/semantics"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/ast"
 )
@@ -228,8 +229,10 @@ func declareStmt(s lower.Declare, slot int, value compiledExpr, check *scalarChe
 					return scalar{}, false, err
 				}
 			}
-			if v, err = check.held(v, nil); err != nil {
-				return scalar{}, false, err
+			if !check.holds(v) {
+				if v, err = check.held(v, nil); err != nil {
+					return scalar{}, false, err
+				}
 			}
 		}
 		frame[slot] = v
@@ -245,7 +248,7 @@ func returnStmt(value compiledExpr, result *scalarCheck) compiledStmt {
 		if err != nil {
 			return scalar{}, false, fmt.Errorf("evaluating the returned expression: %w", err)
 		}
-		if result != nil {
+		if result != nil && !(result.accepts(v) && result.holds(v)) {
 			what := func() string { return "result" }
 			if !result.accepts(v) {
 				if err := result.refuse(ctx, v, what); err != nil {
@@ -268,7 +271,7 @@ func ifStmt(cond compiledExpr, then, els compiledStmt) compiledStmt {
 		if err != nil {
 			return scalar{}, false, fmt.Errorf("eval condition of 'if': %w", err)
 		}
-		if cv.kind != scalarBool {
+		if cv.Kind != semantics.ValBool {
 			return scalar{}, false, fmt.Errorf("%s: condition of 'if' must evaluate to a Boolean, got %s",
 				calcBodyDescription, ValConst)
 		}
diff --git a/internal/exec/runtime/context.go b/internal/exec/runtime/context.go
index 909bb16ad6..b028d53019 100644
--- a/internal/exec/runtime/context.go
+++ b/internal/exec/runtime/context.go
@@ -303,6 +303,10 @@ type Context struct {
 	// quiescent is the memo a full scan leaves when it finds them all idle.
 	work      uint64
 	quiescent quiescence
+	// held counts the behaviors that entered held on a succession; noneHeld is
+	// the memo the cycle check leaves when it finds none held at that count.
+	held     uint64
+	noneHeld noneHeldMemo
 	// onStack lists the runs of the executors whose calls are under way, outermost first.
 	onStack []*executorRun
 
diff --git a/internal/exec/runtime/held_image_behavior.go b/internal/exec/runtime/held_image_behavior.go
index 6377ff78bc..51a159558a 100644
--- a/internal/exec/runtime/held_image_behavior.go
+++ b/internal/exec/runtime/held_image_behavior.go
@@ -833,7 +833,7 @@ func (m *materializing) frameCells(
 			continue
 		}
 		check := func(value *Value) error {
-			return m.dst.checkBodyDeclaration(state.scope, perf.describe(), state.name, value)
+			return m.dst.checkBodyDeclarationAs(state.scope, perf.describe, state.name, value)
 		}
 		var onDerived func(*Value) error
 		if perf.node == nil && perf.parent == nil {
diff --git a/internal/exec/runtime/occurrence_terminate.go b/internal/exec/runtime/occurrence_terminate.go
index ccfcfb9f23..dba75a6835 100644
--- a/internal/exec/runtime/occurrence_terminate.go
+++ b/internal/exec/runtime/occurrence_terminate.go
@@ -110,7 +110,7 @@ func (ctx *Context) noteEndingUndo(b *ObjectBehavior) {
 		captured.captureState(b.State)
 		captured.captureRunState(b.State.driven.state)
 	}
-	ctx.noteProbeUndo(captured.restore)
+	ctx.noteProbeUndo(func() { captured.restore(ctx) })
 }
 
 // endsWith reports whether the executor's performance ends with the objects ended:
diff --git a/internal/exec/runtime/snapshot.go b/internal/exec/runtime/snapshot.go
index 6f05ad23aa..433043d37c 100644
--- a/internal/exec/runtime/snapshot.go
+++ b/internal/exec/runtime/snapshot.go
@@ -219,7 +219,7 @@ func (s *Snapshot) Restore() {
 	ctx.snapshots = ctx.snapshots[:at+1]
 	ctx.rollbackJournal(s.journal)
 	s.run.restore(ctx)
-	s.executorCaptures.restore()
+	s.executorCaptures.restore(ctx)
 }
 
 // captureAction captures an action executor once, with the executors the work of
@@ -267,7 +267,7 @@ func (s *executorCaptures) captureBehavior(behavior *ObjectBehavior) {
 	})
 }
 
-func (s *executorCaptures) restore() {
+func (s *executorCaptures) restore(ctx *Context) {
 	for _, capture := range s.runStates {
 		capture.restore()
 	}
@@ -285,6 +285,9 @@ func (s *executorCaptures) restore() {
 		capture.behavior.State = capture.state
 		capture.behavior.Err = capture.err
 		capture.behavior.deferred = capture.deferred
+		if capture.deferred != nil {
+			ctx.behaviorHeld()
+		}
 	}
 }
 
@@ -1033,5 +1036,5 @@ func (m *moveMark) undo() {
 	m.run.steps, m.run.elements, m.run.notes = m.steps, m.elements, m.notes
 	e.ctx.choices, e.ctx.draws = e.ctx.choices[:m.choices], e.ctx.draws[:m.draws]
 	m.trace.restore(e.ctx.trace)
-	m.state.restore()
+	m.state.restore(e.ctx)
 }
diff --git a/internal/exec/runtime/state_executor.go b/internal/exec/runtime/state_executor.go
index 2f851fcc5b..db4effa1cc 100644
--- a/internal/exec/runtime/state_executor.go
+++ b/internal/exec/runtime/state_executor.go
@@ -639,11 +639,11 @@ func (e *StateExecutor) assignAttribute(name string, value Value) error {
 	} else {
 		// No occurrence holds this feature, so its declaration is checked here
 		// rather than by the write to that occurrence.
-		where := "state machine " + symbolText(e.stateMachine)
-		if err := e.ctx.checkMutable(e.graph.Scope, func() string { return where + ": assignment to " + name }, name); err != nil {
+		where := func() string { return "state machine " + symbolText(e.stateMachine) }
+		if err := e.ctx.checkMutable(e.graph.Scope, func() string { return where() + ": assignment to " + name }, name); err != nil {
 			return err
 		}
-		if err := e.ctx.checkNamedWrite(e.graph.Scope, where, name, &value); err != nil {
+		if err := e.ctx.checkNamedWriteAs(e.graph.Scope, where, name, &value); err != nil {
 			return err
 		}
 	}
diff --git a/internal/exec/runtime/state_statements.go b/internal/exec/runtime/state_statements.go
index 4ba9de1c6e..e4d4cdcedb 100644
--- a/internal/exec/runtime/state_statements.go
+++ b/internal/exec/runtime/state_statements.go
@@ -396,7 +396,7 @@ func (h *stateStmtHost) assignStateAttribute(name string, value Value) (bool, er
 	if !ok {
 		return false, nil
 	}
-	if err := h.exec.ctx.checkNamedWrite(scope, h.describe(), name, &value); err != nil {
+	if err := h.exec.ctx.checkNamedWriteAs(scope, h.describe, name, &value); err != nil {
 		return true, err
 	}
 	h.exec.ctx.writeBodyValue(cells, data, name, value)
@@ -512,7 +512,7 @@ func (h *stateStmtHost) runFlow(block lower.Block) (stmtFlow, error) {
 // the body's flow, else what is around it.
 func (h *stateStmtHost) setFeature(name string, value Value) error {
 	if root := h.perfs.root; root.holds(name) {
-		if err := h.exec.ctx.checkNamedWrite(root.scope, h.describe(), name, &value); err != nil {
+		if err := h.exec.ctx.checkNamedWriteAs(root.scope, h.describe, name, &value); err != nil {
 			return err
 		}
 		h.exec.ctx.writeBodyValue(root.cells, root.data, root.key(name), value)
diff --git a/internal/exec/runtime/statements.go b/internal/exec/runtime/statements.go
index 78fff53a07..1f1d515993 100644
--- a/internal/exec/runtime/statements.go
+++ b/internal/exec/runtime/statements.go
@@ -833,7 +833,7 @@ func (e *stmtEngine) execute(stmt lower.Statement) (stmtFlow, error) {
 		if s.Target == "" {
 			return flowNext, fmt.Errorf("%s: unsupported assignment target", e.host.describe())
 		}
-		if err := e.ctx.checkAssignable(e.host.describe(), s); err != nil {
+		if err := e.ctx.checkAssignable(e.host.describe, s); err != nil {
 			return flowNext, err
 		}
 		value, err := e.evalIn(s.Scope).Eval(s.Value)
@@ -895,7 +895,7 @@ func (e *stmtEngine) execute(stmt lower.Statement) (stmtFlow, error) {
 				cells = e.ensureRootCells()
 			}
 			check := func(value *Value) error {
-				return e.ctx.checkBodyDeclaration(s.Scope, e.host.describe(), name, value)
+				return e.ctx.checkBodyDeclarationAs(s.Scope, e.host.describe, name, value)
 			}
 			bindingContext := e.evalIn(s.Scope)
 			visible := make([]map[string]bool, len(bindingContext.frames))
@@ -930,7 +930,7 @@ func (e *stmtEngine) execute(stmt lower.Statement) (stmtFlow, error) {
 				if err != nil {
 					return flowNext, fmt.Errorf("eval declaration %s: %w", s.Name, err)
 				}
-				if err := e.ctx.checkBodyDeclaration(s.Scope, e.host.describe(), s.Name, &evaluated); err != nil {
+				if err := e.ctx.checkBodyDeclarationAs(s.Scope, e.host.describe, s.Name, &evaluated); err != nil {
 					return flowNext, err
 				}
 				value = evaluated
@@ -945,7 +945,7 @@ func (e *stmtEngine) execute(stmt lower.Statement) (stmtFlow, error) {
 				if err != nil {
 					return flowNext, fmt.Errorf("eval declaration %s: %w", s.Name, err)
 				}
-				if err := e.ctx.checkBodyDeclaration(s.Scope, e.host.describe(), s.Name, &evaluated); err != nil {
+				if err := e.ctx.checkBodyDeclarationAs(s.Scope, e.host.describe, s.Name, &evaluated); err != nil {
 					return flowNext, err
 				}
 				value = evaluated
@@ -958,7 +958,7 @@ func (e *stmtEngine) execute(stmt lower.Statement) (stmtFlow, error) {
 			if err != nil {
 				return flowNext, fmt.Errorf("eval declaration %s: %w", s.Name, err)
 			}
-			if err := e.ctx.checkBodyDeclaration(s.Scope, e.host.describe(), s.Name, &evaluated); err != nil {
+			if err := e.ctx.checkBodyDeclarationAs(s.Scope, e.host.describe, s.Name, &evaluated); err != nil {
 				return flowNext, err
 			}
 			e.env.declare(e.ctx, s.Name, evaluated)
diff --git a/internal/exec/runtime/succession_cycle_memo_test.go b/internal/exec/runtime/succession_cycle_memo_test.go
new file mode 100644
index 0000000000..81c2f7bb5f
--- /dev/null
+++ b/internal/exec/runtime/succession_cycle_memo_test.go
@@ -0,0 +1,86 @@
+package runtime
+
+import (
+	"errors"
+	"testing"
+)
+
+// TestSuccessionCycleMemo: the none-held memo answers the cycle check only while
+// no behavior has entered held; one entering, by instantiation or by a snapshot
+// restore, sends the check back to the walk, whose verdict it must then match.
+func TestSuccessionCycleMemo(t *testing.T) {
+	src := `package test {
+		private import ScalarValues::*;
+		part def Plain {
+			attribute n : Integer = 0;
+			perform action step { assign n := 1; }
+		}
+		part def Ring {
+			perform action a { action stepA; }
+			perform action b { action stepB; }
+			first a then b;
+			first b then a;
+		}
+	}`
+	idx, _, ctx := buildRuntimeWithLibraries(t, "<test>", parseAndBuild(t, src))
+	if _, err := ctx.Instantiate(oneSymbol(t, idx, "test::Plain")); err != nil {
+		t.Fatalf("instantiate Plain: %v", err)
+	}
+	requireSameCycleVerdict(t, ctx)
+	if !ctx.noneHeld.answers(ctx) {
+		t.Fatal("cycle check over no held behavior left no memo")
+	}
+
+	_, cached := ctx.Instantiate(oneSymbol(t, idx, "test::Ring"))
+	requireSuccessionError(t, cached, ErrSuccessionOrderCycle, successionOrderCycleCode)
+	if ctx.noneHeld.answers(ctx) {
+		t.Fatal("memo still answers after behaviors entered held")
+	}
+	requireSameCycleVerdict(t, ctx)
+
+	// The same objects in a context whose check never answered from the memo.
+	freshIdx, _, fresh := buildRuntimeWithLibraries(t, "<test>", parseAndBuild(t, src))
+	if _, err := fresh.Instantiate(oneSymbol(t, freshIdx, "test::Plain")); err != nil {
+		t.Fatalf("instantiate Plain afresh: %v", err)
+	}
+	fresh.noneHeld = noneHeldMemo{}
+	_, uncached := fresh.Instantiate(oneSymbol(t, freshIdx, "test::Ring"))
+	if uncached == nil || uncached.Error() != cached.Error() {
+		t.Fatalf("cycle after memo = %v, want the uncached %v", cached, uncached)
+	}
+
+	timed, inst := instantiateTimedSuccession(t)
+	snapshot, err := timed.Snapshot()
+	if err != nil {
+		t.Fatalf("snapshot: %v", err)
+	}
+	if _, err := timed.Advance(1); err != nil {
+		t.Fatalf("advance clock: %v", err)
+	}
+	if behaviorNamed(t, inst, "later").deferred != nil {
+		t.Fatal("Advance did not release later")
+	}
+	requireSameCycleVerdict(t, timed)
+	if !timed.noneHeld.answers(timed) {
+		t.Fatal("cycle check over released behaviors left no memo")
+	}
+	snapshot.Restore()
+	if behaviorNamed(t, inst, "later").deferred == nil {
+		t.Fatal("restore did not return later to held")
+	}
+	if timed.noneHeld.answers(timed) {
+		t.Fatal("memo still answers after a restore returned a behavior to held")
+	}
+	requireSameCycleVerdict(t, timed)
+}
+
+func requireSameCycleVerdict(t *testing.T, ctx *Context) {
+	t.Helper()
+	got, want := ctx.successionCycle(), ctx.walkSuccessionCycle()
+	if (got == nil) != (want == nil) || (got != nil && got.Error() != want.Error()) {
+		t.Fatalf("memoized cycle check = %v, want the walk's %v", got, want)
+	}
+	if !errors.Is(got, ErrSuccessionOrderCycle) && want != nil {
+		t.Fatalf("memoized cycle check lost the sentinel: %v", got)
+	}
+}
diff --git a/internal/exec/runtime/succession_order.go b/internal/exec/runtime/succession_order.go
index 9da593cd91..a92df0571f 100644
--- a/internal/exec/runtime/succession_order.go
+++ b/internal/exec/runtime/succession_order.go
@@ -317,6 +317,7 @@ func (ctx *Context) deferredBehaviorFor(inst *Instance, decl classifierBehaviorD
 		return nil, err
 	}
 	deferred := decl
+	ctx.behaviorHeld()
 	return &ObjectBehavior{
 		Name:      decl.behavior.Name,
 		Kind:      decl.behavior.Kind,
@@ -584,7 +585,34 @@ func (ctx *Context) releaseDeferredBehavior(behavior *ObjectBehavior) error {
 	return nil
 }
 
+// noneHeldMemo remembers a cycle check that found no behavior held; it answers
+// until a behavior enters held, the one move that can put a cycle in the graph.
+type noneHeldMemo struct {
+	taken bool
+	held  uint64
+}
+
+func (m noneHeldMemo) answers(ctx *Context) bool { return m.taken && m.held == ctx.held }
+
+// behaviorHeld records a behavior entering held, retiring the none-held memo.
+func (ctx *Context) behaviorHeld() { ctx.held++ }
+
+// successionCycle is walkSuccessionCycle, answered from the memo while no behavior
+// is held: the walk visits held behaviors only, so with none it finds no cycle.
 func (ctx *Context) successionCycle() error {
+	if ctx.noneHeld.answers(ctx) {
+		return nil
+	}
+	for _, behavior := range ctx.objectBehaviors {
+		if behavior.deferred != nil {
+			return ctx.walkSuccessionCycle()
+		}
+	}
+	ctx.noneHeld = noneHeldMemo{taken: true, held: ctx.held}
+	return nil
+}
+
+func (ctx *Context) walkSuccessionCycle() error {
 	var visit func(*ObjectBehavior) bool
 	state := make(map[*ObjectBehavior]uint8)
 	stack := make([]*ObjectBehavior, 0)
diff --git a/internal/exec/runtime/write_conformance.go b/internal/exec/runtime/write_conformance.go
index b05782d955..31d56b2703 100644
--- a/internal/exec/runtime/write_conformance.go
+++ b/internal/exec/runtime/write_conformance.go
@@ -102,14 +102,14 @@ func (ctx *Context) readOnlyRefusal(what func() string, name string, feature *sy
 // statement was written — before its value is evaluated. A chained target is
 // judged on the object its chain reaches (writeThroughChain), unless it ends in
 // a `featured by` feature no object holds a slot for (featuredChainTarget).
-func (ctx *Context) checkAssignable(where string, s lower.Assign) error {
+func (ctx *Context) checkAssignable(where func() string, s lower.Assign) error {
 	if s.Chain != nil {
 		if feature, ok := ctx.featuredChainTarget(s); ok {
-			return ctx.readOnlyRefusal(func() string { return fmt.Sprintf("%s: assignment to %s", where, s.Chain.Text) }, s.Chain.Text, feature)
+			return ctx.readOnlyRefusal(func() string { return fmt.Sprintf("%s: assignment to %s", where(), s.Chain.Text) }, s.Chain.Text, feature)
 		}
 		return nil
 	}
-	what := func() string { return fmt.Sprintf("%s: assignment to %s", where, s.Target) }
+	what := func() string { return fmt.Sprintf("%s: assignment to %s", where(), s.Target) }
 	if s.Qualified {
 		if s.Feature == nil {
 			return nil
@@ -182,17 +182,23 @@ func (ctx *Context) writeCountRefusal(target *writeTarget, value *Value) string
 // block-local, a parameter, an output - against the declaration of the name it
 // writes, before that value is stored.
 func (ctx *Context) checkBodyWrite(host stmtHost, s lower.Assign, value *Value) error {
-	return ctx.checkNamedWrite(s.Scope, host.describe(), s.Target, value)
+	return ctx.checkNamedWriteAs(s.Scope, host.describe, s.Target, value)
 }
 
 // checkNamedWrite checks a write of a name resolved in scope, for a path that
 // stores the value itself rather than reaching Instance.SetFeatureValue.
 func (ctx *Context) checkNamedWrite(scope *symbols.Scope, where, name string, value *Value) error {
+	return ctx.checkNamedWriteAs(scope, func() string { return where }, name, value)
+}
+
+// checkNamedWriteAs is checkNamedWrite naming where the write ran only when it is
+// refused, so a conformant write on a hot path does not pay for the description.
+func (ctx *Context) checkNamedWriteAs(scope *symbols.Scope, where func() string, name string, value *Value) error {
 	target, ok := ctx.writeTargetIn(scope, name)
 	if !ok {
 		return nil
 	}
-	what := func() string { return fmt.Sprintf("%s: assignment to %s", where, name) }
+	what := func() string { return fmt.Sprintf("%s: assignment to %s", where(), name) }
 	return ctx.checkTargetAs(scope, what, target, value, admitWritten, true)
 }
 
@@ -203,13 +209,19 @@ func (ctx *Context) checkNamedWrite(scope *symbols.Scope, where, name string, va
 // holds the count its initializer has and, as a namespace-level one, is judged for
 // uniqueness only where it declares more than one value.
 func (ctx *Context) checkBodyDeclaration(scope *symbols.Scope, where, name string, value *Value) error {
+	return ctx.checkBodyDeclarationAs(scope, func() string { return where }, name, value)
+}
+
+// checkBodyDeclarationAs is checkBodyDeclaration naming where the declaration ran
+// only when it is refused, so a conformant binding does not pay for the description.
+func (ctx *Context) checkBodyDeclarationAs(scope *symbols.Scope, where func() string, name string, value *Value) error {
 	target, ok := ctx.writeTargetIn(scope, name)
 	if !ok {
 		return nil
 	}
 	declared := *target
 	declared.unique = target.unique && multiValued(target.mult)
-	what := func() string { return fmt.Sprintf("%s: declaration of %s", where, name) }
+	what := func() string { return fmt.Sprintf("%s: declaration of %s", where(), name) }
 	return ctx.checkTargetAs(scope, what, &declared, value, admitDeclared, target.countJudged)
 }
 
diff --git a/internal/frontend/grpc/cache.go b/internal/frontend/grpc/cache.go
index de86a341ef..411a22ee71 100644
--- a/internal/frontend/grpc/cache.go
+++ b/internal/frontend/grpc/cache.go
@@ -8,6 +8,7 @@ import (
 
 	"connectrpc.com/connect"
 
+	pb "github.com/Open-MBEE/OpenSysML/api/proto"
 	"github.com/Open-MBEE/OpenSysML/internal/check/passes"
 	"github.com/Open-MBEE/OpenSysML/internal/exec/analysis"
 	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
@@ -34,6 +35,35 @@ type CachedDocument struct {
 	// and the passes' own findings when the model parsed clean and was analyzed.
 	Diagnostics []diag.Diagnostic
 	Warnings    []string
+	// proto is Diagnostics and Warnings converted to protobuf, once per document;
+	// a lineage hands the same cell to the next model when neither changed.
+	proto *protoDiagnostics
+}
+
+// protoDiagnostics is one document's diagnostics as protobuf, built once (capability
+// filter applied) and shared read-only by every response that reports them.
+type protoDiagnostics struct {
+	once  sync.Once
+	diags []*pb.Diagnostic
+}
+
+// newCachedDocument is a document whose diagnostics are converted at most once.
+func newCachedDocument(root *ast.RootNamespace, sf *source.SourceFile, parseDiags []parser.Diagnostic,
+	diagnostics []diag.Diagnostic, warnings []string) *CachedDocument {
+	return &CachedDocument{
+		Root: root, Source: sf, ParseDiags: parseDiags, Diagnostics: diagnostics,
+		Warnings: append([]string(nil), warnings...), proto: &protoDiagnostics{},
+	}
+}
+
+// protoDiagnostics is the document's diagnostics as build converts them, built on
+// first use and shared read-only across responses: never mutate a returned message.
+func (d *CachedDocument) protoDiagnostics(build func(*CachedDocument) []*pb.Diagnostic) []*pb.Diagnostic {
+	if d.proto == nil {
+		return build(d)
+	}
+	d.proto.once.Do(func() { d.proto.diags = build(d) })
+	return d.proto.diags
 }
 
 // CachedModel holds parsed model data with semantic analysis results
diff --git a/internal/frontend/grpc/diagnostics_converted_once_test.go b/internal/frontend/grpc/diagnostics_converted_once_test.go
new file mode 100644
index 0000000000..3d117e6b32
--- /dev/null
+++ b/internal/frontend/grpc/diagnostics_converted_once_test.go
@@ -0,0 +1,223 @@
+package grpc
+
+import (
+	"context"
+	"testing"
+
+	pb "github.com/Open-MBEE/OpenSysML/api/proto"
+	"google.golang.org/protobuf/proto"
+)
+
+// warningLibrary, warningTop and warningOther are a model whose top document
+// parses clean with a warning, so a parse of it reports diagnostics.
+const (
+	warningLibrary = "package Lib {\n\tpart def Engine;\n}\n"
+	warningTop     = "package Top {\n\tprivate import Lib::*;\n\tcalc def F { 1 /* c */ }\n\tpart def Car {\n\t\tpart motor : Engine;\n\t}\n}\n"
+	warningOther   = "package Other {\n\tpart def Wheel;\n}\n"
+)
+
+// requireWarnings fails unless diags hold a warning and nothing more severe.
+func requireWarnings(t *testing.T, diags []*pb.Diagnostic) {
+	t.Helper()
+	if len(diags) == 0 {
+		t.Fatal("no diagnostics to compare")
+	}
+	for _, d := range diags {
+		if d.Severity != "warning" {
+			t.Fatalf("diagnostic %v is not a warning", d)
+		}
+	}
+}
+
+// requireSameDiagnostics fails unless got repeats want message for message.
+func requireSameDiagnostics(t *testing.T, got, want []*pb.Diagnostic) {
+	t.Helper()
+	if len(got) != len(want) {
+		t.Fatalf("%d diagnostics, want %d:\n%v\n%v", len(got), len(want), got, want)
+	}
+	for i := range got {
+		if !proto.Equal(got[i], want[i]) {
+			t.Errorf("diagnostic %d is %v, want %v", i, got[i], want[i])
+		}
+	}
+}
+
+// A parse of a model parsed before answers the diagnostics the first parse
+// did, converted once: the messages are the same, so a service seeing the model
+// for the first time, a repeated parse and GetDiagnostics all agree, and a
+// service that withholds diagnostic codes withholds them on every call.
+func TestParseFileConvertsACachedModelsDiagnosticsOnce(t *testing.T) {
+	ctx := context.Background()
+	req := &pb.ParseFileRequest{Source: &pb.ParseFileRequest_Content{Content: misplacedComment}}
+	fresh := mustNewService(t, 10)
+	defer fresh.Close()
+	want, err := fresh.ParseFile(ctx, req)
+	if err != nil {
+		t.Fatalf("ParseFile: %v", err)
+	}
+	requireWarnings(t, want.Diagnostics)
+	requireEveryCoded(t, want.Diagnostics)
+
+	srv := mustNewService(t, 10)
+	defer srv.Close()
+	first, err := srv.ParseFile(ctx, req)
+	if err != nil {
+		t.Fatalf("ParseFile: %v", err)
+	}
+	second, err := srv.ParseFile(ctx, req)
+	if err != nil {
+		t.Fatalf("ParseFile again: %v", err)
+	}
+	if !proto.Equal(first, want) {
+		t.Errorf("first parse is\n%v\nfresh parse is\n%v", first, want)
+	}
+	if !proto.Equal(second, want) {
+		t.Errorf("repeated parse is\n%v\nfresh parse is\n%v", second, want)
+	}
+	for i := range first.Diagnostics {
+		if first.Diagnostics[i] != second.Diagnostics[i] {
+			t.Errorf("diagnostic %d was converted again for the repeated parse", i)
+		}
+	}
+	// The list is the response's own: growing one leaves the other as it was.
+	second.Diagnostics = append(second.Diagnostics, &pb.Diagnostic{Severity: "error"})
+	diags, err := srv.GetDiagnostics(ctx, &pb.DiagnosticsRequest{ModelHash: first.ModelHash})
+	if err != nil {
+		t.Fatalf("GetDiagnostics: %v", err)
+	}
+	requireSameDiagnostics(t, diags.Diagnostics, want.Diagnostics)
+	requireSameDiagnostics(t, first.Diagnostics, want.Diagnostics)
+
+	withheld, err := NewServiceWithUnavailableCapabilitiesForTesting(10, "test", []string{CapabilityDiagnosticCodes})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer withheld.Close()
+	for call := 0; call < 2; call++ {
+		resp, err := withheld.ParseFile(ctx, req)
+		if err != nil {
+			t.Fatalf("ParseFile: %v", err)
+		}
+		if len(resp.Diagnostics) != len(want.Diagnostics) {
+			t.Fatalf("withheld service reported %d diagnostics, want %d", len(resp.Diagnostics), len(want.Diagnostics))
+		}
+		for i, d := range resp.Diagnostics {
+			uncoded := proto.Clone(want.Diagnostics[i]).(*pb.Diagnostic)
+			uncoded.Code = ""
+			if !proto.Equal(d, uncoded) {
+				t.Errorf("call %d: withheld diagnostic = %v, want %v", call, d, uncoded)
+			}
+		}
+	}
+}
+
+// documentDiagnosticsOf are the diagnostics of resp located in the document named.
+func documentDiagnosticsOf(resp *pb.ParseSourcesResponse, name string) []*pb.Diagnostic {
+	var out []*pb.Diagnostic
+	for _, d := range resp.Diagnostics {
+		if d.GetSpan().GetFile() == name {
+			out = append(out, d)
+		}
+	}
+	return out
+}
+
+// A model answered from its lineage shares the converted diagnostics of every
+// document the edit before it did not reach, and converts afresh those of the
+// documents it did; either way it reports what a fresh parse of the same
+// documents reports.
+func TestParseSourcesSharesConvertedDiagnosticsOfDocumentsAnEditDidNotReach(t *testing.T) {
+	ctx := context.Background()
+	srv := mustNewService(t, 32)
+	defer srv.Close()
+	parse := func(srv *Service, documents []*pb.SourceDocument) *pb.ParseSourcesResponse {
+		t.Helper()
+		resp, err := srv.ParseSources(ctx, &pb.ParseSourcesRequest{Documents: documents})
+		if err != nil {
+			t.Fatalf("ParseSources: %v", err)
+		}
+		for _, d := range resp.Diagnostics {
+			if d.Severity != "warning" {
+				t.Fatalf("diagnostic %v is not a warning", d)
+			}
+		}
+		return resp
+	}
+	documents := func(other string) []*pb.SourceDocument {
+		return inlineDocuments("lib.sysml", warningLibrary, "top.sysml", warningTop, "other.sysml", other)
+	}
+	// Parsed twice so the edits are answered from the set's lineage.
+	parse(srv, documents(warningOther+"// first\n"))
+	base := parse(srv, documents(warningOther))
+	requireWarnings(t, documentDiagnosticsOf(base, "top.sysml"))
+
+	untouched := parse(srv, documents(warningOther+"// a comment\n"))
+	requireSameDiagnostics(t, untouched.Diagnostics, base.Diagnostics)
+	before, after := documentDiagnosticsOf(base, "top.sysml"), documentDiagnosticsOf(untouched, "top.sysml")
+	for i := range before {
+		if before[i] != after[i] {
+			t.Errorf("top.sysml diagnostic %d was converted again though the edit did not reach the document", i)
+		}
+	}
+
+	reached := inlineDocuments("lib.sysml", warningLibrary, "top.sysml", warningTop+"// edited\n", "other.sysml", warningOther)
+	edited := parse(srv, reached)
+	fresh := mustNewService(t, 10)
+	defer fresh.Close()
+	requireSameDiagnostics(t, edited.Diagnostics, parse(fresh, reached).Diagnostics)
+	for _, d := range documentDiagnosticsOf(edited, "top.sysml") {
+		for _, was := range before {
+			if d == was {
+				t.Errorf("top.sysml diagnostic %v is the base model's though the edit reached the document", d)
+			}
+		}
+	}
+}
+
+// freshlyConverted converts the cached model's diagnostics again, past the cache.
+func freshlyConverted(t *testing.T, srv *Service, hash string) []*pb.Diagnostic {
+	t.Helper()
+	cached, ok := srv.cache.Get(hash)
+	if !ok {
+		t.Fatalf("model %s is not cached", hash)
+	}
+	var fresh []*pb.Diagnostic
+	for _, doc := range cached.Documents {
+		fresh = append(fresh, srv.documentDiagnostics(doc)...)
+	}
+	return fresh
+}
+
+// The shared messages are never written after they are built: every later
+// response still equals a conversion made afresh from the cached model.
+func TestCachedDiagnosticsStayEqualToAFreshConversion(t *testing.T) {
+	ctx := context.Background()
+	req := &pb.ParseFileRequest{Source: &pb.ParseFileRequest_Content{Content: misplacedComment}}
+	withheld, err := NewServiceWithUnavailableCapabilitiesForTesting(10, "test", []string{CapabilityDiagnosticCodes})
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer withheld.Close()
+	for name, srv := range map[string]*Service{"coded": mustNewService(t, 10), "codes withheld": withheld} {
+		t.Run(name, func(t *testing.T) {
+			defer srv.Close()
+			first, err := srv.ParseFile(ctx, req)
+			if err != nil {
+				t.Fatalf("ParseFile: %v", err)
+			}
+			requireWarnings(t, first.Diagnostics)
+			second, err := srv.ParseFile(ctx, req)
+			if err != nil {
+				t.Fatalf("ParseFile again: %v", err)
+			}
+			diags, err := srv.GetDiagnostics(ctx, &pb.DiagnosticsRequest{ModelHash: first.ModelHash})
+			if err != nil {
+				t.Fatalf("GetDiagnostics: %v", err)
+			}
+			fresh := freshlyConverted(t, srv, first.ModelHash)
+			requireSameDiagnostics(t, first.Diagnostics, fresh)
+			requireSameDiagnostics(t, second.Diagnostics, fresh)
+			requireSameDiagnostics(t, diags.Diagnostics, fresh)
+		})
+	}
+}
diff --git a/internal/frontend/grpc/lineage.go b/internal/frontend/grpc/lineage.go
index ca7caf48e6..ed98edefe7 100644
--- a/internal/frontend/grpc/lineage.go
+++ b/internal/frontend/grpc/lineage.go
@@ -2,6 +2,7 @@ package grpc
 
 import (
 	"container/list"
+	"slices"
 	"sort"
 	"strings"
 	"sync"
@@ -42,6 +43,15 @@ type lineage struct {
 	library  libs.Source       // the files the workspace's library was built from
 	held     map[string]string // document name to the content the workspace holds
 	versions int               // the version the next update is given
+	// answered is each document of the model last answered, with the stamp of its
+	// analysis; the next model shares its converted diagnostics when both are unchanged.
+	answered map[string]answeredDocument
+}
+
+// answeredDocument is one document of the model a lineage last answered.
+type answeredDocument struct {
+	doc   *CachedDocument
+	stamp uint64
 }
 
 // lineages holds the most recently used lineages, a few at most: a lineage
@@ -171,7 +181,7 @@ func (s *Service) parseFromLineage(inputs []sourceInput, mode diag.ConformanceMo
 		}
 	}
 	if len(standIns) > 0 {
-		l.fresh, l.standIns, l.ws, l.held = true, standIns, nil, nil
+		l.fresh, l.standIns, l.ws, l.held, l.answered = true, standIns, nil, nil, nil
 		return nil, false
 	}
 	names := make([]string, len(inputs))
@@ -199,24 +209,37 @@ func (s *Service) parseFromLineage(inputs []sourceInput, mode diag.ConformanceMo
 	documents := make([]*CachedDocument, len(inputs))
 	for i, input := range inputs {
 		doc := l.ws.Document(input.name)
-		documents[i] = &CachedDocument{
-			Root:        doc.AST,
-			Source:      detached.Source(input.name),
-			ParseDiags:  doc.ParseDiagnostics,
-			Diagnostics: diagnostics[i],
-			Warnings:    append([]string(nil), input.warnings...),
-		}
+		documents[i] = newCachedDocument(doc.AST, detached.Source(input.name), doc.ParseDiagnostics,
+			diagnostics[i], input.warnings)
 	}
 	stamps := make(map[string]uint64, len(names))
 	for _, name := range names {
 		stamps[name] = l.ws.AnalysisStamp(name)
 	}
+	l.shareConvertedDiagnostics(documents, stamps)
 	return &CachedModel{
 		Documents: documents, Index: detached.Index(), Library: l.library, Mode: mode,
 		analysis: &analysisSnapshot{workspace: l.ws, stamps: stamps, scoped: declaresIdentityScope(inputs)},
 	}, true
 }
 
+// shareConvertedDiagnostics hands a document the converted diagnostics answered under
+// its name before when stamp, source and warnings are unchanged, i.e. no edit reached it.
+func (l *lineage) shareConvertedDiagnostics(documents []*CachedDocument, stamps map[string]uint64) {
+	if l.answered == nil {
+		l.answered = make(map[string]answeredDocument, len(documents))
+	}
+	for _, doc := range documents {
+		name := doc.Source.Name()
+		stamp := stamps[name]
+		if last, ok := l.answered[name]; ok && stamp != 0 && last.stamp == stamp &&
+			last.doc.Source == doc.Source && slices.Equal(last.doc.Warnings, doc.Warnings) {
+			doc.proto = last.doc.proto
+		}
+		l.answered[name] = answeredDocument{doc: doc, stamp: stamp}
+	}
+}
+
 // analysisSnapshot is which analysis of each document a model was answered
 // with, as the lineage's workspace numbers them (model.Workspace.AnalysisStamp).
 // A stamp changes exactly when the document is analyzed afresh, which happens
diff --git a/internal/frontend/grpc/service.go b/internal/frontend/grpc/service.go
index 2dda0747ce..d9d8ac2ed3 100644
--- a/internal/frontend/grpc/service.go
+++ b/internal/frontend/grpc/service.go
@@ -873,13 +873,8 @@ func (s *Service) parseModel(inputs []sourceInput, mode diag.ConformanceMode, in
 		if len(p.Diagnostics) > 0 {
 			parsedClean = false
 		}
-		documents = append(documents, &CachedDocument{
-			Root:        root,
-			Source:      srcFile,
-			ParseDiags:  p.Diagnostics,
-			Diagnostics: parser.AsDiagnostics(p.Diagnostics, p.Warnings),
-			Warnings:    append([]string(nil), input.warnings...),
-		})
+		documents = append(documents, newCachedDocument(root, srcFile, p.Diagnostics,
+			parser.AsDiagnostics(p.Diagnostics, p.Warnings), input.warnings))
 	}
 
 	// Registers what a wildcard import re-exports, so a qualified name reaches a
@@ -944,22 +939,32 @@ func (s *Service) GetDiagnostics(ctx context.Context, req *pb.DiagnosticsRequest
 	}, nil
 }
 
-// modelDiagnostics are every document's diagnostics, document by document, each
-// located in the source it came from. The parse's are among them once: the
-// passes report them, escalated where a pass judged the notation.
+// modelDiagnostics are every document's diagnostics in document order, each in its own
+// source, the parse's among them once as the passes report them; the list is the response's own.
 func (s *Service) modelDiagnostics(model *CachedModel) []*pb.Diagnostic {
 	var pbDiags []*pb.Diagnostic
 	for _, doc := range model.Documents {
-		for _, diag := range doc.Diagnostics {
-			pbDiags = append(pbDiags, DiagnosticToProto(diag, doc.Source))
-		}
-		for _, warning := range doc.Warnings {
-			pbDiags = append(pbDiags, &pb.Diagnostic{
-				Severity: diag.SeverityWarning.String(),
-				Message:  warning,
-				Span:     &pb.Span{File: doc.Source.Name()},
-			})
-		}
+		pbDiags = append(pbDiags, doc.protoDiagnostics(s.documentDiagnostics)...)
+	}
+	return pbDiags
+}
+
+// documentDiagnostics converts one document's diagnostics, then its warnings, to
+// protobuf, filtered by the service's capabilities, which are fixed when it is built.
+func (s *Service) documentDiagnostics(doc *CachedDocument) []*pb.Diagnostic {
+	if len(doc.Diagnostics)+len(doc.Warnings) == 0 {
+		return nil
+	}
+	pbDiags := make([]*pb.Diagnostic, 0, len(doc.Diagnostics)+len(doc.Warnings))
+	for _, diag := range doc.Diagnostics {
+		pbDiags = append(pbDiags, DiagnosticToProto(diag, doc.Source))
+	}
+	for _, warning := range doc.Warnings {
+		pbDiags = append(pbDiags, &pb.Diagnostic{
+			Severity: diag.SeverityWarning.String(),
+			Message:  warning,
+			Span:     &pb.Span{File: doc.Source.Name()},
+		})
 	}
 	return s.filterDiagnosticCapabilities(pbDiags)
 }
diff --git a/internal/frontend/jupyter/display.go b/internal/frontend/jupyter/display.go
index 0d97854ff2..4e5894aa44 100644
--- a/internal/frontend/jupyter/display.go
+++ b/internal/frontend/jupyter/display.go
@@ -5,6 +5,7 @@ import (
 	"strings"
 
 	"github.com/Open-MBEE/OpenSysML/internal/doc/docrender"
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl"
 	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext"
 	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
 )
@@ -58,6 +59,18 @@ func formBundle(form view.Form, lines []string) MIMEBundle {
 	return bundle
 }
 
+// vizBundle packages what %viz drew: the bundle of each form it was written
+// in, merged, the first form's plain text being the one every front end shows.
+func vizBundle(rendered []repl.Rendered) MIMEBundle {
+	bundle := MIMEBundle{}
+	for i := len(rendered) - 1; i >= 0; i-- {
+		for mime, data := range formBundle(rendered[i].Form, rendered[i].Lines) {
+			bundle[mime] = data
+		}
+	}
+	return bundle
+}
+
 // drawDot is the SVG of a DOT diagram when a Graphviz drawer is linked and
 // installed; false otherwise, and the diagram is shown as its source.
 func drawDot(dot string) (string, bool) {
diff --git a/internal/frontend/jupyter/kernel.go b/internal/frontend/jupyter/kernel.go
index 235a65ca9e..a2f93a6ad2 100644
--- a/internal/frontend/jupyter/kernel.go
+++ b/internal/frontend/jupyter/kernel.go
@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"io"
 	"log"
+	"net"
 	"os"
 	"sync"
 	"time"
@@ -40,6 +41,10 @@ type Kernel struct {
 	// session is the kernel's own session id, on every message it originates.
 	session string
 
+	// ctx and bound are set by Listen and consumed by Serve.
+	ctx   context.Context
+	bound *channels
+
 	iopubMu sync.Mutex
 	iopub   zmq4.Socket
 
@@ -67,60 +72,127 @@ func New(info Info, conn ConnectionInfo, engine Engine, logger *log.Logger) *Ker
 	}
 }
 
-// Run binds the channels and serves them until a shutdown request arrives or
-// ctx ends. It reports whether the front end asked for a restart.
+// channels are the five sockets of a kernel, one per channel. They close
+// once, whoever asks first: the context ending or Serve.
+type channels struct {
+	shell, control, stdin, iopub, hb zmq4.Socket
+	once                             sync.Once
+}
+
+func (c *channels) all() []zmq4.Socket {
+	return []zmq4.Socket{c.shell, c.control, c.stdin, c.iopub, c.hb}
+}
+
+func (c *channels) close() {
+	c.once.Do(func() {
+		for _, s := range c.all() {
+			_ = s.Close()
+		}
+	})
+}
+
+// Run is Listen then Serve: it binds the channels and serves them until a
+// shutdown request arrives or ctx ends, reporting whether the front end asked
+// for a restart.
 func (k *Kernel) Run(ctx context.Context) (restart bool, err error) {
+	if _, err := k.Listen(ctx); err != nil {
+		return false, err
+	}
+	return k.Serve()
+}
+
+// Listen binds the five channels and returns the connection they are bound
+// on. A TCP channel whose port is 0 is bound on a free port, and the
+// connection returned names the port taken; any other port is bound as given,
+// so a port already in use fails here. ctx ending closes the sockets, whether
+// or not Serve was called. A binding not yet served must be served before
+// the kernel can listen again.
+func (k *Kernel) Listen(ctx context.Context) (ConnectionInfo, error) {
+	if k.bound != nil {
+		return ConnectionInfo{}, errors.New("listen: the channels are bound already and not served")
+	}
 	ctx, cancel := context.WithCancel(ctx)
-	defer cancel()
 	k.stopMu.Lock()
 	k.stop = cancel
 	k.stopMu.Unlock()
 
-	shell := zmq4.NewRouter(ctx)
-	control := zmq4.NewRouter(ctx)
-	stdin := zmq4.NewRouter(ctx)
-	iopub := zmq4.NewPub(ctx)
-	hb := zmq4.NewRep(ctx)
-	sockets := []struct {
+	conn := k.conn
+	listening := &channels{
+		shell:   zmq4.NewRouter(ctx),
+		control: zmq4.NewRouter(ctx),
+		stdin:   zmq4.NewRouter(ctx),
+		iopub:   zmq4.NewPub(ctx),
+		hb:      zmq4.NewRep(ctx),
+	}
+	for _, s := range []struct {
 		name string
 		sock zmq4.Socket
-		port int
+		port *int
 	}{
-		{"shell", shell, k.conn.ShellPort},
-		{"control", control, k.conn.ControlPort},
-		{"stdin", stdin, k.conn.StdinPort},
-		{"iopub", iopub, k.conn.IOPubPort},
-		{"hb", hb, k.conn.HBPort},
-	}
-	defer func() {
-		for _, s := range sockets {
-			_ = s.sock.Close()
-		}
-	}()
-	for _, s := range sockets {
-		if err := s.sock.Listen(k.conn.endpoint(s.port)); err != nil {
-			return false, fmt.Errorf("listen %s on %s: %w", s.name, k.conn.endpoint(s.port), err)
+		{"shell", listening.shell, &conn.ShellPort},
+		{"control", listening.control, &conn.ControlPort},
+		{"stdin", listening.stdin, &conn.StdinPort},
+		{"iopub", listening.iopub, &conn.IOPubPort},
+		{"hb", listening.hb, &conn.HBPort},
+	} {
+		port, err := listen(s.sock, conn, *s.port)
+		if err != nil {
+			listening.close()
+			cancel()
+			return ConnectionInfo{}, fmt.Errorf("listen %s on %s: %w", s.name, conn.endpoint(*s.port), err)
 		}
+		*s.port = port
 	}
+	context.AfterFunc(ctx, listening.close)
+	k.conn = conn
+	k.ctx = ctx
+	k.bound = listening
 	k.iopubMu.Lock()
-	k.iopub = iopub
+	k.iopub = listening.iopub
 	k.iopubMu.Unlock()
+	return conn, nil
+}
+
+// listen binds one channel's socket and returns the port it is bound on: the
+// port given, or the one the system chose when that was 0.
+func listen(sock zmq4.Socket, conn ConnectionInfo, port int) (int, error) {
+	if err := sock.Listen(conn.endpoint(port)); err != nil {
+		return 0, err
+	}
+	if port != 0 || conn.Transport != "tcp" {
+		return port, nil
+	}
+	addr, ok := sock.Addr().(*net.TCPAddr)
+	if !ok {
+		return 0, fmt.Errorf("bound on %v, not a TCP address", sock.Addr())
+	}
+	return addr.Port, nil
+}
+
+// Serve answers on the channels Listen bound until a shutdown request arrives
+// or the context given to Listen ends. It reports whether the front end asked
+// for a restart.
+func (k *Kernel) Serve() (restart bool, err error) {
+	if k.bound == nil {
+		return false, errors.New("serve: the channels are not bound; Listen first")
+	}
+	ctx, ch := k.ctx, k.bound
+	k.ctx, k.bound = nil, nil
+	defer ch.close()
 
 	k.publish("status", Header{}, map[string]any{"execution_state": "starting"})
 
 	var wg sync.WaitGroup
 	wg.Add(3)
-	go func() { defer wg.Done(); k.heartbeat(ctx, hb) }()
-	go func() { defer wg.Done(); k.serve(ctx, control, k.handleControl) }()
-	go func() { defer wg.Done(); k.serve(ctx, shell, k.handleShell) }()
+	go func() { defer wg.Done(); k.heartbeat(ctx, ch.hb) }()
+	go func() { defer wg.Done(); k.serve(ctx, ch.control, k.handleControl) }()
+	go func() { defer wg.Done(); k.serve(ctx, ch.shell, k.handleShell) }()
 	<-ctx.Done()
 	// A cell under way is stopped first: closing the sockets cannot reach the
-	// goroutine busy in Execute, and Run waits for it below.
+	// goroutine busy in Execute, and Serve waits for it below.
 	k.engine.Interrupt()
 	// Closing the sockets unblocks the receives; the loops then see ctx done.
-	for _, s := range sockets {
-		_ = s.sock.Close()
-	}
+	ch.close()
 	wg.Wait()
 	k.stopMu.Lock()
 	defer k.stopMu.Unlock()
diff --git a/internal/frontend/jupyter/kernel_test.go b/internal/frontend/jupyter/kernel_test.go
index a313cfed58..4594cc21ba 100644
--- a/internal/frontend/jupyter/kernel_test.go
+++ b/internal/frontend/jupyter/kernel_test.go
@@ -84,31 +84,22 @@ type client struct {
 	pub chan Message
 }
 
-func freePort(t *testing.T) int {
-	t.Helper()
-	l, err := net.Listen("tcp", "127.0.0.1:0")
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer l.Close()
-	return l.Addr().(*net.TCPAddr).Port
-}
-
-// startKernel runs a kernel over the engine and connects a client to it; the
-// kernel's Run result is read from done.
+// startKernel binds a kernel on free ports, serves the engine over it and
+// connects a client; the kernel's Serve result is read from done.
 func startKernel(t *testing.T, engine Engine) (*client, *Kernel, chan struct{ restart bool }) {
 	t.Helper()
-	conn := ConnectionInfo{
-		Transport: "tcp", IP: "127.0.0.1", Key: "test-key", SignatureScheme: "hmac-sha256",
-		ShellPort: freePort(t), IOPubPort: freePort(t), StdinPort: freePort(t), ControlPort: freePort(t), HBPort: freePort(t),
-	}
-	kernel := New(Info{Implementation: "test", ImplementationVersion: "0", Language: LanguageInfo{Name: "sysml"}}, conn, engine, nil)
+	kernel := New(Info{Implementation: "test", ImplementationVersion: "0", Language: LanguageInfo{Name: "sysml"}}, testConnection, engine, nil)
 	ctx, cancel := context.WithCancel(context.Background())
+	conn, err := kernel.Listen(ctx)
+	if err != nil {
+		cancel()
+		t.Fatalf("Listen: %v", err)
+	}
 	done := make(chan struct{ restart bool }, 1)
 	go func() {
-		restart, err := kernel.Run(ctx)
+		restart, err := kernel.Serve()
 		if err != nil {
-			t.Errorf("Run: %v", err)
+			t.Errorf("Serve: %v", err)
 		}
 		done <- struct{ restart bool }{restart}
 	}()
@@ -129,19 +120,20 @@ func startKernel(t *testing.T, engine Engine) (*client, *Kernel, chan struct{ re
 	if err := c.iopub.SetOption(zmq4.OptionSubscribe, ""); err != nil {
 		t.Fatal(err)
 	}
+	t.Cleanup(func() {
+		for _, s := range []zmq4.Socket{c.shell, c.control, c.iopub, c.hb} {
+			s.Close()
+		}
+	})
+	// The kernel is listening already, so a dial that fails is a failure.
 	for _, s := range []struct {
 		sock zmq4.Socket
 		port int
 	}{{c.shell, conn.ShellPort}, {c.control, conn.ControlPort}, {c.iopub, conn.IOPubPort}, {c.hb, conn.HBPort}} {
-		if err := dialUntilUp(ctx, s.sock, conn.endpoint(s.port)); err != nil {
+		if err := s.sock.Dial(conn.endpoint(s.port)); err != nil {
 			t.Fatal(err)
 		}
 	}
-	t.Cleanup(func() {
-		for _, s := range []zmq4.Socket{c.shell, c.control, c.iopub, c.hb} {
-			s.Close()
-		}
-	})
 	go func() {
 		for {
 			raw, err := c.iopub.Recv()
@@ -159,6 +151,11 @@ func startKernel(t *testing.T, engine Engine) (*client, *Kernel, chan struct{ re
 	// A subscription joins late: ask for kernel info until its status shows on IOPub.
 	deadline := time.Now().Add(10 * time.Second)
 	for {
+		select {
+		case r := <-done:
+			t.Fatalf("the kernel stopped before it answered (restart=%v)", r.restart)
+		default:
+		}
 		id := c.send(c.shell, "kernel_info_request", map[string]any{})
 		c.reply(c.shell, id)
 		if c.sawStatus(id) {
@@ -171,21 +168,9 @@ func startKernel(t *testing.T, engine Engine) (*client, *Kernel, chan struct{ re
 	return c, kernel, done
 }
 
-// dialUntilUp dials the endpoint, retrying while the kernel is still binding.
-func dialUntilUp(ctx context.Context, sock zmq4.Socket, ep string) error {
-	var err error
-	for i := 0; i < 200; i++ {
-		if err = sock.Dial(ep); err == nil {
-			return nil
-		}
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		case <-time.After(25 * time.Millisecond):
-		}
-	}
-	return err
-}
+// testConnection leaves every port to Listen, so no port is reserved before
+// it is bound and nothing else can take it in between.
+var testConnection = ConnectionInfo{Transport: "tcp", IP: "127.0.0.1", Key: "test-key", SignatureScheme: "hmac-sha256"}
 
 // sawStatus drains IOPub for up to half a second and reports whether an idle
 // status for the request arrived.
@@ -580,6 +565,143 @@ func TestShutdownStopsTheCellRunningAndEndsRun(t *testing.T) {
 	}
 }
 
+func TestListenOnZeroPortsBindsFiveDistinctPortsAndReportsThem(t *testing.T) {
+	kernel := New(Info{}, testConnection, newFakeEngine(), nil)
+	ctx, cancel := context.WithCancel(context.Background())
+	conn, err := kernel.Listen(ctx)
+	if err != nil {
+		cancel()
+		t.Fatalf("Listen: %v", err)
+	}
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		if _, err := kernel.Serve(); err != nil {
+			t.Errorf("Serve: %v", err)
+		}
+	}()
+	t.Cleanup(func() {
+		cancel()
+		<-done
+	})
+	ports := []int{conn.ShellPort, conn.IOPubPort, conn.StdinPort, conn.ControlPort, conn.HBPort}
+	seen := map[int]bool{}
+	for _, port := range ports {
+		if port <= 0 {
+			t.Fatalf("Listen reported ports %v: a port was not bound", ports)
+		}
+		if seen[port] {
+			t.Fatalf("Listen reported ports %v: two channels share a port", ports)
+		}
+		seen[port] = true
+		probe, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", port))
+		if err != nil {
+			t.Errorf("port %d reported bound does not accept: %v", port, err)
+			continue
+		}
+		probe.Close()
+	}
+	if conn.Transport != "tcp" || conn.IP != "127.0.0.1" || conn.Key != "test-key" || conn.SignatureScheme != "hmac-sha256" {
+		t.Errorf("Listen altered the connection beyond its ports: %+v", conn)
+	}
+	if err := conn.Validate(); err != nil {
+		t.Errorf("the connection reported does not validate: %v", err)
+	}
+}
+
+func TestListenOnAPortAlreadyBoundFailsAtOnce(t *testing.T) {
+	c, _, _ := startKernel(t, newFakeEngine())
+	taken := New(Info{}, c.conn, newFakeEngine(), nil)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	started := time.Now()
+	conn, err := taken.Listen(ctx)
+	if err == nil {
+		t.Fatalf("Listen on the ports of a running kernel bound %+v", conn)
+	}
+	if !strings.Contains(err.Error(), "listen shell on "+c.conn.endpoint(c.conn.ShellPort)) {
+		t.Errorf("Listen error = %v, want it to name the shell channel and its endpoint", err)
+	}
+	if took := time.Since(started); took > 5*time.Second {
+		t.Errorf("Listen took %v to fail", took)
+	}
+	if _, err := taken.Serve(); err == nil {
+		t.Error("Serve after a failed Listen did not fail")
+	}
+}
+
+func TestListenAgainBeforeServingIsRefusedAndTheFirstBindingStillShutsDown(t *testing.T) {
+	engine := newFakeEngine()
+	kernel := New(Info{}, testConnection, engine, nil)
+	ctx, cancel := context.WithCancel(context.Background())
+	defer cancel()
+	conn, err := kernel.Listen(ctx)
+	if err != nil {
+		t.Fatalf("Listen: %v", err)
+	}
+	if again, err := kernel.Listen(ctx); err == nil {
+		t.Fatalf("a second Listen before Serve bound %+v", again)
+	}
+	done := make(chan struct{})
+	go func() {
+		defer close(done)
+		if _, err := kernel.Serve(); err != nil {
+			t.Errorf("Serve: %v", err)
+		}
+	}()
+	c := &client{t: t, conn: conn, signer: newSigner(conn), pub: make(chan Message, 1)}
+	c.control = zmq4.NewDealer(ctx, zmq4.WithID(zmq4.SocketIdentity("control-client")))
+	defer c.control.Close()
+	if err := c.control.Dial(conn.endpoint(conn.ControlPort)); err != nil {
+		t.Fatal(err)
+	}
+	id := c.send(c.control, "shutdown_request", map[string]any{"restart": false})
+	if reply := c.reply(c.control, id); reply.Header.MsgType != "shutdown_reply" {
+		t.Errorf("reply = %s %v", reply.Header.MsgType, reply.Content)
+	}
+	select {
+	case <-done:
+	case <-time.After(10 * time.Second):
+		t.Fatal("Serve did not return after the shutdown: the refused Listen must leave the first binding's stop in place")
+	}
+}
+
+func TestCancellingAfterListenReleasesThePortsWithoutServe(t *testing.T) {
+	kernel := New(Info{}, testConnection, newFakeEngine(), nil)
+	ctx, cancel := context.WithCancel(context.Background())
+	conn, err := kernel.Listen(ctx)
+	if err != nil {
+		cancel()
+		t.Fatalf("Listen: %v", err)
+	}
+	cancel()
+	deadline := time.Now().Add(10 * time.Second)
+	for _, port := range []int{conn.ShellPort, conn.IOPubPort, conn.StdinPort, conn.ControlPort, conn.HBPort} {
+		for {
+			probe, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", port))
+			if err != nil {
+				break
+			}
+			probe.Close()
+			if time.Now().After(deadline) {
+				t.Fatalf("port %d still accepts ten seconds after the context ended", port)
+			}
+			time.Sleep(10 * time.Millisecond)
+		}
+	}
+	// Serve on a cancelled binding is allowed and returns at once.
+	if _, err := kernel.Serve(); err != nil {
+		t.Errorf("Serve after the context ended: %v", err)
+	}
+}
+
+func TestServeBeforeListenFails(t *testing.T) {
+	kernel := New(Info{}, testConnection, newFakeEngine(), nil)
+	if _, err := kernel.Serve(); err == nil {
+		t.Error("Serve without Listen did not fail")
+	}
+}
+
 func TestKernelInterruptReachesTheEngine(t *testing.T) {
 	engine := newFakeEngine()
 	kernel := New(Info{}, ConnectionInfo{}, engine, nil)
diff --git a/internal/frontend/jupyter/replengine.go b/internal/frontend/jupyter/replengine.go
index fb01624d22..80c27b9edf 100644
--- a/internal/frontend/jupyter/replengine.go
+++ b/internal/frontend/jupyter/replengine.go
@@ -9,6 +9,7 @@ import (
 
 	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
 	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl"
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
 )
 
 // errPrefix marks a line the prompt prints for a failure.
@@ -90,6 +91,15 @@ func (e *REPLEngine) meta(line string, out Output) error {
 		}
 		out.Display(formBundle(rendered.Form, rendered.Lines), nil)
 		return nil
+	case "%viz":
+		// With no form asked for, the diagram is shown as richly as the front
+		// end can: as Mermaid, and as SVG drawn from DOT where Graphviz is.
+		rendered, err := e.session.Viz(args, view.FormMermaid, view.FormDot)
+		if err != nil {
+			return renderError(err)
+		}
+		out.Display(vizBundle(rendered), nil)
+		return nil
 	case "%render-document":
 		// A trailing `html` asks for the document as HTML rather than the
 		// Markdown the prompt prints; the arguments before it are the prompt's.
@@ -113,6 +123,10 @@ func (e *REPLEngine) meta(line string, out Output) error {
 	}
 	lines, quit, err := e.session.RunMeta(line)
 	if err != nil {
+		var usage *repl.UsageError
+		if errors.As(err, &usage) {
+			return execError("UsageError", usage.Error(), usage.Lines)
+		}
 		name := "CommandError"
 		if errors.Is(err, runtime.ErrInterrupted) {
 			name = "KeyboardInterrupt"
diff --git a/internal/frontend/jupyter/replengine_test.go b/internal/frontend/jupyter/replengine_test.go
index 903b7447c0..ef02032d9d 100644
--- a/internal/frontend/jupyter/replengine_test.go
+++ b/internal/frontend/jupyter/replengine_test.go
@@ -1,7 +1,11 @@
 package jupyter
 
 import (
+	"encoding/json"
 	"errors"
+	"os"
+	"path/filepath"
+	"slices"
 	"strings"
 	"testing"
 	"time"
@@ -105,6 +109,10 @@ func TestFailuresAreNamedByWhatFailed(t *testing.T) {
 		"%print Nope":                        "CommandError",
 		"%render nothing":                    "RenderError",
 		"%render":                            "UsageError",
+		"%viz":                               "UsageError",
+		"%viz --view nope Demo":              "UsageError",
+		"%viz --style nosuch Demo":           "UsageError",
+		"%viz nothing":                       "RenderError",
 		"%render-document":                   "UsageError",
 		"1 +":                                "SubmissionError",
 	}
@@ -347,3 +355,145 @@ func hugeBudgets(t *testing.T, e *REPLEngine) runtime.Budgets {
 	b.MaxActionSteps = 1 << 40
 	return b
 }
+
+const vizKernelModel = `package P {
+  part def Wheel;
+  part def Car { part fl : Wheel; part fr : Wheel; connect fl to fr; }
+  part car : Car { part a : Wheel; part b : Wheel; connect a to b; }
+  state def Lamp { state off; state on; transition off then on; }
+  action def Start { action a; action b; first a then b; }
+}
+`
+
+// %viz with no form shows a diagram: Mermaid, and the DOT the kind is drawn in,
+// as SVG where Graphviz draws it; a form asked for is shown as %render shows it.
+func TestVizShowsADiagram(t *testing.T) {
+	e := newEngine(t)
+	mustRun(t, e, vizKernelModel)
+	cases := []struct {
+		code string
+		mark string
+	}{
+		{"%viz P::Car", "flowchart"},
+		{"%viz P::car", "flowchart LR"},
+		{"%viz --view STATE P::Lamp", "stateDiagram-v2"},
+		{"%viz P::Lamp", "stateDiagram-v2"},
+		{"%viz P::Start", "flowchart"},
+		{"%viz --style LR --style ortholine P::Car P::Lamp", "flowchart LR"},
+	}
+	for _, c := range cases {
+		out := mustRun(t, e, c.code)
+		if len(out.displays) != 1 {
+			t.Fatalf("%s displayed %d bundles, want 1", c.code, len(out.displays))
+		}
+		bundle := out.displays[0]
+		mermaid, ok := bundle[mimeMermaid].(string)
+		if !ok || !strings.Contains(mermaid, c.mark) {
+			t.Errorf("%s: %s = %q, want a diagram holding %q", c.code, mimeMermaid, bundle[mimeMermaid], c.mark)
+		}
+		dot, ok := bundle[mimeDot].(string)
+		if !ok || !strings.Contains(dot, "digraph") {
+			t.Errorf("%s: %s = %q, want the DOT source beside the Mermaid", c.code, mimeDot, bundle[mimeDot])
+		}
+		if text, ok := bundle[mimeText].(string); !ok || text != mermaid {
+			t.Errorf("%s: %s = %q, want the Mermaid source as the plain text", c.code, mimeText, bundle[mimeText])
+		}
+		if svg, ok := bundle[mimeSVG].(string); ok != dotDrawn() || ok && !strings.Contains(svg, "<svg") {
+			t.Errorf("%s: %s present = %t, want %t (Graphviz drawn)", c.code, mimeSVG, ok, dotDrawn())
+		}
+	}
+	out := mustRun(t, e, "%viz --style ortholine P::Car")
+	if mermaid, _ := out.displays[0][mimeMermaid].(string); !strings.Contains(mermaid, "%% not represented: style ORTHOLINE (orthogonal line style) is not drawn") {
+		t.Errorf("a pilot style not drawn was not noted in the diagram:\n%s", mermaid)
+	}
+	out = mustRun(t, e, "%viz --view SEQUENCE P::Car")
+	if bundle := out.displays[0]; bundle[mimeMermaid] == nil || bundle[mimeDot] != nil {
+		t.Errorf("a sequence diagram, which DOT does not draw, was shown as %v", bundle)
+	}
+	out = mustRun(t, e, "%viz text P::Car")
+	if bundle := out.displays[0]; bundle[mimeMermaid] != nil || !strings.Contains(bundle[mimeText].(string), "tree rendering") {
+		t.Errorf("the text form asked for was shown as %v", bundle)
+	}
+	out = mustRun(t, e, "%viz P::Car dot")
+	if bundle := out.displays[0]; bundle[mimeDot] == nil || bundle[mimeMermaid] != nil {
+		t.Errorf("the dot form asked for was shown as %v", bundle)
+	}
+	failure := mustFail(t, e, "%viz --view nope P::Car")
+	if failure.Name != "UsageError" || !strings.Contains(failure.Value, `unknown view "nope"`) || !slices.ContainsFunc(failure.Traceback, func(line string) bool { return strings.HasPrefix(line, "usage: %viz") }) {
+		t.Errorf("a usage problem failed as %+v", failure)
+	}
+	failure = mustFail(t, e, "%viz P::Car P::Nope")
+	if failure.Name != "RenderError" || !strings.Contains(failure.Value, "P::Nope") {
+		t.Errorf("an unresolved name failed as %+v", failure)
+	}
+}
+
+// dotDrawn reports whether the kernel can draw DOT as SVG here.
+func dotDrawn() bool {
+	_, ok := drawDot("digraph { a -> b }")
+	return ok
+}
+
+func TestACellMayLoadAnotherNotebookAndUseItsNames(t *testing.T) {
+	dir := t.TempDir()
+	other := filepath.Join(dir, "other.ipynb")
+	data, err := json.Marshal(map[string]any{
+		"cells": []map[string]any{
+			{"cell_type": "markdown", "metadata": map[string]any{}, "source": "# A wheel"},
+			{"cell_type": "code", "metadata": map[string]any{}, "outputs": []any{}, "source": []string{
+				"%verbosity quiet\n",
+				"private import ScalarValues::*;\n",
+				"package Demo {\n",
+				"  part def Wheel { attribute diameter : Real = 16.0; }\n",
+				"}\n",
+				"Demo::Wheel::diameter + 1\n",
+			}},
+			{"cell_type": "code", "metadata": map[string]any{}, "outputs": []any{}, "source": "%instantiate Demo::Wheel\n"},
+		},
+		"metadata": map[string]any{"kernelspec": map[string]any{"language": "sysml", "name": "sysml"}},
+		"nbformat": 4, "nbformat_minor": 5,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.WriteFile(other, data, 0o600); err != nil {
+		t.Fatal(err)
+	}
+
+	e := newEngine(t)
+	out := mustRun(t, e, "%load "+other)
+	for _, want := range []string{
+		"loaded " + other + ": 2 of 2 code cells, 1 declaration",
+		"skipped 2 % command lines and 1 expression line",
+		"✓ package Demo",
+	} {
+		if !strings.Contains(out.text(), want) {
+			t.Errorf("want %q in the load report:\n%s", want, out.text())
+		}
+	}
+	if len(out.results) != 0 {
+		t.Errorf("the other notebook's expression was evaluated: %v", out.results)
+	}
+	out = mustRun(t, e, "Demo::Wheel::diameter + 1")
+	if len(out.results) != 1 || !strings.Contains(out.results[0][mimeText].(string), "= 17.0") {
+		t.Errorf("the loaded names are not usable: %v", out.results)
+	}
+	// The other notebook's %verbosity did not run: a declaration is still echoed.
+	out = mustRun(t, e, "package Spare { part def Rim; }")
+	if !strings.Contains(out.text(), "✓ package Spare") {
+		t.Errorf("declaration output = %q", out.text())
+	}
+}
+
+func TestLoadingAPythonNotebookIsACommandError(t *testing.T) {
+	dir := t.TempDir()
+	other := filepath.Join(dir, "analysis.ipynb")
+	nb := `{"cells": [{"cell_type": "code", "metadata": {}, "outputs": [], "source": "print(1)"}], "metadata": {"kernelspec": {"language": "python", "name": "python3"}}, "nbformat": 4, "nbformat_minor": 5}`
+	if err := os.WriteFile(other, []byte(nb), 0o600); err != nil {
+		t.Fatal(err)
+	}
+	failure := mustFail(t, newEngine(t), "%load "+other)
+	if failure.Name != "CommandError" || !strings.Contains(failure.Value, "a python notebook") {
+		t.Errorf("failure = %+v, want a CommandError naming the python notebook", failure)
+	}
+}
diff --git a/internal/frontend/jupyter/repository_test.go b/internal/frontend/jupyter/repository_test.go
new file mode 100644
index 0000000000..b8ed822f55
--- /dev/null
+++ b/internal/frontend/jupyter/repository_test.go
@@ -0,0 +1,48 @@
+package jupyter
+
+import (
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+)
+
+// TestRepositoryCommandsRunThroughTheKernel drives %repo and %projects against
+// a fake SysML v2 API server: the listing streams as text, an argument problem
+// is a UsageError, and a server failure a CommandError naming the status.
+func TestRepositoryCommandsRunThroughTheKernel(t *testing.T) {
+	var projects []map[string]any
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		if r.URL.Path != "/projects" {
+			w.WriteHeader(http.StatusInternalServerError)
+			_, _ = w.Write([]byte(`{"error":"the database is away"}`))
+			return
+		}
+		w.Header().Set("Content-Type", "application/json")
+		_ = json.NewEncoder(w).Encode(projects)
+	}))
+	defer server.Close()
+	t.Setenv("FLEXO_SYSMLV2_URL", server.URL)
+	t.Setenv("FLEXO_INTEROP_TOKEN", "")
+
+	e := newEngine(t)
+	if got := mustRun(t, e, "%repo").text(); got != "stdout: API base path: "+server.URL+"\n" {
+		t.Errorf("%%repo streamed %q", got)
+	}
+	if got := mustRun(t, e, "%projects").text(); got != "stdout: no projects\n" {
+		t.Errorf("%%projects over an empty repository streamed %q", got)
+	}
+	projects = []map[string]any{{"@id": "p-1", "name": "Rover", "defaultBranch": map[string]any{"@id": "b-1"}}}
+	if got := mustRun(t, e, "%projects").text(); got != "stdout: Rover (p-1)\n" {
+		t.Errorf("%%projects streamed %q", got)
+	}
+
+	if failure := mustFail(t, e, "%projects now"); failure.Name != "UsageError" || !strings.HasPrefix(failure.Value, "usage: %projects") {
+		t.Errorf("%%projects now: %s: %s", failure.Name, failure.Value)
+	}
+	failure := mustFail(t, e, "%load --id=p-1")
+	if failure.Name != "CommandError" || !strings.Contains(failure.Value, "Internal Server Error") || !strings.Contains(failure.Value, "the database is away") {
+		t.Errorf("a server failure: %s: %s", failure.Name, failure.Value)
+	}
+}
diff --git a/internal/frontend/repl/cell.go b/internal/frontend/repl/cell.go
index da5f8770f9..203df2a46c 100644
--- a/internal/frontend/repl/cell.go
+++ b/internal/frontend/repl/cell.go
@@ -11,6 +11,8 @@ type Statement struct {
 	// Meta is set when Text is a `%` command line.
 	Meta bool
 	Text string
+	// Line is the line of the cell, counted from 1, that Text begins on.
+	Line int
 }
 
 // Statements splits a cell of input into what the prompt would read from it.
@@ -22,19 +24,33 @@ type Statement struct {
 func Statements(cell string) []Statement {
 	var out []Statement
 	var decls, chunk strings.Builder
-	flush := func(b *strings.Builder) {
+	declsAt, chunkAt := 0, 0
+	flush := func(b *strings.Builder, at int) {
 		if strings.TrimSpace(b.String()) != "" {
-			out = append(out, Statement{Text: b.String()})
+			out = append(out, Statement{Text: b.String(), Line: at})
 		}
 		b.Reset()
 	}
-	for _, line := range strings.Split(cell, "\n") {
-		if chunk.Len() == 0 && isMeta(line) {
-			flush(&decls)
-			out = append(out, Statement{Meta: true, Text: strings.TrimSpace(line)})
-			continue
+	// A chunk joins to the declarations before it with a newline, so a blank
+	// line keeps its place and the declarations' line is their first text's.
+	join := func() {
+		if decls.Len() == 0 {
+			declsAt = chunkAt
+		} else {
+			decls.WriteByte('\n')
 		}
-		if chunk.Len() > 0 {
+		decls.WriteString(chunk.String())
+		chunk.Reset()
+	}
+	for i, line := range strings.Split(cell, "\n") {
+		if chunk.Len() == 0 {
+			chunkAt = i + 1
+			if isMeta(line) {
+				flush(&decls, declsAt)
+				out = append(out, Statement{Meta: true, Text: strings.TrimSpace(line), Line: chunkAt})
+				continue
+			}
+		} else {
 			chunk.WriteByte('\n')
 		}
 		chunk.WriteString(line)
@@ -42,23 +58,16 @@ func Statements(cell string) []Statement {
 			continue
 		}
 		if _, ok := bareExpression(chunk.String()); ok {
-			flush(&decls)
-			flush(&chunk)
+			flush(&decls, declsAt)
+			flush(&chunk, chunkAt)
 			continue
 		}
-		if decls.Len() > 0 {
-			decls.WriteByte('\n')
-		}
-		decls.WriteString(chunk.String())
-		chunk.Reset()
+		join()
 	}
 	if chunk.Len() > 0 {
-		if decls.Len() > 0 {
-			decls.WriteByte('\n')
-		}
-		decls.WriteString(chunk.String())
+		join()
 	}
-	flush(&decls)
+	flush(&decls, declsAt)
 	return out
 }
 
diff --git a/internal/frontend/repl/cell_test.go b/internal/frontend/repl/cell_test.go
index 662b44a7e6..147d1d7a3d 100644
--- a/internal/frontend/repl/cell_test.go
+++ b/internal/frontend/repl/cell_test.go
@@ -13,21 +13,23 @@ func TestStatementsSplitACellAsThePromptReadsIt(t *testing.T) {
 	}{
 		{"empty", "", nil},
 		{"blank lines only", "\n  \n", nil},
-		{"one meta", "%help", []Statement{{Meta: true, Text: "%help"}}},
-		{"meta with surrounding space", "  %eval 1 + 2  ", []Statement{{Meta: true, Text: "%eval 1 + 2"}}},
-		{"one declaration", "part def A;", []Statement{{Text: "part def A;"}}},
-		{"declaration over lines with a blank line", "package P {\n\n  part def A;\n}", []Statement{{Text: "package P {\n\n  part def A;\n}"}}},
-		{"meta then declaration", "%clear\npart def A;", []Statement{{Meta: true, Text: "%clear"}, {Text: "part def A;"}}},
-		{"declaration then meta", "part def A;\n%print A", []Statement{{Text: "part def A;"}, {Meta: true, Text: "%print A"}}},
-		{"meta inside an open brace is text", "package P {\n%notacommand\n}", []Statement{{Text: "package P {\n%notacommand\n}"}}},
-		{"meta after a closed brace is a command", "package P {\n}\n%print P", []Statement{{Text: "package P {\n}"}, {Meta: true, Text: "%print P"}}},
-		{"string holding a brace", "attribute s = \"{\";\n%print s", []Statement{{Text: "attribute s = \"{\";"}, {Meta: true, Text: "%print s"}}},
-		{"two declarations are one submission", "part def A;\npart def B;", []Statement{{Text: "part def A;\npart def B;"}}},
-		{"expression", "1 + 2", []Statement{{Text: "1 + 2"}}},
-		{"two expressions are two submissions", "1 + 2\nP::x.mass + 100.0", []Statement{{Text: "1 + 2"}, {Text: "P::x.mass + 100.0"}}},
-		{"declaration then expression", "package P {\n  part def A;\n}\n1 + 2", []Statement{{Text: "package P {\n  part def A;\n}"}, {Text: "1 + 2"}}},
-		{"expression over lines", "(1 +\n 2)", []Statement{{Text: "(1 +\n 2)"}}},
-		{"unfinished declaration is submitted as it stands", "package P {\n  part def A;", []Statement{{Text: "package P {\n  part def A;"}}},
+		{"one meta", "%help", []Statement{{Meta: true, Text: "%help", Line: 1}}},
+		{"meta with surrounding space", "  %eval 1 + 2  ", []Statement{{Meta: true, Text: "%eval 1 + 2", Line: 1}}},
+		{"one declaration", "part def A;", []Statement{{Text: "part def A;", Line: 1}}},
+		{"declaration over lines with a blank line", "package P {\n\n  part def A;\n}", []Statement{{Text: "package P {\n\n  part def A;\n}", Line: 1}}},
+		{"meta then declaration", "%clear\npart def A;", []Statement{{Meta: true, Text: "%clear", Line: 1}, {Text: "part def A;", Line: 2}}},
+		{"declaration then meta", "part def A;\n%print A", []Statement{{Text: "part def A;", Line: 1}, {Meta: true, Text: "%print A", Line: 2}}},
+		{"meta inside an open brace is text", "package P {\n%notacommand\n}", []Statement{{Text: "package P {\n%notacommand\n}", Line: 1}}},
+		{"meta after a closed brace is a command", "package P {\n}\n%print P", []Statement{{Text: "package P {\n}", Line: 1}, {Meta: true, Text: "%print P", Line: 3}}},
+		{"string holding a brace", "attribute s = \"{\";\n%print s", []Statement{{Text: "attribute s = \"{\";", Line: 1}, {Meta: true, Text: "%print s", Line: 2}}},
+		{"two declarations are one submission", "part def A;\npart def B;", []Statement{{Text: "part def A;\npart def B;", Line: 1}}},
+		{"expression", "1 + 2", []Statement{{Text: "1 + 2", Line: 1}}},
+		{"two expressions are two submissions", "1 + 2\nP::x.mass + 100.0", []Statement{{Text: "1 + 2", Line: 1}, {Text: "P::x.mass + 100.0", Line: 2}}},
+		{"declaration then expression", "package P {\n  part def A;\n}\n1 + 2", []Statement{{Text: "package P {\n  part def A;\n}", Line: 1}, {Text: "1 + 2", Line: 4}}},
+		{"expression over lines", "(1 +\n 2)", []Statement{{Text: "(1 +\n 2)", Line: 1}}},
+		{"unfinished declaration is submitted as it stands", "package P {\n  part def A;", []Statement{{Text: "package P {\n  part def A;", Line: 1}}},
+		{"a leading blank line is not the declaration's", "\npart def A;\n\n1 + 2\n%print A", []Statement{{Text: "part def A;\n", Line: 2}, {Text: "1 + 2", Line: 4}, {Meta: true, Text: "%print A", Line: 5}}},
+		{"declarations after an expression start on their own line", "1 + 2\n\npart def A;\n%help\n\npart def B;", []Statement{{Text: "1 + 2", Line: 1}, {Text: "part def A;", Line: 3}, {Meta: true, Text: "%help", Line: 4}, {Text: "part def B;", Line: 6}}},
 	}
 	for _, tc := range cases {
 		t.Run(tc.name, func(t *testing.T) {
diff --git a/internal/frontend/repl/complete.go b/internal/frontend/repl/complete.go
index b4dd10d271..17952da087 100644
--- a/internal/frontend/repl/complete.go
+++ b/internal/frontend/repl/complete.go
@@ -48,10 +48,22 @@ func (s *Session) Complete(line string, pos int) Completion {
 	if word := lastField(head); strings.HasPrefix(word, "%") && word == command {
 		return completion(word, matchingPrefix(metaCommands(), word))
 	}
+	if command == "%load" || command == "%publish" {
+		if candidates, ok := s.repositoryCompletions(command, lastField(head)); ok {
+			return completion(lastField(head), candidates)
+		}
+	}
 	if command == "%load" || command == "%save" {
 		word := lastField(head)
 		return completion(word, pathCompletions(word))
 	}
+	if command == "%documents" {
+		return completion(lastField(head), nil)
+	}
+	if command == "%views" {
+		word := lastField(head)
+		return completion(word, matchingPrefix(viewsArguments(), word))
+	}
 	// %render takes the form after the view name, which is no name to look up,
 	// and a palette after a form that fills nodes.
 	if command == "%render" && atSecondArgument(head) {
@@ -82,6 +94,9 @@ func (s *Session) Complete(line string, pos int) Completion {
 			}
 		}
 	}
+	if command == "%viz" {
+		return s.completeViz(head)
+	}
 	if command == "%render" && atPaletteArgument(head) {
 		word := lastField(head)
 		return completion(word, matchingPrefix(renderPalettes(), word))
@@ -708,3 +723,88 @@ func nextQualifier(text string, from int) int {
 	}
 	return -1
 }
+
+// completeViz offers %viz's words: the value of a --view or --style option being
+// typed, in the option's spelling or after it as its own word; the options
+// themselves at a dash; otherwise the names, and the forms until one is typed.
+func (s *Session) completeViz(head string) Completion {
+	word := lastField(head)
+	args := typedArgs(head)
+	previous := ""
+	if argumentIndex(head) >= 2 && len(args) >= 2 && !inUnfinishedName(head) {
+		previous = args[argumentIndex(head)-1]
+	}
+	switch {
+	case strings.HasPrefix(word, "--view="):
+		return completion(word, prefixed("--view=", matchingPrefixFold(vizViews(), strings.TrimPrefix(word, "--view="))))
+	case strings.HasPrefix(word, "--style="):
+		return completion(word, prefixed("--style=", matchingPrefixFold(vizStyles(), strings.TrimPrefix(word, "--style="))))
+	case strings.HasPrefix(word, "-"):
+		return completion(word, matchingPrefix([]string{"--view=", "--style="}, word))
+	case previous == "--view":
+		return completion(word, matchingPrefixFold(vizViews(), word))
+	case previous == "--style":
+		return completion(word, matchingPrefixFold(vizStyles(), word))
+	}
+	name := nameWord(head)
+	if vizFormTyped(args[:min(len(args), argumentIndex(head))]) {
+		return completion(name, s.nameCompletions(name))
+	}
+	// At an empty word the grammar is offered: the forms and the options; a
+	// name is offered once its first character narrows the thousands there are.
+	if name == "" {
+		return completion(name, append(renderForms(), "--view=", "--style="))
+	}
+	return completion(name, append(s.nameCompletions(name), matchingPrefix(renderForms(), name)...))
+}
+
+// vizFormTyped reports whether one of the finished words of a %viz line names
+// the form: a word standing alone, not the value of an option.
+func vizFormTyped(finished []string) bool {
+	for i := 1; i < len(finished); i++ {
+		if finished[i] == "--view" || finished[i] == "--style" {
+			i++
+			continue
+		}
+		if slices.Contains(renderForms(), finished[i]) {
+			return true
+		}
+	}
+	return false
+}
+
+// matchingPrefixFold is matchingPrefix in any letter case. Each match is offered
+// in the case the prefix is typed in — the values are read in any — so that it
+// begins with the prefix, as the prompt's insertion requires.
+func matchingPrefixFold(candidates []string, prefix string) []string {
+	out := make([]string, 0, len(candidates))
+	for _, c := range candidates {
+		if len(c) >= len(prefix) && strings.EqualFold(c[:len(prefix)], prefix) {
+			out = append(out, spelledLike(c, prefix))
+		}
+	}
+	return out
+}
+
+// spelledLike respells word in the letter case of prefix, a prefix of it in any
+// case: all lower or all upper when prefix is, otherwise prefix and the rest.
+func spelledLike(word, prefix string) string {
+	switch {
+	case strings.ToLower(prefix) == strings.ToUpper(prefix):
+		return word
+	case prefix == strings.ToLower(prefix):
+		return strings.ToLower(word)
+	case prefix == strings.ToUpper(prefix):
+		return strings.ToUpper(word)
+	}
+	return prefix + word[len(prefix):]
+}
+
+// prefixed puts an option's spelling before each of its values.
+func prefixed(option string, values []string) []string {
+	out := make([]string, len(values))
+	for i, value := range values {
+		out[i] = option + value
+	}
+	return out
+}
diff --git a/internal/frontend/repl/complete_test.go b/internal/frontend/repl/complete_test.go
index b1ae8fd2e4..132b6897c1 100644
--- a/internal/frontend/repl/complete_test.go
+++ b/internal/frontend/repl/complete_test.go
@@ -117,7 +117,7 @@ func TestCompleteNames(t *testing.T) {
 // TestCompletePaths covers the file paths %load and %save complete to.
 func TestCompletePaths(t *testing.T) {
 	dir := t.TempDir()
-	for _, name := range []string{"model.sysml", "other.sysml"} {
+	for _, name := range []string{"model.sysml", "other.sysml", "notes.ipynb"} {
 		if err := os.WriteFile(filepath.Join(dir, name), []byte("part def A;\n"), 0o600); err != nil {
 			t.Fatalf("write %s: %v", name, err)
 		}
@@ -135,7 +135,12 @@ func TestCompletePaths(t *testing.T) {
 		{
 			name:  "every entry of a directory",
 			line:  "%load " + dir + "/",
-			wants: []string{dir + "/model.sysml", dir + "/other.sysml", dir + "/nested/"},
+			wants: []string{dir + "/model.sysml", dir + "/other.sysml", dir + "/notes.ipynb", dir + "/nested/"},
+		},
+		{
+			name:  "a notebook completes after the cell selection",
+			line:  "%load --cells 1,3 " + dir + "/no",
+			wants: []string{dir + "/notes.ipynb"},
 		},
 		{
 			name:    "narrowed by what is typed",
diff --git a/internal/frontend/repl/fakeapi_test.go b/internal/frontend/repl/fakeapi_test.go
new file mode 100644
index 0000000000..9ad64b7225
--- /dev/null
+++ b/internal/frontend/repl/fakeapi_test.go
@@ -0,0 +1,331 @@
+package repl
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"sort"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+// fakeAPI is an in-memory SysML v2 API server speaking the standard resources
+// the pilot's does: projects, branches, commits with change payloads, elements
+// and roots, paged by a Link rel="next" header. No token, no Layer 1.
+type fakeAPI struct {
+	mu       sync.Mutex
+	server   *httptest.Server
+	projects map[string]*fakeProject
+	order    []string // project ids in creation order
+	pageSize int      // elements and projects per page
+	nextID   int
+	// conflict, when set, answers the next commit with 409 and this message.
+	conflict string
+	requests []string
+}
+
+type fakeProject struct {
+	id, name string
+	branches map[string]*fakeBranch
+	commits  map[string]map[string]json.RawMessage // commit id → element id → element
+	defaults string
+}
+
+type fakeBranch struct {
+	id, name, head string
+}
+
+func newFakeAPI() *fakeAPI {
+	f := &fakeAPI{projects: map[string]*fakeProject{}, pageSize: 2}
+	f.server = httptest.NewServer(http.HandlerFunc(f.serve))
+	return f
+}
+
+func (f *fakeAPI) Close() { f.server.Close() }
+
+func (f *fakeAPI) URL() string { return f.server.URL }
+
+func (f *fakeAPI) id(kind string) string {
+	f.nextID++
+	return fmt.Sprintf("%s-%04d", kind, f.nextID)
+}
+
+// addProject creates an empty project with a default branch, as the API's POST
+// /projects does, and returns it.
+func (f *fakeAPI) addProject(name string) *fakeProject {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	return f.createProject(name, "main")
+}
+
+func (f *fakeAPI) createProject(name, branch string) *fakeProject {
+	p := &fakeProject{id: f.id("project"), name: name, branches: map[string]*fakeBranch{}, commits: map[string]map[string]json.RawMessage{}}
+	b := &fakeBranch{id: f.id("branch"), name: branch}
+	p.branches[b.id] = b
+	p.defaults = b.id
+	f.projects[p.id] = p
+	f.order = append(f.order, p.id)
+	return p
+}
+
+// addBranch gives a project a branch at the head of its default branch.
+func (f *fakeAPI) addBranch(project, name string) *fakeBranch {
+	p := f.projects[project]
+	b := &fakeBranch{id: f.id("branch"), name: name, head: p.branches[p.defaults].head}
+	p.branches[b.id] = b
+	return b
+}
+
+func (f *fakeAPI) projectJSON(p *fakeProject) map[string]any {
+	return map[string]any{"@id": p.id, "@type": "Project", "name": p.name, "defaultBranch": map[string]any{"@id": p.defaults}}
+}
+
+func (f *fakeAPI) branchJSON(b *fakeBranch) map[string]any {
+	out := map[string]any{"@id": b.id, "@type": "Branch", "name": b.name, "head": nil}
+	if b.head != "" {
+		out["head"] = map[string]any{"@id": b.head, "@type": "Commit"}
+	}
+	return out
+}
+
+func writeJSON(w http.ResponseWriter, status int, v any) {
+	w.Header().Set("Content-Type", "application/json")
+	w.WriteHeader(status)
+	_ = json.NewEncoder(w).Encode(v)
+}
+
+func (f *fakeAPI) fail(w http.ResponseWriter, status int, msg string) {
+	writeJSON(w, status, map[string]any{"error": msg})
+}
+
+// page answers one page of items, linking to the next when there is one.
+func (f *fakeAPI) page(w http.ResponseWriter, r *http.Request, items []any, idOf func(any) string) {
+	after := r.URL.Query().Get("page[after]")
+	if after == "" {
+		after = r.URL.Query().Get("pageAfter")
+	}
+	start := 0
+	if after != "" {
+		for i, item := range items {
+			if idOf(item) == after {
+				start = i + 1
+			}
+		}
+	}
+	end := start + f.pageSize
+	if end > len(items) {
+		end = len(items)
+	}
+	if end < len(items) {
+		next := *r.URL
+		q := next.Query()
+		q.Set("page[after]", idOf(items[end-1]))
+		q.Set("page[size]", strconv.Itoa(f.pageSize))
+		next.RawQuery = q.Encode()
+		w.Header().Set("Link", fmt.Sprintf(`<%s>; rel="next"`, next.String()))
+	}
+	writeJSON(w, http.StatusOK, items[start:end])
+}
+
+func (f *fakeAPI) serve(w http.ResponseWriter, r *http.Request) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	f.requests = append(f.requests, r.Method+" "+r.URL.Path)
+	if r.Header.Get("Authorization") != "" {
+		f.fail(w, http.StatusBadRequest, "this server takes no token")
+		return
+	}
+	parts := strings.Split(strings.Trim(r.URL.Path, "/"), "/")
+	if parts[0] != "projects" {
+		f.fail(w, http.StatusNotFound, "no such resource")
+		return
+	}
+	if len(parts) == 1 {
+		switch r.Method {
+		case http.MethodGet:
+			items := make([]any, 0, len(f.order))
+			for _, id := range f.order {
+				items = append(items, f.projectJSON(f.projects[id]))
+			}
+			f.page(w, r, items, func(v any) string { return v.(map[string]any)["@id"].(string) })
+		case http.MethodPost:
+			var req struct {
+				Name          string `json:"name"`
+				DefaultBranch *struct {
+					Name string `json:"name"`
+				} `json:"defaultBranch"`
+			}
+			if err := json.NewDecoder(r.Body).Decode(&req); err != nil || req.Name == "" {
+				f.fail(w, http.StatusBadRequest, "a project needs a name")
+				return
+			}
+			branch := "main"
+			if req.DefaultBranch != nil && req.DefaultBranch.Name != "" {
+				branch = req.DefaultBranch.Name
+			}
+			writeJSON(w, http.StatusOK, f.projectJSON(f.createProject(req.Name, branch)))
+		default:
+			f.fail(w, http.StatusMethodNotAllowed, r.Method)
+		}
+		return
+	}
+	p, ok := f.projects[parts[1]]
+	if !ok {
+		f.fail(w, http.StatusNotFound, "project "+parts[1]+" not found")
+		return
+	}
+	if len(parts) == 2 {
+		writeJSON(w, http.StatusOK, f.projectJSON(p))
+		return
+	}
+	switch parts[2] {
+	case "branches":
+		if len(parts) == 3 {
+			ids := make([]string, 0, len(p.branches))
+			for id := range p.branches {
+				ids = append(ids, id)
+			}
+			sort.Strings(ids)
+			items := make([]any, 0, len(ids))
+			for _, id := range ids {
+				items = append(items, f.branchJSON(p.branches[id]))
+			}
+			f.page(w, r, items, func(v any) string { return v.(map[string]any)["@id"].(string) })
+			return
+		}
+		b, ok := p.branches[parts[3]]
+		if !ok {
+			f.fail(w, http.StatusNotFound, "branch "+parts[3]+" not found")
+			return
+		}
+		writeJSON(w, http.StatusOK, f.branchJSON(b))
+	case "commits":
+		f.serveCommits(w, r, p, parts[3:])
+	default:
+		f.fail(w, http.StatusNotFound, "no such resource")
+	}
+}
+
+func (f *fakeAPI) serveCommits(w http.ResponseWriter, r *http.Request, p *fakeProject, rest []string) {
+	if len(rest) == 0 {
+		if r.Method != http.MethodPost {
+			f.fail(w, http.StatusMethodNotAllowed, r.Method)
+			return
+		}
+		if f.conflict != "" {
+			msg := f.conflict
+			f.conflict = ""
+			f.fail(w, http.StatusConflict, msg)
+			return
+		}
+		b, ok := p.branches[r.URL.Query().Get("branchId")]
+		if !ok {
+			b = p.branches[p.defaults]
+		}
+		var req struct {
+			Change []struct {
+				Identity struct {
+					ID string `json:"@id"`
+				} `json:"identity"`
+				Payload json.RawMessage `json:"payload"`
+			} `json:"change"`
+		}
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
+			f.fail(w, http.StatusBadRequest, err.Error())
+			return
+		}
+		elements := map[string]json.RawMessage{}
+		for id, element := range p.commits[b.head] {
+			elements[id] = element
+		}
+		for _, change := range req.Change {
+			if string(change.Payload) == "null" || len(change.Payload) == 0 {
+				delete(elements, change.Identity.ID)
+				continue
+			}
+			elements[change.Identity.ID] = change.Payload
+		}
+		commit := f.id("commit")
+		p.commits[commit] = elements
+		b.head = commit
+		writeJSON(w, http.StatusOK, map[string]any{"@id": commit, "@type": "Commit"})
+		return
+	}
+	elements, ok := p.commits[rest[0]]
+	if !ok {
+		f.fail(w, http.StatusNotFound, "commit "+rest[0]+" not found")
+		return
+	}
+	ids := make([]string, 0, len(elements))
+	for id := range elements {
+		ids = append(ids, id)
+	}
+	sort.Strings(ids)
+	if len(rest) < 2 {
+		f.fail(w, http.StatusNotFound, "no such resource")
+		return
+	}
+	switch rest[1] {
+	case "elements":
+		if len(rest) == 3 {
+			element, ok := elements[rest[2]]
+			if !ok {
+				f.fail(w, http.StatusNotFound, "element "+rest[2]+" not found")
+				return
+			}
+			w.Header().Set("Content-Type", "application/json")
+			_, _ = w.Write(element)
+			return
+		}
+		items := make([]any, 0, len(ids))
+		for _, id := range ids {
+			items = append(items, elements[id])
+		}
+		f.page(w, r, items, func(v any) string {
+			var e struct {
+				ID string `json:"@id"`
+			}
+			_ = json.Unmarshal(v.(json.RawMessage), &e)
+			return e.ID
+		})
+	case "roots":
+		var roots []json.RawMessage
+		for _, id := range ids {
+			var e struct {
+				Owner *struct {
+					ID string `json:"@id"`
+				} `json:"owner"`
+			}
+			_ = json.Unmarshal(elements[id], &e)
+			if e.Owner == nil {
+				roots = append(roots, elements[id])
+			}
+		}
+		writeJSON(w, http.StatusOK, roots)
+	default:
+		f.fail(w, http.StatusNotFound, "no such resource")
+	}
+}
+
+// elementCount is how many elements a project's branch head holds.
+func (f *fakeAPI) elementCount(project, branch string) int {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	p := f.projects[project]
+	return len(p.commits[p.branches[branch].head])
+}
+
+// heldBytes is how many elements a project's branch head holds, and how many
+// bytes of JSON they amount to.
+func (f *fakeAPI) heldBytes(project, branch string) (count, size int) {
+	f.mu.Lock()
+	defer f.mu.Unlock()
+	p := f.projects[project]
+	for _, element := range p.commits[p.branches[branch].head] {
+		count++
+		size += len(element)
+	}
+	return count, size
+}
diff --git a/internal/frontend/repl/listing.go b/internal/frontend/repl/listing.go
new file mode 100644
index 0000000000..7cf1e7d66d
--- /dev/null
+++ b/internal/frontend/repl/listing.go
@@ -0,0 +1,255 @@
+package repl
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"slices"
+	"strconv"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/workspace/model"
+)
+
+// The categories a listing item is of.
+const (
+	ListDocument   = "document"
+	ListView       = "view"
+	ListPseudoView = "pseudo-view"
+)
+
+// ListItem is one document, view or pseudo-view a listing names. Name is the
+// qualified name as the notation writes it, which -render-document and -render
+// read back as the same element; File and Line locate the declaration.
+type ListItem struct {
+	Category  string    `json:"category"`
+	Name      string    `json:"name"`
+	Kind      view.Kind `json:"kind,omitempty"`
+	Supported *bool     `json:"supported,omitempty"`
+	Reason    string    `json:"reason,omitempty"`
+	File      string    `json:"file,omitempty"`
+	Line      int       `json:"line,omitempty"`
+}
+
+// DocumentItems lists document definitions as items, in the order given.
+func DocumentItems(defs []model.DocumentDefinition) []ListItem {
+	out := make([]ListItem, 0, len(defs))
+	for _, def := range defs {
+		out = append(out, ListItem{Category: ListDocument, Name: def.Notation, File: def.Doc, Line: def.Line})
+	}
+	return out
+}
+
+// ViewItems lists views as items, in the order given, an unsupported view
+// carrying the reason it is not produced.
+func ViewItems(views []model.ViewInfo) []ListItem {
+	out := make([]ListItem, 0, len(views))
+	for _, info := range views {
+		item := ListItem{
+			Category:  ListView,
+			Name:      info.Notation,
+			Kind:      info.Kind,
+			Supported: boolRef(info.Supported),
+			File:      info.Doc,
+			Line:      info.Line,
+		}
+		if !info.Supported {
+			item.Reason = info.Reason
+		}
+		out = append(out, item)
+	}
+	return out
+}
+
+// PseudoViewItems lists the pseudo-views a document is rendered through when
+// it declares no view of its own.
+func PseudoViewItems() []ListItem {
+	specs := view.PseudoViewSpecs()
+	out := make([]ListItem, 0, len(specs))
+	for _, spec := range specs {
+		kind := view.Kind(strings.TrimPrefix(spec, view.PseudoViewPrefix))
+		out = append(out, ListItem{Category: ListPseudoView, Name: spec, Kind: kind, Supported: boolRef(true)})
+	}
+	return out
+}
+
+func boolRef(b bool) *bool { return &b }
+
+// FilterViews keeps the views of the kinds named, every kind when none is, and
+// only the graph-shaped ones when diagrams is set.
+func FilterViews(views []model.ViewInfo, diagrams bool, kinds []view.Kind) []model.ViewInfo {
+	want := make(map[view.Kind]bool, len(kinds))
+	for _, kind := range kinds {
+		want[kind] = true
+	}
+	out := []model.ViewInfo{}
+	for _, info := range views {
+		if diagrams && !info.Kind.GraphShaped() {
+			continue
+		}
+		if len(want) > 0 && !want[info.Kind] {
+			continue
+		}
+		out = append(out, info)
+	}
+	return out
+}
+
+// ListText writes items one per line, the columns aligned: `document  <name>`,
+// `view  <kind>  <name>`, an unsupported view followed by the reason.
+func ListText(items []ListItem) []string {
+	categoryWidth, kindWidth := 0, 0
+	for _, item := range items {
+		categoryWidth = max(categoryWidth, len(item.Category))
+		kindWidth = max(kindWidth, len(item.Kind))
+	}
+	out := make([]string, 0, len(items))
+	for _, item := range items {
+		var b strings.Builder
+		b.WriteString(pad(item.Category, categoryWidth))
+		b.WriteString("  ")
+		if item.Category != ListDocument {
+			b.WriteString(pad(string(item.Kind), kindWidth))
+			b.WriteString("  ")
+		}
+		b.WriteString(escapeLineBreaks(item.Name))
+		if item.Supported != nil && !*item.Supported {
+			b.WriteString("  (unsupported: " + escapeLineBreaks(item.Reason) + ")")
+		}
+		out = append(out, b.String())
+	}
+	return out
+}
+
+func pad(s string, width int) string {
+	return s + strings.Repeat(" ", width-len(s))
+}
+
+// listTSVHeader is the header record of the tab-separated listing.
+const listTSVHeader = "category\tkind\tsupported\tfile\tline\tname\treason"
+
+// WriteListTSV writes items as tab-separated values under a header record;
+// nothing at all when there are none.
+func WriteListTSV(w io.Writer, items []ListItem) error {
+	if len(items) == 0 {
+		return nil
+	}
+	var b strings.Builder
+	b.WriteString(listTSVHeader + "\n")
+	for _, item := range items {
+		supported, line := "", ""
+		if item.Supported != nil {
+			supported = strconv.FormatBool(*item.Supported)
+		}
+		if item.Line > 0 {
+			line = strconv.Itoa(item.Line)
+		}
+		fields := []string{item.Category, string(item.Kind), supported, item.File, line, item.Name, item.Reason}
+		for i, field := range fields {
+			fields[i] = tsvField(field)
+		}
+		b.WriteString(strings.Join(fields, "\t") + "\n")
+	}
+	_, err := io.WriteString(w, b.String())
+	return err
+}
+
+// WriteListJSON writes items as a JSON array; nothing at all when there are none.
+func WriteListJSON(w io.Writer, items []ListItem) error {
+	if len(items) == 0 {
+		return nil
+	}
+	data, err := json.MarshalIndent(items, "", "  ")
+	if err != nil {
+		return fmt.Errorf("write listing: %w", err)
+	}
+	_, err = w.Write(append(data, '\n'))
+	return err
+}
+
+// escapeLineBreaks keeps a field on its line, writing a line break as the notation's
+// escape for it.
+func escapeLineBreaks(s string) string {
+	return strings.NewReplacer("\r", `\r`, "\n", `\n`).Replace(s)
+}
+
+// tsvField keeps a field within its column and its record.
+func tsvField(s string) string {
+	return strings.NewReplacer("\t", `\t`, "\r", `\r`, "\n", `\n`).Replace(s)
+}
+
+// ListDocuments lists the document definitions the session's model declares.
+func (s *Session) ListDocuments() []ListItem {
+	defer s.enter()()
+	return s.listDocuments()
+}
+
+func (s *Session) listDocuments() []ListItem {
+	return DocumentItems(s.ws.DocumentDefinitions())
+}
+
+// ListViews lists the views the session's model declares, those of the kinds
+// named when any are, and only the graph-shaped ones when diagrams is set.
+func (s *Session) ListViews(diagrams bool, kinds []view.Kind) []ListItem {
+	defer s.enter()()
+	return s.listViews(diagrams, kinds)
+}
+
+func (s *Session) listViews(diagrams bool, kinds []view.Kind) []ListItem {
+	return ViewItems(FilterViews(s.ws.AllViews(), diagrams, kinds))
+}
+
+// viewsDiagrams is the %views argument keeping the graph-shaped views.
+const viewsDiagrams = "diagrams"
+
+const viewsUsage = "usage: %views [diagrams] [<kind>...]"
+
+// doDocuments answers %documents.
+func (s *Session) doDocuments() ([]string, bool, error) {
+	lines := ListText(s.listDocuments())
+	if len(lines) == 0 {
+		return []string{"(no documents)"}, false, nil
+	}
+	return lines, false, nil
+}
+
+// doViews answers %views: every view, or those of the kinds the arguments name.
+func (s *Session) doViews(args []string) ([]string, bool, error) {
+	diagrams := false
+	var kinds []view.Kind
+	for _, arg := range args {
+		if arg == viewsDiagrams {
+			diagrams = true
+			continue
+		}
+		kind := view.Kind(arg)
+		if !slices.Contains(view.Kinds(), kind) {
+			return []string{fmt.Sprintf("error: unknown view kind %q; %%views takes diagrams or %s", arg, ViewKindList()), viewsUsage}, false, nil
+		}
+		kinds = append(kinds, kind)
+	}
+	lines := ListText(s.listViews(diagrams, kinds))
+	if len(lines) == 0 {
+		return []string{"(no views)"}, false, nil
+	}
+	return lines, false, nil
+}
+
+// viewsArguments are the words %views takes.
+func viewsArguments() []string {
+	out := []string{viewsDiagrams}
+	for _, kind := range view.Kinds() {
+		out = append(out, string(kind))
+	}
+	return out
+}
+
+// ViewKindList names the view kinds, as a refusal lists them.
+func ViewKindList() string {
+	names := make([]string, 0, len(view.Kinds()))
+	for _, kind := range view.Kinds() {
+		names = append(names, string(kind))
+	}
+	return strings.Join(names, ", ")
+}
diff --git a/internal/frontend/repl/listing_test.go b/internal/frontend/repl/listing_test.go
new file mode 100644
index 0000000000..f47acfae61
--- /dev/null
+++ b/internal/frontend/repl/listing_test.go
@@ -0,0 +1,115 @@
+package repl
+
+import (
+	"slices"
+	"strings"
+	"testing"
+)
+
+const listingModel = `package 'My Pkg' {
+	private import DocumentQueries::*;
+	private import Views::*;
+	private import StandardViewDefinitions::*;
+
+	part def Widget { part cog : Cog; }
+	part def Cog;
+	part def 'Doc "A"' :> Document { attribute redefines title = "A"; }
+	part def 'line\nbreak' :> Document { attribute redefines title = "B"; }
+
+	view 'v one' { expose Widget; }
+	view 'x::y' : GridView { expose Widget; }
+	view states : StateTransitionView { expose Widget; }
+	view geo : GeometryView { expose Widget; }
+}
+`
+
+func listingSession(t *testing.T) *Session {
+	t.Helper()
+	s := NewSession()
+	if res := s.Submit(listingModel); len(errorDiagnostics(res.Diagnostics)) > 0 {
+		t.Fatalf("model did not analyse cleanly: %v", res.Diagnostics)
+	}
+	return s
+}
+
+// %documents lists the documents by the names %render-document reads, in the
+// text form -list writes.
+func TestDocumentsCommand(t *testing.T) {
+	s := listingSession(t)
+	got := run(t, s, "%documents")
+	want := strings.Join([]string{
+		`document  'My Pkg'::'Doc "A"'`,
+		`document  'My Pkg'::'line\nbreak'`,
+	}, "\n")
+	if got != want {
+		t.Errorf("%%documents =\n%s\nwant\n%s", got, want)
+	}
+	if got != strings.Join(ListText(s.ListDocuments()), "\n") {
+		t.Errorf("%%documents does not write the listing's text form:\n%s", got)
+	}
+	if !strings.Contains(run(t, s, `%render-document 'My Pkg'::'line\nbreak'`), "# B") {
+		t.Error("a listed document name does not resolve through %render-document")
+	}
+	wants(t, run(t, NewSession(), "%documents"), "(no documents)")
+}
+
+// %views lists every view, the graph-shaped ones under diagrams, and those of
+// the kinds named; an unknown kind is refused with the kinds there are.
+func TestViewsCommand(t *testing.T) {
+	s := listingSession(t)
+	all := run(t, s, "%views")
+	want := strings.Join([]string{
+		`view  geometry  'My Pkg'::geo  (unsupported: 'My Pkg'::geo: geometry rendering (view def GeometryView) is not supported)`,
+		`view  state     'My Pkg'::states`,
+		`view  tree      'My Pkg'::'v one'`,
+		`view  table     'My Pkg'::'x::y'`,
+	}, "\n")
+	if all != want {
+		t.Errorf("%%views =\n%s\nwant\n%s", all, want)
+	}
+	if all != strings.Join(ListText(s.ListViews(false, nil)), "\n") {
+		t.Errorf("%%views does not write the listing's text form:\n%s", all)
+	}
+	if got := run(t, s, "%views diagrams"); got != "view  state  'My Pkg'::states\nview  tree   'My Pkg'::'v one'" {
+		t.Errorf("%%views diagrams =\n%s", got)
+	}
+	if got := run(t, s, "%views table geometry"); !strings.Contains(got, "'My Pkg'::'x::y'") ||
+		!strings.Contains(got, "'My Pkg'::geo") || strings.Contains(got, "'v one'") {
+		t.Errorf("%%views table geometry =\n%s", got)
+	}
+	if got := run(t, s, "%views diagrams table"); got != "(no views)" {
+		t.Errorf("%%views diagrams table =\n%s", got)
+	}
+	wants(t, run(t, s, "%views bogus"), `unknown view kind "bogus"`, "diagrams or tree, interconnection", viewsUsage)
+	if !strings.Contains(run(t, s, `%render 'My Pkg'::'x::y'`), "table rendering") {
+		t.Error("a listed view name does not resolve through %render")
+	}
+}
+
+// %documents and %views are listed in %help's session group and completed, the
+// %views kinds with them.
+func TestListingCommandsInHelpAndCompletion(t *testing.T) {
+	s := NewSession()
+	help := run(t, s, "%help")
+	session := help[strings.Index(help, groupSession):]
+	if next := strings.Index(session[len(groupSession):], ":\n"); next >= 0 {
+		session = session[:len(groupSession)+next]
+	}
+	wants(t, session, "%documents", "%views [diagrams] [<kind>...]")
+	for prefix, want := range map[string]string{"%docu": "%documents", "%vie": "%views"} {
+		if comp := s.Complete(prefix, len(prefix)); !slices.Contains(comp.Candidates, want) {
+			t.Errorf("completing %q: want %q in %v", prefix, want, comp.Candidates)
+		}
+	}
+	line := "%views "
+	comp := s.Complete(line, len(line))
+	for _, want := range []string{"diagrams", "tree", "state", "action", "table"} {
+		if !slices.Contains(comp.Candidates, want) {
+			t.Errorf("completing %q: want %q in %v", line, want, comp.Candidates)
+		}
+	}
+	line = "%views st"
+	if comp := s.Complete(line, len(line)); !slices.Equal(comp.Candidates, []string{"state"}) {
+		t.Errorf("completing %q: %v, want [state]", line, comp.Candidates)
+	}
+}
diff --git a/internal/frontend/repl/load.go b/internal/frontend/repl/load.go
index 8694396419..680fb249c5 100644
--- a/internal/frontend/repl/load.go
+++ b/internal/frontend/repl/load.go
@@ -6,6 +6,7 @@ import (
 	"io/fs"
 
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+	"github.com/Open-MBEE/OpenSysML/internal/workspace/notebook"
 	"github.com/Open-MBEE/OpenSysML/internal/workspace/project"
 )
 
@@ -21,11 +22,11 @@ import (
 // lines from its start.
 func (s *Session) LoadPaths(paths []string) ([]string, error) {
 	defer s.enter()()
-	return s.loadPaths(paths)
+	return s.loadPaths(paths, loadOptions{})
 }
 
-func (s *Session) loadPaths(paths []string) ([]string, error) {
-	rep, err := s.loadPathsReport(paths)
+func (s *Session) loadPaths(paths []string, opts loadOptions) ([]string, error) {
+	rep, err := s.loadPathsReport(paths, opts)
 	if err != nil {
 		return nil, err
 	}
@@ -36,7 +37,7 @@ func (s *Session) loadPaths(paths []string) ([]string, error) {
 // LoadReport is what a load produced, in parts so a caller can keep what the
 // analysis found off the stream it prints results on.
 type LoadReport struct {
-	Loaded   []string // the files read, when more than one was
+	Loaded   []string // the files read, when more than one was, and what each notebook contributed
 	Found    []string // diagnostics and the notes that belong with them
 	Declared []string // what the load declared, empty if the analysis errored
 	Errors   bool     // whether the analysis found an error
@@ -46,30 +47,49 @@ type LoadReport struct {
 // analysis found apart from what the load declared.
 func (s *Session) LoadPathsReport(paths []string) (LoadReport, error) {
 	defer s.enter()()
-	return s.loadPathsReport(paths)
+	return s.loadPathsReport(paths, loadOptions{})
 }
 
-func (s *Session) loadPathsReport(paths []string) (LoadReport, error) {
+func (s *Session) loadPathsReport(paths []string, opts loadOptions) (LoadReport, error) {
 	files, err := ExpandPaths(paths)
 	if err != nil {
 		return LoadReport{}, err
 	}
-	srcs, err := s.readSources(s.withDependencies(files))
+	read, err := s.readWithDependencies(files, opts)
 	if err != nil {
 		return LoadReport{}, err
 	}
-	var loaded []string
-	if len(srcs) > 1 {
-		loaded = append(loaded, fmt.Sprintf("loaded %d files:", len(srcs)))
-		for _, src := range srcs {
-			loaded = append(loaded, "  "+src.Name)
-		}
+	srcs := read.files
+	loaded := append(loadedFiles(srcs), read.notes...)
+	if len(srcs) == 0 {
+		return LoadReport{Loaded: loaded, Errors: s.hasAnalysisErrors()}, nil
 	}
 	found, declared := renderSplit(s.submitFiles(srcs), s.verbosity)
 	found = append(found, conversionWarnings(srcs, s.verbosity)...)
 	return LoadReport{Loaded: loaded, Found: found, Declared: declared, Errors: s.hasAnalysisErrors()}, nil
 }
 
+// loadedFiles lists the files a load read when it read more than one, a
+// notebook counted once however many cells it contributed.
+func loadedFiles(srcs []SourceFile) []string {
+	var names []string
+	seen := map[string]bool{}
+	for _, src := range srcs {
+		name := src.Name
+		if src.Of != "" {
+			name = src.Of
+		}
+		if !seen[name] {
+			seen[name] = true
+			names = append(names, "  "+name)
+		}
+	}
+	if len(names) < 2 {
+		return nil
+	}
+	return append([]string{fmt.Sprintf("loaded %d files:", len(names))}, names...)
+}
+
 func conversionWarnings(files []SourceFile, verbosity Verbosity) []string {
 	if verbosity <= VerbosityQuiet {
 		return nil
@@ -84,8 +104,8 @@ func conversionWarnings(files []SourceFile, verbosity Verbosity) []string {
 }
 
 // ExpandPaths turns the paths a caller was given — files, directories to walk
-// for .sysml/.kerml files, or glob patterns — into the model files to load, in a
-// deterministic order and without duplicates.
+// for .sysml/.kerml files and .ipynb notebooks, or glob patterns — into the
+// sources to load, in a deterministic order and without duplicates.
 func ExpandPaths(paths []string) ([]string, error) {
 	files, err := project.Expand(expandHomes(paths))
 	if err != nil {
@@ -97,10 +117,34 @@ func ExpandPaths(paths []string) ([]string, error) {
 	return files, nil
 }
 
-// withDependencies appends to files the model files beside and below them that
-// declare a root namespace they import and neither they nor the library declare.
-func (s *Session) withDependencies(files []string) []string {
-	return append(files, project.Dependencies(files, s.ws.IsLibraryRoot)...)
+// reading is what readSources read: the sources a load submits, and what the
+// notebooks among them report of their cells.
+type reading struct {
+	files []SourceFile
+	notes []string
+	// deps is the same text under the paths the dependency search starts
+	// from, a notebook's cells under the notebook's path.
+	deps []project.Source
+}
+
+// readWithDependencies reads paths, then the model files beside and below them
+// that declare a root namespace they import and neither they nor the library
+// declare.
+func (s *Session) readWithDependencies(paths []string, opts loadOptions) (reading, error) {
+	read, err := s.readSources(paths, opts)
+	if err != nil {
+		return reading{}, err
+	}
+	deps := project.DependenciesOf(read.deps, s.ws.IsLibraryRoot)
+	if len(deps) == 0 {
+		return read, nil
+	}
+	more, err := s.readSources(deps, loadOptions{})
+	if err != nil {
+		return reading{}, err
+	}
+	read.files = append(read.files, more.files...)
+	return read, nil
 }
 
 // expandHomes expands a leading ~ in every path.
@@ -112,17 +156,33 @@ func expandHomes(paths []string) []string {
 	return out
 }
 
-// readSources reads every path into the file a load submits, under the name it
-// is reported by; the error is a *ReadError or a *ReservedNameError.
-func (s *Session) readSources(paths []string) ([]SourceFile, error) {
-	files := make([]SourceFile, 0, len(paths))
+// readSources reads every path into the sources a load submits, under the names
+// they are reported by — a notebook's cells each under its own; the error is a
+// *ReadError, a *ReservedNameError, or a notebook's refusal. opts picks the
+// cells of the notebooks; it is an error when no notebook was named.
+func (s *Session) readSources(paths []string, opts loadOptions) (reading, error) {
+	var read reading
+	notebooks := 0
 	for _, path := range paths {
+		if notebook.IsNotebook(path) {
+			notebooks++
+			cells, note, err := s.readNotebook(path, opts.cells)
+			if err != nil {
+				return reading{}, err
+			}
+			read.files = append(read.files, cells...)
+			read.notes = append(read.notes, note...)
+			for _, cell := range cells {
+				read.deps = append(read.deps, project.Source{Path: path, Content: []byte(cell.Text)})
+			}
+			continue
+		}
 		name, data, err := project.ReadFile(path)
 		if err != nil {
-			return nil, readError(name, err)
+			return reading{}, readError(name, err)
 		}
 		if err := reservedName(name); err != nil {
-			return nil, err
+			return reading{}, err
 		}
 		var warnings []string
 		text, converted := data, false
@@ -132,16 +192,20 @@ func (s *Session) readSources(paths []string) ([]SourceFile, error) {
 				warnings = append(warnings, message)
 			})
 			if err != nil {
-				return nil, fmt.Errorf("cannot convert %s: %w", name, err)
+				return reading{}, fmt.Errorf("cannot convert %s: %w", name, err)
 			}
 		}
 		var kind source.Kind
 		if converted {
 			kind = source.KindSysML
 		}
-		files = append(files, SourceFile{Name: name, Text: string(text), Kind: kind, Warnings: warnings})
+		read.files = append(read.files, SourceFile{Name: name, Text: string(text), Kind: kind, Warnings: warnings})
+		read.deps = append(read.deps, project.Source{Path: path, Content: text})
 	}
-	return files, nil
+	if notebooks == 0 && !opts.cells.IsZero() {
+		return reading{}, errors.New("--cells picks the cells of a notebook, and no .ipynb was named")
+	}
+	return read, nil
 }
 
 // ReservedNameError is a file a load refused because its name is the one the
diff --git a/internal/frontend/repl/loop.go b/internal/frontend/repl/loop.go
index b29ac645b0..71d096e630 100644
--- a/internal/frontend/repl/loop.go
+++ b/internal/frontend/repl/loop.go
@@ -56,7 +56,7 @@ func Loop(r LineReader, out io.Writer, s *Session) error {
 			printLines(w, metaOut)
 			_ = w.Flush()
 			if merr != nil {
-				printLines(w, []string{"error: " + merr.Error()})
+				printLines(w, metaErrorLines(merr))
 				_ = w.Flush()
 			}
 			if quit {
@@ -124,6 +124,16 @@ func bareExpression(src string) (string, bool) {
 	return trimmed, true
 }
 
+// metaErrorLines prints a meta command's error: every line of a usage error,
+// the first under the error prefix as the kernel's value; other errors as before.
+func metaErrorLines(err error) []string {
+	var usage *UsageError
+	if errors.As(err, &usage) && len(usage.Lines) > 0 {
+		return append([]string{errPrefix + usage.Error()}, usage.Lines[1:]...)
+	}
+	return []string{errPrefix + err.Error()}
+}
+
 func printLines(w io.Writer, lines []string) {
 	for _, l := range lines {
 		_, _ = io.WriteString(w, l+"\n")
diff --git a/internal/frontend/repl/meta.go b/internal/frontend/repl/meta.go
index c9de45b984..a524bc9b87 100644
--- a/internal/frontend/repl/meta.go
+++ b/internal/frontend/repl/meta.go
@@ -138,6 +138,7 @@ const (
 	timeLabel         = "  Time: "
 
 	groupSession    = "Session:"
+	groupRepository = "Repository:"
 	groupSettings   = "Settings:"
 	groupEngines    = "Analysis engines:"
 	groupChecks     = "Checking every schedule:"
@@ -183,14 +184,21 @@ func graphLinked() bool      { return replext.Graph() != nil }
 var metaCommandTable = []metaCommand{
 	{name: "%help", group: groupSession, desc: "show this help"},
 	{name: "%list", group: groupSession, desc: "list current session declarations"},
+	{name: "%documents", group: groupSession, desc: "list the model's documents by the names %render-document reads"},
+	{name: "%views", group: groupSession, args: "[diagrams] [<kind>...]", desc: "list the model's views and their kinds by the names %render reads; diagrams keeps the graph-shaped ones"},
 	{name: "%clear", group: groupSession, desc: "reset the session"},
-	{name: "%load", group: groupSession, args: "<path>...", desc: "submit the contents of files, directories or globs"},
+	{name: "%load", group: groupSession, args: "[--cells <sel>] <path>... | [--id=<project id>] [--name=<name>] [--branch=<branch>] [<name>]", desc: "submit the contents of files, directories or globs (a .ipynb notebook's code cells declare, --cells 1,3-5 or tag:<tag> picking cells), or load a repository project's model: named, by --id or by --name, at a branch or its default; a name that is a path on disk loads the files",
+		part: repositoryLinked, partArgs: "[--cells <sel>] <path>...", partDesc: "submit the contents of files, directories or globs; a .ipynb notebook's code cells declare, its % commands and expressions skipped, --cells 1,3-5 or tag:<tag> picking cells"},
 	{name: "%print", group: groupSession, args: "[name]", desc: "print the session model as SysML notation, or just the named element", linked: notationLinked},
 	{name: "%save", group: groupSession, args: "<file>", desc: "write the session model to a file (.sysml notation, or .ttl/.json RDF — experimental)", linked: notationLinked},
 	{name: cmdQuery, group: groupSession, args: "<oslc-query>", desc: "identify model elements using OSLC Query text", linked: positionalLinked},
 	{name: "%quit", group: groupSession, desc: "exit the REPL (also %exit)"},
 	{name: "%exit", group: groupSession, desc: "exit the REPL", alias: true},
 
+	{name: "%repo", group: groupRepository, args: "[<base path>]", desc: "show or set the base URL of the SysML v2 API server the repository commands address, seeded from FLEXO_SYSMLV2_URL; a bearer token, when the server wants one, is read from FLEXO_INTEROP_TOKEN", linked: repositoryLinked},
+	{name: "%projects", group: groupRepository, desc: "list the repository's projects, name and id", linked: repositoryLinked},
+	{name: "%publish", group: groupRepository, args: "[-d] [--project=<project name>] [--branch=<branch name>] <name>", desc: "publish the elements rooted in <name> to the repository: a new project named after it (or --project) when none is, else a new commit on the branch holding what changed; -d includes the derived properties", linked: repositoryLinked},
+
 	{name: "%verbosity", group: groupSettings, args: "[level]", desc: "show or set output level: quiet, normal or debug"},
 	{name: "%trace", group: groupSettings, args: "[on|off]", desc: "show or set execution tracing (evaluation, calc, action and state steps)"},
 	{name: "%strict", group: groupSettings, args: "[on|off]", desc: "show or set strict conformance: report notation no SysML v2 production admits as an error"},
@@ -219,6 +227,7 @@ var metaCommandTable = []metaCommand{
 	{name: "%view", group: groupLibrary, args: argName, desc: "show what a view exposes, and the views nested in it"},
 	{name: "%graphs", group: groupLibrary, args: argName, desc: "export the lowered graph of an action or state machine, and of every behavior it performs, as the canonical graphs:1 JSON an external engine is sent"},
 	{name: "%render", group: groupLibrary, args: "<name> [form [palette] [style] [ports] [link=<template>]]", desc: "render a view as the rendering it states — as text, as a Mermaid diagram, a Markdown table or relationship matrix, or as Graphviz DOT, PlantUML or D2, filled from a named palette, drawn in a style (pilot or cameo) and optionally linking elements to their source with a link template"},
+	{name: "%viz", group: groupLibrary, args: "[--view=<VIEW>] [--style=<STYLE>...] [form] <name> [<name>...]", desc: "draw the named elements on demand, with no view declared, as the pilot kernel's %viz does: VIEW is DEFAULT, TREE, INTERCONNECTION, STATE, ACTION, SEQUENCE, MIXED or CASE in any letter case, DEFAULT (the view when none is named) choosing the kind from what the names resolve to; each --style is a direction (TB, LR, RL, BT), a drawing style (pilot or cameo), a palette, a port display, or a pilot style that is accepted and noted as not drawn; the form is any %render form, text when none is named"},
 
 	{name: "%instantiate", group: groupRuntime, args: argName, desc: "create an instance of a part def"},
 	{name: "%eval", group: groupRuntime, args: "[in <name>|<path>|#<id> :] <expr>", desc: "evaluate an expression, in the named element or object when one is named"},
@@ -340,7 +349,7 @@ func (s *Session) runMeta(line string) (out []string, quit bool, err error) {
 		return []string{unknownCommandLine(fields[0])}, false, nil
 	}
 	for _, run := range []func([]string, string) (metaResult, bool){
-		s.metaSessionCommand, s.metaModelCommand, s.metaDebugCommand,
+		s.metaRepositoryCommand, s.metaSessionCommand, s.metaModelCommand, s.metaDebugCommand,
 	} {
 		if res, ok := run(fields, line); ok {
 			return res.out, res.quit, res.err
@@ -378,11 +387,19 @@ func (s *Session) metaSessionCommand(fields []string, line string) (metaResult,
 		return metaOut(decls, false, nil), true
 	case "%clear":
 		return metaOut(append([]string{"session cleared"}, s.clear()...), false, nil), true
+	case "%documents":
+		return metaOut(s.doDocuments()), true
+	case "%views":
+		return metaOut(s.doViews(fields[1:])), true
 	case "%load":
-		if len(fields) < 2 {
-			return metaOut([]string{"usage: %load <file|dir|glob>..."}, false, nil), true
+		paths, opts, perr := parseLoadArgs(fields[1:])
+		if perr != nil {
+			return metaOut(nil, false, perr), true
 		}
-		lines, lerr := s.loadPaths(pathArgs(fields[1:]))
+		if len(paths) == 0 {
+			return metaOut([]string{usageLoadPath}, false, nil), true
+		}
+		lines, lerr := s.loadPaths(paths, opts)
 		if lerr != nil {
 			return metaOut(nil, false, lerr), true
 		}
@@ -452,6 +469,8 @@ func (s *Session) metaSessionCommand(fields []string, line string) (metaResult,
 		return metaOut(s.doGraphs(fields[1])), true
 	case "%render":
 		return metaOut(s.metaRender(fields[1:])), true
+	case "%viz":
+		return metaOut(s.metaViz(fields[1:])), true
 	case "%render-run":
 		return metaOut(s.metaRenderRun(fields[1:])), true
 	case "%quit", "%exit":
@@ -915,16 +934,6 @@ func (s *Session) contextScope(sym *symbols.Symbol) *symbols.Scope {
 	return nil
 }
 
-// pathArgs is a command's path arguments with any notation quoting removed, so
-// a path holding a space can be written as a quoted name too.
-func pathArgs(args []string) []string {
-	out := make([]string, 0, len(args))
-	for _, arg := range args {
-		out = append(out, nameText(arg))
-	}
-	return out
-}
-
 // nameText is the text a quoted argument names, for a command matching a name
 // rather than resolving one: the quotes are notation, not part of the name.
 func nameText(arg string) string {
diff --git a/internal/frontend/repl/notebook.go b/internal/frontend/repl/notebook.go
new file mode 100644
index 0000000000..8a2b42d557
--- /dev/null
+++ b/internal/frontend/repl/notebook.go
@@ -0,0 +1,177 @@
+package repl
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/parser"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+	"github.com/Open-MBEE/OpenSysML/internal/workspace/notebook"
+)
+
+// loadOptions is what a load takes besides its paths: the cells to pick from
+// the notebooks among them, every cell when zero.
+type loadOptions struct {
+	cells notebook.Selection
+}
+
+// parseLoadArgs reads the arguments of `%load`: the paths, quoted as parseArgs
+// leaves them, and `--cells <selection>` or `--cells=<selection>` anywhere
+// among them. A path beginning with `--` is written `./--...`.
+func parseLoadArgs(args []string) ([]string, loadOptions, error) {
+	var (
+		paths []string
+		opts  loadOptions
+		cells bool
+	)
+	for i := 0; i < len(args); i++ {
+		arg := args[i]
+		if !strings.HasPrefix(arg, "--") {
+			paths = append(paths, nameText(arg))
+			continue
+		}
+		name, value, inline := strings.Cut(arg, "=")
+		if name != "--cells" {
+			lines := []string{usageLoadPath}
+			if repositoryLinked() {
+				lines = append(lines, usageLoadRepo)
+			}
+			return nil, loadOptions{}, &UsageError{Lines: append(lines, fmt.Sprintf("unknown option %s; %%load takes --cells <n,n-m|tag:<tag>>", name))}
+		}
+		if cells {
+			return nil, loadOptions{}, errors.New("--cells given twice; one selection picks the cells of every notebook named")
+		}
+		if !inline {
+			if i+1 == len(args) {
+				return nil, loadOptions{}, errors.New("--cells needs a selection: cells by position (1,3-5) or by tag (tag:<tag>)")
+			}
+			i++
+			value = nameText(args[i])
+		}
+		sel, err := notebook.ParseSelection(value)
+		if err != nil {
+			return nil, loadOptions{}, fmt.Errorf("--cells %s: %w", value, err)
+		}
+		opts.cells, cells = sel, true
+	}
+	return paths, opts, nil
+}
+
+// cellName names a notebook's code cell as a source: the notebook's path and
+// the cell's position among the code cells, which is how a diagnostic locates it.
+func cellName(path string, index int) string {
+	return fmt.Sprintf("%s cell %d", path, index)
+}
+
+// cellKey identifies a cell across the spellings of its notebook's path, as
+// fileKey does a file, so the cell reloaded by another spelling replaces itself.
+func cellKey(path string, index int) string {
+	return cellName(fileKey(path), index)
+}
+
+// readNotebook reads the code cells of the notebook at path that sel picks into
+// the sources a load submits, one per cell. A cell is loaded for what it
+// declares: its `%` command lines and its expressions are blanked rather than
+// run, in place so a diagnostic's line is the cell's. The lines report what was
+// loaded and what was passed over. A notebook written for another language, or
+// in another format, is refused.
+func (s *Session) readNotebook(path string, sel notebook.Selection) ([]SourceFile, []string, error) {
+	nb, err := notebook.Read(path)
+	if err != nil {
+		var format *notebook.FormatError
+		var language *notebook.LanguageError
+		if errors.As(err, &format) || errors.As(err, &language) {
+			return nil, nil, err
+		}
+		return nil, nil, readError(path, err)
+	}
+	picked, err := sel.Apply(nb)
+	if err != nil {
+		return nil, nil, err
+	}
+	report := notebookReport{name: path, of: len(nb.Cells), selection: sel}
+	var files []SourceFile
+	for _, cell := range picked {
+		name := cellName(path, cell.Index)
+		if err := reservedName(name); err != nil {
+			return nil, nil, err
+		}
+		file := SourceFile{Name: name, Key: cellKey(path, cell.Index), Kind: source.KindSysML, Of: path, Whole: sel.IsZero()}
+		if cell.Tagged(notebook.SkipTag) {
+			report.tagged = append(report.tagged, cell.Index)
+		} else {
+			file.Text = declarationsOf(cell.Source, &report)
+			report.cells++
+			report.declarations += len(declaredNames(parser.New(source.NewWithKind(name, []byte(file.Text), source.KindSysML)).ParseFile()))
+		}
+		// A cell loaded for nothing — passed over, or commands and expressions
+		// alone — is still submitted, so it replaces what it declared before.
+		files = append(files, file)
+	}
+	// A notebook read whole that contributes no cell still replaces what an
+	// earlier reading declared, as a file that now declares nothing does.
+	if len(files) == 0 && sel.IsZero() {
+		files = append(files, SourceFile{Name: path, Kind: source.KindSysML, Of: path, Whole: true})
+	}
+	return files, report.lines(), nil
+}
+
+// declarationsOf is the text of a cell as a load submits it: its declarations
+// where they stand, every `%` command line and expression line blank. The lines
+// passed over are counted into report.
+func declarationsOf(cell string, report *notebookReport) string {
+	lines := make([]string, strings.Count(cell, "\n")+1)
+	for _, stmt := range Statements(cell) {
+		count := strings.Count(stmt.Text, "\n") + 1
+		switch {
+		case stmt.Meta:
+			report.metaLines += count
+		case isExpression(stmt.Text):
+			report.exprLines += count
+		default:
+			copy(lines[stmt.Line-1:], strings.Split(stmt.Text, "\n"))
+		}
+	}
+	return strings.Join(lines, "\n")
+}
+
+// isExpression reports whether a statement Statements split off is an
+// expression the prompt would answer, not a declaration it would submit.
+func isExpression(text string) bool {
+	_, ok := bareExpression(text)
+	return ok
+}
+
+// notebookReport is what a load says of one notebook.
+type notebookReport struct {
+	name         string
+	selection    notebook.Selection
+	cells, of    int // code cells loaded, of those the notebook holds
+	declarations int // top-level declarations the loaded cells hold
+	metaLines    int // `%` command lines passed over
+	exprLines    int // expression lines passed over
+	tagged       []int
+}
+
+func (r notebookReport) lines() []string {
+	head := fmt.Sprintf("loaded %s: %d of %d code cells", r.name, r.cells, r.of)
+	if !r.selection.IsZero() {
+		head += fmt.Sprintf(" (--cells %s)", r.selection)
+	}
+	out := []string{head + fmt.Sprintf(", %d %s", r.declarations, plural(r.declarations, "declaration", "declarations"))}
+	if r.metaLines > 0 || r.exprLines > 0 {
+		var what []string
+		if r.metaLines > 0 {
+			what = append(what, fmt.Sprintf("%d %% command %s", r.metaLines, plural(r.metaLines, "line", "lines")))
+		}
+		if r.exprLines > 0 {
+			what = append(what, fmt.Sprintf("%d expression %s", r.exprLines, plural(r.exprLines, "line", "lines")))
+		}
+		out = append(out, "  skipped "+strings.Join(what, " and ")+": a loaded notebook declares; its commands are not run and its expressions not evaluated")
+	}
+	for _, index := range r.tagged {
+		out = append(out, fmt.Sprintf("  skipped cell %d: tagged %s", index, notebook.SkipTag))
+	}
+	return out
+}
diff --git a/internal/frontend/repl/notebook_test.go b/internal/frontend/repl/notebook_test.go
new file mode 100644
index 0000000000..a908397575
--- /dev/null
+++ b/internal/frontend/repl/notebook_test.go
@@ -0,0 +1,427 @@
+package repl
+
+import (
+	"encoding/json"
+	"errors"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func fixtureNotebook(name string) string {
+	return filepath.Join("..", "..", "..", "tests", "testdata", "notebooks", name)
+}
+
+// writeNotebook writes an nbformat 4 notebook whose code cells hold the given
+// sources, tagged as given, and returns its path.
+func writeNotebook(t *testing.T, path string, cells ...notebookCell) string {
+	t.Helper()
+	var raw []map[string]any
+	for _, c := range cells {
+		cell := map[string]any{"cell_type": "code", "metadata": map[string]any{}, "outputs": []any{}, "source": c.source}
+		if len(c.tags) > 0 {
+			cell["metadata"] = map[string]any{"tags": c.tags}
+		}
+		raw = append(raw, cell)
+	}
+	data, err := json.Marshal(map[string]any{
+		"cells":    raw,
+		"metadata": map[string]any{"kernelspec": map[string]any{"language": "sysml", "name": "sysml"}},
+		"nbformat": 4, "nbformat_minor": 5,
+	})
+	if err != nil {
+		t.Fatal(err)
+	}
+	return writeFile(t, path, string(data))
+}
+
+type notebookCell struct {
+	source string
+	tags   []string
+}
+
+func loadMeta(t *testing.T, s *Session, line string) string {
+	t.Helper()
+	out, _, err := s.RunMeta(line)
+	if err != nil {
+		t.Fatalf("%s: %v", line, err)
+	}
+	return strings.Join(out, "\n")
+}
+
+func TestLoadingANotebookSubmitsItsCodeCellsInOrder(t *testing.T) {
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+fixtureNotebook("plain.ipynb"))
+	if !strings.Contains(out, "loaded "+fixtureNotebook("plain.ipynb")+": 2 of 2 code cells, 2 declarations") {
+		t.Errorf("report:\n%s", out)
+	}
+	wheels, cars := strings.Index(out, "✓ package Wheels"), strings.Index(out, "✓ package Cars")
+	if wheels < 0 || cars < 0 || cars < wheels {
+		t.Errorf("want Wheels declared before Cars:\n%s", out)
+	}
+	if strings.Contains(out, "skipped") {
+		t.Errorf("a notebook of declarations alone has nothing to skip:\n%s", out)
+	}
+	if list := strings.Join(s.List(), "\n"); !strings.Contains(list, "Cars") {
+		t.Errorf("the loaded cells are not in the session:\n%s", list)
+	}
+}
+
+func TestLoadingANotebookSkipsItsCommandsAndExpressionsAndSaysSo(t *testing.T) {
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+fixtureNotebook("magics.ipynb"))
+	for _, want := range []string{
+		": 4 of 4 code cells, 2 declarations",
+		"skipped 3 % command lines and 4 expression lines: a loaded notebook declares; its commands are not run and its expressions not evaluated",
+		"✓ package Demo",
+		"✓ package Extra",
+	} {
+		if !strings.Contains(out, want) {
+			t.Errorf("want %q in:\n%s", want, out)
+		}
+	}
+	if strings.Contains(out, "= 17.0") || strings.Contains(out, "= 3") {
+		t.Errorf("an expression of the notebook was evaluated:\n%s", out)
+	}
+	if s.verbosity != VerbosityNormal {
+		t.Errorf("the notebook's %%verbosity quiet ran: verbosity is %v", s.verbosity)
+	}
+	eval, _, err := s.RunMeta("%eval Extra::spare.diameter")
+	if err != nil || !strings.Contains(strings.Join(eval, "\n"), "16.0") {
+		t.Errorf("the loaded declarations are not usable: %v %v", eval, err)
+	}
+}
+
+func TestACellTaggedSkipLoadIsPassedOver(t *testing.T) {
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+fixtureNotebook("tagged.ipynb"))
+	if !strings.Contains(out, ": 3 of 4 code cells, 3 declarations") || !strings.Contains(out, "skipped cell 2: tagged skip-load") {
+		t.Errorf("report:\n%s", out)
+	}
+	list := strings.Join(s.List(), "\n")
+	for _, want := range []string{"Model", "More", "Untagged"} {
+		if !strings.Contains(list, want) {
+			t.Errorf("want %s loaded:\n%s", want, list)
+		}
+	}
+	if strings.Contains(list, "Scratch") {
+		t.Errorf("the skip-load cell was loaded:\n%s", list)
+	}
+}
+
+func TestCellsArePickedByPositionOrTag(t *testing.T) {
+	for _, tt := range []struct{ line, wantReport string }{
+		{"%load " + fixtureNotebook("tagged.ipynb") + " --cells 1,3-4", ": 3 of 4 code cells (--cells 1,3-4), 3 declarations"},
+		{"%load --cells=tag:model " + fixtureNotebook("tagged.ipynb"), ": 2 of 4 code cells (--cells tag:model), 2 declarations"},
+	} {
+		s := NewSession()
+		out := loadMeta(t, s, tt.line)
+		if !strings.Contains(out, tt.wantReport) {
+			t.Errorf("%s:\n%s", tt.line, out)
+		}
+		list := strings.Join(s.List(), "\n")
+		if !strings.Contains(list, "Model") || !strings.Contains(list, "More") || strings.Contains(list, "Scratch") {
+			t.Errorf("%s loaded:\n%s", tt.line, list)
+		}
+	}
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+fixtureNotebook("tagged.ipynb")+" --cells 1,3-4")
+	if strings.Contains(out, "skipped cell") {
+		t.Errorf("a cell not picked is not reported skipped:\n%s", out)
+	}
+	if strings.Contains(out, "loaded 3 files:") {
+		t.Errorf("the picked cells of one notebook are not three files:\n%s", out)
+	}
+	if list := strings.Join(NewSession().List(), "\n"); strings.Contains(list, "Untagged") {
+		t.Errorf("cell 4 is not tagged model:\n%s", list)
+	}
+}
+
+func TestASkipLoadCellIsPassedOverEvenWhenPicked(t *testing.T) {
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+fixtureNotebook("tagged.ipynb")+" --cells 2")
+	if !strings.Contains(out, ": 0 of 4 code cells (--cells 2), 0 declarations") || !strings.Contains(out, "skipped cell 2: tagged skip-load") {
+		t.Errorf("report:\n%s", out)
+	}
+	if len(s.List()) != 0 {
+		t.Errorf("loaded %v", s.List())
+	}
+}
+
+func TestLoadRefusesWhatItCannotRead(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "a.sysml"), "package A { }\n")
+	for _, tt := range []struct{ name, line, want string }{
+		{"out of range", "%load " + fixtureNotebook("tagged.ipynb") + " --cells 2,9", "cells 2,9 selected, but the notebook has 4 code cells"},
+		{"tag no cell carries", "%load " + fixtureNotebook("tagged.ipynb") + " --cells tag:nope", "no code cell is tagged nope"},
+		{"python", "%load " + fixtureNotebook("python.ipynb"), "a python notebook"},
+		{"nbformat 3", "%load " + fixtureNotebook("nbformat3.ipynb"), "nbformat 3 is not read"},
+		{"malformed", "%load " + fixtureNotebook("malformed.ipynb"), "not a notebook"},
+		{"missing", "%load " + filepath.Join(dir, "nope.ipynb"), "cannot read"},
+		{"--cells without a notebook", "%load " + filepath.Join(dir, "a.sysml") + " --cells 1", "no .ipynb was named"},
+		{"--cells without a selection", "%load " + fixtureNotebook("plain.ipynb") + " --cells", "--cells needs a selection"},
+		{"--cells twice", "%load --cells 1 --cells 2 " + fixtureNotebook("plain.ipynb"), "--cells given twice"},
+		{"a bad selection", "%load " + fixtureNotebook("plain.ipynb") + " --cells 0", "not a cell position"},
+		{"an unknown option", "%load --tags x " + fixtureNotebook("plain.ipynb"), "unknown option --tags"},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			s := NewSession()
+			_, _, err := s.RunMeta(tt.line)
+			if err == nil || !strings.Contains(errorText(err), tt.want) {
+				t.Errorf("%s: err = %v, want %q", tt.line, err, tt.want)
+			}
+			if len(s.List()) != 0 {
+				t.Errorf("%s: a refused load declared %v", tt.line, s.List())
+			}
+		})
+	}
+}
+
+func TestDiagnosticsOfALoadedCellNameTheNotebookAndTheCell(t *testing.T) {
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+fixtureNotebook("broken.ipynb"))
+	if want := fixtureNotebook("broken.ipynb") + " cell 2:2:"; !strings.Contains(out, want) {
+		t.Errorf("want a diagnostic at %q in:\n%s", want, out)
+	}
+}
+
+func TestDiagnosticLinesAreTheCellsOwnDespiteSkippedLines(t *testing.T) {
+	dir := t.TempDir()
+	nb := writeNotebook(t, filepath.Join(dir, "a.ipynb"),
+		notebookCell{source: "package A { }\n"},
+		notebookCell{source: "%print A\n1 + 2\npackage B {\n  import Missing::X;\n}\n"},
+	)
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+nb)
+	if want := nb + " cell 2:4:"; !strings.Contains(out, want) {
+		t.Errorf("want a diagnostic at %q in:\n%s", want, out)
+	}
+}
+
+func TestReloadingANotebookRedeclaresIt(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "a.ipynb")
+	writeNotebook(t, path,
+		notebookCell{source: "package P { part def Wheel; }\n"},
+		notebookCell{source: "package Q { part def Axle; }\n"},
+	)
+	s := NewSession()
+	loadMeta(t, s, "%load "+path)
+	writeNotebook(t, path, notebookCell{source: "package P { part def Rim; }\n"})
+	out := loadMeta(t, s, "%load "+path)
+	if !strings.Contains(out, "✓ package P") {
+		t.Errorf("report:\n%s", out)
+	}
+	list := strings.Join(s.List(), "\n")
+	if strings.Contains(list, "Wheel") || strings.Contains(list, "Axle") {
+		t.Errorf("a stale declaration survived the reload:\n%s", list)
+	}
+	if !strings.Contains(list, "Rim") {
+		t.Errorf("the reloaded cell is not in the session:\n%s", list)
+	}
+}
+
+func TestReloadingPickedCellsKeepsTheOthers(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "a.ipynb")
+	writeNotebook(t, path,
+		notebookCell{source: "package P { part def Wheel; }\n"},
+		notebookCell{source: "package Q { part def Axle; }\n"},
+	)
+	s := NewSession()
+	loadMeta(t, s, "%load "+path)
+	writeNotebook(t, path,
+		notebookCell{source: "package P { part def Rim; }\n"},
+		notebookCell{source: "package Q { part def Hub; }\n"},
+	)
+	loadMeta(t, s, "%load "+path+" --cells 1")
+	list := strings.Join(s.List(), "\n")
+	if !strings.Contains(list, "Rim") || !strings.Contains(list, "Axle") || strings.Contains(list, "Wheel") || strings.Contains(list, "Hub") {
+		t.Errorf("want cell 1 refreshed and cell 2 as it was:\n%s", list)
+	}
+}
+
+func TestAPickedCellLoadedForNothingReplacesWhatItDeclared(t *testing.T) {
+	for _, tt := range []struct {
+		name string
+		cell notebookCell
+	}{
+		{"an expression now", notebookCell{source: "1 + 2\n"}},
+		{"tagged skip-load now", notebookCell{source: "package P { part def Old; }\n", tags: []string{"skip-load"}}},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			path := filepath.Join(t.TempDir(), "a.ipynb")
+			writeNotebook(t, path, notebookCell{source: "package P { part def Old; }\n"}, notebookCell{source: "package Q { part def Kept; }\n"})
+			s := NewSession()
+			loadMeta(t, s, "%load "+path+" --cells 1")
+			writeNotebook(t, path, tt.cell, notebookCell{source: "package Q { part def Kept; }\n"})
+			loadMeta(t, s, "%load "+path+" --cells 1")
+			list := strings.Join(s.List(), "\n")
+			if strings.Contains(list, "Old") {
+				t.Errorf("a stale declaration survived:\n%s", list)
+			}
+		})
+	}
+}
+
+func TestAPickedCellReloadedByAnotherSpellingReplacesItself(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "real.ipynb")
+	alias := filepath.Join(dir, "alias.ipynb")
+	if err := os.Symlink(path, alias); err != nil {
+		t.Skipf("no symlinks here: %v", err)
+	}
+	writeNotebook(t, path, notebookCell{source: "package P { part def Old; }\n"})
+	s := NewSession()
+	loadMeta(t, s, "%load "+path+" --cells 1")
+	writeNotebook(t, path, notebookCell{source: "package P { part def New; }\n"})
+	loadMeta(t, s, "%load "+alias+" --cells 1")
+	list := strings.Join(s.List(), "\n")
+	if strings.Contains(list, "Old") || !strings.Contains(list, "New") || strings.Count(list, "package P") != 1 {
+		t.Errorf("want the cell replaced once:\n%s", list)
+	}
+}
+
+func TestATypedDeclarationStillReplacesALoadedCell(t *testing.T) {
+	s := NewSession()
+	loadMeta(t, s, "%load "+fixtureNotebook("plain.ipynb"))
+	s.Submit("package Cars { part def Truck; }")
+	list := strings.Join(s.List(), "\n")
+	if strings.Contains(list, "wheels") || !strings.Contains(list, "Truck") {
+		t.Errorf("want the typed Cars to replace the loaded one:\n%s", list)
+	}
+}
+
+func TestANotebookDeclaringNothingReplacesWhatItDeclared(t *testing.T) {
+	dir := t.TempDir()
+	path := filepath.Join(dir, "a.ipynb")
+	writeNotebook(t, path, notebookCell{source: "package P { part def Wheel; }\n"})
+	s := NewSession()
+	loadMeta(t, s, "%load "+path)
+	writeNotebook(t, path, notebookCell{source: "1 + 2\n"})
+	out := loadMeta(t, s, "%load "+path)
+	if !strings.Contains(out, ": 1 of 1 code cells, 0 declarations") {
+		t.Errorf("report:\n%s", out)
+	}
+	if list := s.List(); len(list) != 0 {
+		t.Errorf("a stale declaration survived: %v", list)
+	}
+}
+
+func TestNotebooksAreLoadedBesideModelFiles(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "lib.sysml"), "package Lib { part def Base; }\n")
+	nb := writeNotebook(t, filepath.Join(dir, "model.ipynb"), notebookCell{source: "package M { part def Derived; }\n"})
+	writeFile(t, filepath.Join(dir, "README.md"), "not loaded\n")
+
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+dir)
+	if !strings.Contains(out, "loaded 2 files:") || !strings.Contains(out, "  "+nb) || strings.Contains(out, "cell 1\n") {
+		t.Errorf("want the notebook listed once among the files:\n%s", out)
+	}
+	if !strings.Contains(out, "✓ package Lib") || !strings.Contains(out, "✓ package M") {
+		t.Errorf("report:\n%s", out)
+	}
+
+	s = NewSession()
+	out = loadMeta(t, s, "%load "+filepath.Join(dir, "*.ipynb"))
+	if !strings.Contains(out, "✓ package M") || strings.Contains(out, "✓ package Lib") {
+		t.Errorf("a pattern picks notebooks:\n%s", out)
+	}
+}
+
+func TestANotebookPullsInTheSiblingsItImports(t *testing.T) {
+	dir := t.TempDir()
+	writeFile(t, filepath.Join(dir, "lib.sysml"), "package Lib { part def Base; }\n")
+	nb := writeNotebook(t, filepath.Join(dir, "model.ipynb"), notebookCell{source: "package M {\n  private import Lib::*;\n  part def Derived :> Base;\n}\n"})
+	s := NewSession()
+	out := loadMeta(t, s, "%load "+nb)
+	if !strings.Contains(out, "✓ package Lib") || !strings.Contains(out, "✓ package M") || strings.Contains(out, "error") {
+		t.Errorf("want Lib loaded as a dependency:\n%s", out)
+	}
+}
+
+func TestAQuotedNotebookPathLoads(t *testing.T) {
+	dir := filepath.Join(t.TempDir(), "with space")
+	nb := writeNotebook(t, filepath.Join(dir, "a.ipynb"), notebookCell{source: "package P { }\n"}, notebookCell{source: "package Q { }\n"})
+	s := NewSession()
+	out := loadMeta(t, s, `%load "`+nb+`" --cells "2"`)
+	if !strings.Contains(out, "✓ package Q") || strings.Contains(out, "✓ package P") {
+		t.Errorf("report:\n%s", out)
+	}
+}
+
+func TestPrintingALoadedCellsDeclarationWorks(t *testing.T) {
+	s := NewSession()
+	loadMeta(t, s, "%load "+fixtureNotebook("plain.ipynb"))
+	out, _, err := s.RunMeta("%print Cars")
+	if err != nil || !strings.Contains(strings.Join(out, "\n"), "part wheels : Wheel[4];") {
+		t.Errorf("%%print Cars = %v, %v", out, err)
+	}
+}
+
+func TestLoadPathsReportCarriesTheNotebookReport(t *testing.T) {
+	s := NewSession()
+	rep, err := s.LoadPathsReport([]string{fixtureNotebook("magics.ipynb")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	loaded := strings.Join(rep.Loaded, "\n")
+	if !strings.Contains(loaded, "4 of 4 code cells") || !strings.Contains(loaded, "skipped 3 % command lines") {
+		t.Errorf("Loaded = %v", rep.Loaded)
+	}
+	if rep.Errors {
+		t.Errorf("Found = %v", rep.Found)
+	}
+}
+
+func TestLoadFilesSummaryReadsNotebooks(t *testing.T) {
+	s := NewSession()
+	lines, err := s.LoadFilesSummary([]string{fixtureNotebook("plain.ipynb")})
+	if err != nil {
+		t.Fatal(err)
+	}
+	joined := strings.Join(lines, "\n")
+	if !strings.Contains(joined, "2 of 2 code cells") || !strings.Contains(joined, "Wheels") || !strings.Contains(joined, "Cars") {
+		t.Errorf("summary:\n%s", joined)
+	}
+}
+
+func TestHelpDescribesNotebookLoading(t *testing.T) {
+	out, _, err := NewSession().RunMeta("%help")
+	if err != nil {
+		t.Fatal(err)
+	}
+	joined := strings.Join(out, "\n")
+	if !strings.Contains(joined, "--cells") || !strings.Contains(joined, ".ipynb") {
+		t.Errorf("%%help does not describe notebook loading:\n%s", joined)
+	}
+}
+
+func TestANotebookInTheWorkingDirectoryLoadsByName(t *testing.T) {
+	dir := t.TempDir()
+	writeNotebook(t, filepath.Join(dir, "a.ipynb"), notebookCell{source: "package P { }\n"})
+	wd, err := os.Getwd()
+	if err != nil {
+		t.Fatal(err)
+	}
+	if err := os.Chdir(dir); err != nil {
+		t.Fatal(err)
+	}
+	defer func() { _ = os.Chdir(wd) }()
+	s := NewSession()
+	out := loadMeta(t, s, "%load a.ipynb")
+	if !strings.Contains(out, "loaded a.ipynb: 1 of 1 code cells, 1 declaration") {
+		t.Errorf("report:\n%s", out)
+	}
+}
+
+// errorText is an error's message, every line of a usage error's.
+func errorText(err error) string {
+	var usage *UsageError
+	if errors.As(err, &usage) {
+		return strings.Join(usage.Lines, "\n")
+	}
+	return err.Error()
+}
diff --git a/internal/frontend/repl/replext/all/all.go b/internal/frontend/repl/replext/all/all.go
index ac0a127abc..9690c27474 100644
--- a/internal/frontend/repl/replext/all/all.go
+++ b/internal/frontend/repl/replext/all/all.go
@@ -7,4 +7,5 @@ import (
 	_ "github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext/instancegraph" // registers the instance-graph REPL commands
 	_ "github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext/notation"      // registers the notation REPL commands
 	_ "github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext/positional"    // registers the positional REPL commands
+	_ "github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext/repository"    // registers the repository REPL commands
 )
diff --git a/internal/frontend/repl/replext/replext.go b/internal/frontend/repl/replext/replext.go
index 79a67701bf..8bc024294c 100644
--- a/internal/frontend/repl/replext/replext.go
+++ b/internal/frontend/repl/replext/replext.go
@@ -3,6 +3,8 @@
 package replext
 
 import (
+	"context"
+
 	"github.com/Open-MBEE/OpenSysML/internal/doc/docrender"
 	"github.com/Open-MBEE/OpenSysML/internal/exec/runtime"
 	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
@@ -95,3 +97,91 @@ func Positional() PositionalNamer { return positional }
 
 // Drawer is the registered diagram drawer, nil when none is linked.
 func Drawer() docrender.DiagramDrawer { return drawer }
+
+// ProjectInfo names one project of a repository.
+type ProjectInfo struct {
+	ID   string
+	Name string
+}
+
+// ProjectState is the branch a session's model was loaded from or published
+// to: what a later publish commits on top of. LastSeenCommit is the head the
+// session last read or wrote.
+type ProjectState struct {
+	Base           string // the server the state was read from
+	ProjectID      string
+	ProjectName    string
+	Branch         string
+	BranchName     string
+	LastSeenCommit string
+}
+
+// LoadRequest picks the project and branch %load reads: a project by id or
+// else by name, a branch by name or id or else the project's default.
+type LoadRequest struct {
+	ProjectID string
+	Name      string
+	Branch    string
+}
+
+// LoadResult is a loaded branch: its notation, ready to submit, and where it
+// came from.
+type LoadResult struct {
+	State    ProjectState
+	Notation []byte
+	Warnings []string
+}
+
+// PublishRequest publishes the elements rooted in one element of the session
+// model: Root is its qualified name, Project the project name (the element's
+// own name when empty), Branch the branch name (the default when empty), State
+// the branch the session loaded the project from, if it did.
+type PublishRequest struct {
+	Origin  string
+	Source  []byte
+	Root    string
+	Project string
+	Branch  string
+	Derived bool
+	State   *ProjectState
+}
+
+// PublishResult is what a publish did: the project and branch it wrote, the
+// commit it made (empty when the branch already agreed), and how many elements
+// it created, updated and deleted. Created reports a project made anew.
+type PublishResult struct {
+	State                     ProjectState
+	Commit                    string
+	Created, Updated, Deleted int
+	NewProject                bool
+	Notes                     []string
+}
+
+// Repository is what %repo, %projects, %load and %publish drive: a SysML v2 API
+// server addressed by base URL. Commands that reach the network take the base
+// URL every time, as %repo may change it between them.
+type Repository interface {
+	// DefaultURL is the base URL a session starts with, from the environment.
+	DefaultURL() string
+	// CheckURL refuses a base URL the transport policy does not allow.
+	CheckURL(base string) error
+	// Projects lists every project, paged through completely.
+	Projects(ctx context.Context, base string) ([]ProjectInfo, error)
+	// Load reads a branch head as notation.
+	Load(ctx context.Context, base string, req LoadRequest) (*LoadResult, error)
+	// Publish writes the elements rooted in one element as a project or a commit.
+	Publish(ctx context.Context, base string, req PublishRequest) (*PublishResult, error)
+}
+
+var repository Repository
+
+// RegisterRepository installs the repository the %repo family of commands drives.
+func RegisterRepository(r Repository) {
+	if repository != nil {
+		panic("replext: repository registered twice")
+	}
+	repository = r
+}
+
+// Repo returns the registered repository, nil when no binary linked one.
+func Repo() Repository { return repository }
diff --git a/internal/frontend/repl/replext/repository/confine_test.go b/internal/frontend/repl/replext/repository/confine_test.go
new file mode 100644
index 0000000000..7d278df035
--- /dev/null
+++ b/internal/frontend/repl/replext/repository/confine_test.go
@@ -0,0 +1,78 @@
+package repository
+
+import (
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+func element(prefix, id string) rdf.Term { return rdf.IRI(rdf.Element + prefix + id) }
+
+func owned(graph *rdf.Graph, prefix, owner, id string) {
+	graph.AddTriple(rdf.Triple{Subject: element(prefix, id), Predicate: rdf.IRI(rdf.SysML + "owner"), Object: element(prefix, owner)})
+}
+
+func named(graph *rdf.Graph, prefix, id string) {
+	graph.AddTriple(rdf.Triple{Subject: element(prefix, id), Predicate: rdf.IRI(rdf.SysML + "name"), Object: rdf.String(id)})
+}
+
+// TestConfineFindsTheRootUnderAnyQualifier: a branch whose ids carry a scope
+// qualifier still has its root found, so what was removed under it is
+// deleted, and what lies under other roots is left alone — on a tracked
+// branch; on an unloaded one, nothing is deleted at all.
+func TestConfineFindsTheRootUnderAnyQualifier(t *testing.T) {
+	for _, qualifier := range []string{"", "org.project:"} {
+		cut := rdf.NewGraph()
+		named(cut, "", "Vehicles")
+		owned(cut, "", "Vehicles", "Wheel")
+		remote := rdf.NewGraph()
+		named(remote, qualifier, "Vehicles")
+		owned(remote, qualifier, "Vehicles", "Wheel")
+		owned(remote, qualifier, "Vehicles", "Car")
+		owned(remote, qualifier, "Car", "wheels")
+		named(remote, qualifier, "Spare")
+		owned(remote, qualifier, "Spare", "Boat")
+		changes := func() *reposync.ChangeSet {
+			return &reposync.ChangeSet{Changes: []reposync.Change{
+				{Kind: reposync.KindUpdate, ID: "Wheel"},
+				{Kind: reposync.KindDelete, ID: "Car"},
+				{Kind: reposync.KindDelete, ID: "wheels"},
+				{Kind: reposync.KindDelete, ID: "Spare"},
+				{Kind: reposync.KindConflict, ID: "Boat", Conflict: reposync.ConflictRepositoryChanged},
+			}}
+		}
+
+		tracked := changes()
+		result := &replext.PublishResult{}
+		confine(tracked, cut, remote, element("", "Vehicles"), true, "Vehicles", result)
+		if ids := idsOf(tracked); ids != "Wheel Car wheels" {
+			t.Errorf("%q tracked: kept %q, want Wheel Car wheels", qualifier, ids)
+		}
+		if len(result.Notes) != 1 {
+			t.Errorf("%q tracked: notes %q", qualifier, result.Notes)
+		}
+
+		unseen := changes()
+		result = &replext.PublishResult{}
+		confine(unseen, cut, remote, element("", "Vehicles"), false, "Vehicles", result)
+		if ids := idsOf(unseen); ids != "Wheel" {
+			t.Errorf("%q untracked: kept %q, want Wheel", qualifier, ids)
+		}
+		if len(result.Notes) != 2 {
+			t.Errorf("%q untracked: notes %q", qualifier, result.Notes)
+		}
+	}
+}
+
+func idsOf(set *reposync.ChangeSet) string {
+	out := ""
+	for i, change := range set.Changes {
+		if i > 0 {
+			out += " "
+		}
+		out += change.ID
+	}
+	return out
+}
diff --git a/internal/frontend/repl/replext/repository/repository.go b/internal/frontend/repl/replext/repository/repository.go
new file mode 100644
index 0000000000..2529b6392b
--- /dev/null
+++ b/internal/frontend/repl/replext/repository/repository.go
@@ -0,0 +1,332 @@
+// Package repository links the %repo, %projects, %load and %publish commands to
+// a SysML v2 API server: any conformant one through the standard surface, with
+// a bearer token from the environment when the server wants one.
+package repository
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/convert"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/modelsync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/sysmlapi"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+func init() { replext.RegisterRepository(repository{}) }
+
+type repository struct{}
+
+// NotFoundError is a project or branch the server does not have.
+type NotFoundError struct {
+	What string // "project" or "branch"
+	Name string
+}
+
+func (e *NotFoundError) Error() string { return fmt.Sprintf("%s %s doesn't exist", e.What, e.Name) }
+
+// NoHeadError is a branch no commit has reached, which has no elements to load.
+type NoHeadError struct {
+	Branch string
+}
+
+func (e *NoHeadError) Error() string { return fmt.Sprintf("branch %s has no head commit", e.Branch) }
+
+func (repository) DefaultURL() string { return sysmlapi.ConfigFromEnv().BaseURL }
+
+func (repository) CheckURL(base string) error { return sysmlapi.CheckURL(base) }
+
+func client(base string) *sysmlapi.Client {
+	cfg := sysmlapi.ConfigFromEnv()
+	cfg.BaseURL = base
+	return sysmlapi.New(cfg)
+}
+
+func (repository) Projects(ctx context.Context, base string) ([]replext.ProjectInfo, error) {
+	projects, err := client(base).Projects(ctx)
+	if err != nil {
+		return nil, err
+	}
+	out := make([]replext.ProjectInfo, 0, len(projects))
+	for _, p := range projects {
+		out = append(out, replext.ProjectInfo{ID: p.ID, Name: p.Name})
+	}
+	return out, nil
+}
+
+// findProject resolves a project by id, else by name; a name several projects
+// share is refused naming them all.
+func findProject(ctx context.Context, c *sysmlapi.Client, id, name string) (sysmlapi.Project, error) {
+	if id != "" {
+		project, err := c.Project(ctx, id)
+		if sysmlapi.Status(err) == http.StatusNotFound {
+			return sysmlapi.Project{}, &NotFoundError{What: "project", Name: id}
+		}
+		return project, err
+	}
+	projects, err := c.Projects(ctx)
+	if err != nil {
+		return sysmlapi.Project{}, err
+	}
+	var matches []sysmlapi.Project
+	for _, p := range projects {
+		if p.Name == name {
+			matches = append(matches, p)
+		}
+	}
+	switch len(matches) {
+	case 0:
+		return sysmlapi.Project{}, &NotFoundError{What: "project", Name: name}
+	case 1:
+		return matches[0], nil
+	}
+	ids := make([]string, 0, len(matches))
+	for _, p := range matches {
+		ids = append(ids, p.ID)
+	}
+	return sysmlapi.Project{}, &modelsync.AmbiguousNameError{Name: name, IDs: ids}
+}
+
+// publishTarget is the project a publish by name means: the one the session
+// tracks under that name while the server still has it by that name, else
+// whatever the name resolves to now — a renamed or deleted one is no match.
+func publishTarget(ctx context.Context, c *sysmlapi.Client, id, name string) (sysmlapi.Project, error) {
+	if id != "" {
+		project, err := findProject(ctx, c, id, "")
+		var missing *NotFoundError
+		switch {
+		case err == nil && project.Name == name:
+			return project, nil
+		case err != nil && !errors.As(err, &missing):
+			return sysmlapi.Project{}, err
+		}
+	}
+	return findProject(ctx, c, "", name)
+}
+
+// findBranch resolves a branch by name or id, or the project's default branch
+// when none is named.
+func findBranch(ctx context.Context, c *sysmlapi.Client, project sysmlapi.Project, nameOrID string) (sysmlapi.Branch, error) {
+	branches, err := c.Branches(ctx, project.ID)
+	if err != nil {
+		return sysmlapi.Branch{}, err
+	}
+	want := nameOrID
+	if want == "" {
+		want = project.DefaultBranch.ID
+	}
+	for _, b := range branches {
+		if b.ID == want {
+			return b, nil
+		}
+	}
+	for _, b := range branches {
+		if nameOrID != "" && b.Name == nameOrID {
+			return b, nil
+		}
+	}
+	if nameOrID == "" {
+		if want == "" && len(branches) == 1 {
+			return branches[0], nil
+		}
+		return sysmlapi.Branch{}, &NotFoundError{What: "default branch", Name: want}
+	}
+	return sysmlapi.Branch{}, &NotFoundError{What: "branch", Name: nameOrID}
+}
+
+func stateOf(base string, project sysmlapi.Project, branch sysmlapi.Branch) replext.ProjectState {
+	return replext.ProjectState{
+		Base:      base,
+		ProjectID: project.ID, ProjectName: project.Name,
+		Branch: branch.ID, BranchName: branch.Name,
+		LastSeenCommit: branch.Head.ID,
+	}
+}
+
+func (repository) Load(ctx context.Context, base string, req replext.LoadRequest) (*replext.LoadResult, error) {
+	c := client(base)
+	project, err := findProject(ctx, c, req.ProjectID, req.Name)
+	if err != nil {
+		return nil, err
+	}
+	branch, err := findBranch(ctx, c, project, req.Branch)
+	if err != nil {
+		return nil, err
+	}
+	if branch.Head.ID == "" {
+		return nil, &NoHeadError{Branch: branch.Name}
+	}
+	repo := c.Repository(project.ID, branch.ID)
+	graph, err := repo.GraphAt(ctx, branch.Head.ID)
+	if err != nil {
+		return nil, err
+	}
+	result := &replext.LoadResult{State: stateOf(base, project, branch)}
+	scoped := modelsync.Scoped(graph, reposync.Scope{ProjectID: project.ID, Branch: branch.ID})
+	result.Notation, err = modelsync.Notation(scoped, func(w string) { result.Warnings = append(result.Warnings, w) })
+	if err != nil {
+		return nil, fmt.Errorf("the elements of %s could not be written as notation: %w", project.Name, err)
+	}
+	return result, nil
+}
+
+// simpleName is the name a root element publishes under when no project is
+// named: its declared name, else the last segment of its qualified name.
+func simpleName(graph *rdf.Graph, root rdf.Term, qualified string) string {
+	if name, ok := graph.Lexical(root, rdf.SysML+"declaredName"); ok && name != "" {
+		return name
+	}
+	if i := strings.LastIndex(qualified, "::"); i >= 0 {
+		return qualified[i+2:]
+	}
+	return qualified
+}
+
+func (repository) Publish(ctx context.Context, base string, req replext.PublishRequest) (*replext.PublishResult, error) {
+	whole, err := convert.SysMLToRDF(req.Origin, req.Source)
+	if err != nil {
+		return nil, err
+	}
+	cut, err := modelsync.Rooted(whole, req.Root)
+	if err != nil {
+		return nil, err
+	}
+	roots := modelsync.Roots(cut)
+	if len(roots) != 1 {
+		return nil, fmt.Errorf("%s does not cut to one root element", req.Root)
+	}
+	if !req.Derived {
+		cut = modelsync.WithoutDerived(cut)
+	}
+	name := req.Project
+	if name == "" {
+		name = simpleName(cut, roots[0], req.Root)
+	}
+
+	c := client(base)
+	result := &replext.PublishResult{}
+	// State from another server is no history of this one, whatever ids match.
+	known := req.State != nil && req.State.Base == base
+	// The project the session tracks under this name is the one meant, by id,
+	// so a namesake elsewhere on the server does not make the name ambiguous.
+	id := ""
+	if known && req.State.ProjectName == name {
+		id = req.State.ProjectID
+	}
+	project, err := publishTarget(ctx, c, id, name)
+	var missing *NotFoundError
+	switch {
+	case errors.As(err, &missing):
+		// The model has to diff cleanly before anything is created on the server.
+		if _, err := reposync.Diff(cut, rdf.NewGraph(), reposync.Options{Representation: sysmlapi.Representation{}}); err != nil {
+			return nil, err
+		}
+		if project, err = c.CreateProject(ctx, "", name, req.Branch); err != nil {
+			return nil, err
+		}
+		// The server fills in what the create left to it: the default branch.
+		if created, err := c.Project(ctx, project.ID); err == nil {
+			project = created
+		}
+		result.NewProject = true
+	case err != nil:
+		return nil, err
+	}
+	fail := func(err error) (*replext.PublishResult, error) {
+		if result.NewProject {
+			return nil, fmt.Errorf("project %s was created but holds no commit yet; publishing again commits into it: %w", projectLine(project), err)
+		}
+		return nil, err
+	}
+	want := req.Branch
+	if want == "" && known && req.State.ProjectID == project.ID {
+		want = req.State.Branch
+	}
+	branch, err := findBranch(ctx, c, project, want)
+	if err != nil {
+		return fail(err)
+	}
+
+	repo := c.Repository(project.ID, branch.ID)
+	scope := reposync.Scope{ProjectID: project.ID, Branch: branch.ID}
+	state := &reposync.State{ProjectID: project.ID, Branch: branch.ID}
+	tracked := known && req.State.ProjectID == project.ID && req.State.Branch == branch.ID
+	if tracked {
+		state.LastSeenCommit = req.State.LastSeenCommit
+		repo.Resume(state.LastSeenCommit)
+	}
+	opts := reposync.Options{Representation: sysmlapi.Representation{}, ConfirmDeletes: tracked}
+	if opts.Base, err = modelsync.Baseline(ctx, repo, state); err != nil {
+		return fail(err)
+	}
+	remote, err := repo.Graph(ctx)
+	if err != nil {
+		return fail(err)
+	}
+	set, err := reposync.Diff(modelsync.Scoped(cut, scope), remote, opts)
+	if err != nil {
+		return fail(err)
+	}
+	confine(set, cut, remote, roots[0], tracked, req.Root, result)
+	if err := set.Appliable(); err != nil {
+		return fail(fmt.Errorf("refused to publish: %w", err))
+	}
+	applied, err := modelsync.Apply(ctx, repo, set, state, "sysml %publish "+req.Root)
+	if err != nil {
+		return fail(err)
+	}
+	result.Commit = applied.Commit
+	result.Created, result.Updated, result.Deleted = applied.Created, applied.Updated, applied.Deleted
+	result.State = stateOf(base, project, branch)
+	result.State.LastSeenCommit = state.LastSeenCommit
+	return result, nil
+}
+
+func projectLine(project sysmlapi.Project) string {
+	return fmt.Sprintf("%s (%s)", project.Name, project.ID)
+}
+
+// confine keeps a publication to its root: the elements under it locally and
+// the elements under the same root on the branch. What the branch holds under
+// other roots is left as it is, neither deleted nor disputed; and a branch the
+// session never loaded keeps everything it holds, since nothing of it was seen.
+func confine(set *reposync.ChangeSet, cut, remote *rdf.Graph, root rdf.Term, tracked bool, name string, result *replext.PublishResult) {
+	within := map[string]bool{}
+	for _, subject := range cut.Subjects() {
+		within[rdf.LocalName(subject.Value)] = true
+	}
+	// The branch may qualify its ids; the root is the subject with the same
+	// effective id, as the diff matches elements.
+	for _, subject := range remote.Subjects() {
+		if rdf.LocalName(subject.Value) == rdf.LocalName(root.Value) {
+			for _, owned := range modelsync.RootedAt(remote, subject).Subjects() {
+				within[rdf.LocalName(owned.Value)] = true
+			}
+			break
+		}
+	}
+	kept := set.Changes[:0]
+	outside, unseen := 0, 0
+	for _, change := range set.Changes {
+		switch {
+		case !within[change.ID]:
+			outside++
+		case !tracked && change.Kind == reposync.KindDelete:
+			unseen++
+		default:
+			kept = append(kept, change)
+		}
+	}
+	set.Changes = kept
+	if outside > 0 {
+		result.Notes = append(result.Notes, fmt.Sprintf("%d element(s) the branch holds outside %s were left in place", outside, name))
+	}
+	if unseen > 0 {
+		result.Notes = append(result.Notes, fmt.Sprintf("%d element(s) of %s the branch holds beyond the model were left in place: the branch was not loaded into this session", unseen, name))
+	}
+}
diff --git a/internal/frontend/repl/repository.go b/internal/frontend/repl/repository.go
new file mode 100644
index 0000000000..65db26fa87
--- /dev/null
+++ b/internal/frontend/repl/repository.go
@@ -0,0 +1,344 @@
+package repl
+
+import (
+	"context"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+)
+
+// The repository commands drive a SysML v2 API server, as the pilot's notebook
+// kernel does: %repo names it, %projects lists it, %load reads a project's
+// branch into the session and %publish writes an element's tree back.
+
+func repositoryLinked() bool { return replext.Repo() != nil }
+
+const (
+	usageRepo     = "usage: %repo [<base path>]"
+	usageProjects = "usage: %projects"
+	usageLoadRepo = "usage: %load [--id=<project id>] [--name=<name>] [--branch=<branch name or id>] [<name>]"
+	usageLoadPath = "usage: %load [--cells <n,n-m|tag:<tag>>] <file|dir|glob|notebook>..."
+	usagePublish  = "usage: %publish [-d] [--project=<project name>] [--branch=<branch name>] <name>"
+)
+
+// completionTimeout bounds a project listing asked for by Tab completion.
+const completionTimeout = 2 * time.Second
+
+// repoBase is the base URL the repository commands address: the one %repo set,
+// else the environment's, held to the same transport rule %repo applies to a
+// URL it is given, so a token never leaves on a URL that was never checked.
+func (s *Session) repoBase() (string, error) {
+	if s.repoURL != "" {
+		return s.repoURL, nil
+	}
+	base := replext.Repo().DefaultURL()
+	if err := replext.Repo().CheckURL(base); err != nil {
+		return "", err
+	}
+	return base, nil
+}
+
+func (s *Session) metaRepositoryCommand(fields []string, _ string) (metaResult, bool) {
+	if !repositoryLinked() {
+		return metaResult{}, false
+	}
+	switch fields[0] {
+	case "%repo":
+		return s.doRepo(fields[1:]), true
+	case "%projects":
+		return s.doProjects(fields[1:]), true
+	case "%load":
+		if !s.loadsRepository(fields[1:]) {
+			return metaResult{}, false
+		}
+		return s.doLoadRepository(fields[1:]), true
+	case "%publish":
+		return s.doPublish(fields[1:]), true
+	}
+	return metaResult{}, false
+}
+
+func usageError(lines ...string) metaResult {
+	return metaOut(nil, false, &UsageError{Lines: lines})
+}
+
+func (s *Session) doRepo(args []string) metaResult {
+	switch len(args) {
+	case 0:
+		base, err := s.repoBase()
+		if err != nil {
+			return metaOut(nil, false, err)
+		}
+		return metaOut([]string{"API base path: " + base}, false, nil)
+	case 1:
+		base := strings.TrimRight(nameText(args[0]), "/")
+		if err := replext.Repo().CheckURL(base); err != nil {
+			return metaOut(nil, false, err)
+		}
+		s.repoURL = base
+		return metaOut([]string{"API base path: " + base}, false, nil)
+	}
+	return usageError(usageRepo)
+}
+
+func (s *Session) doProjects(args []string) metaResult {
+	if len(args) != 0 {
+		return usageError(usageProjects)
+	}
+	base, err := s.repoBase()
+	if err != nil {
+		return metaOut(nil, false, err)
+	}
+	projects, err := replext.Repo().Projects(s.command.context(), base)
+	if err != nil {
+		return metaOut(nil, false, err)
+	}
+	if len(projects) == 0 {
+		return metaOut([]string{"no projects"}, false, nil)
+	}
+	lines := make([]string, 0, len(projects))
+	for _, p := range projects {
+		lines = append(lines, projectLine(p.Name, p.ID))
+	}
+	return metaOut(lines, false, nil)
+}
+
+func projectLine(name, id string) string { return fmt.Sprintf("%s (%s)", name, id) }
+
+// loadsRepository tells a %load of a repository project from one of files: a
+// repository option names a project or a branch, and a lone name that names no
+// path names a project. Other options and the stdin "-" are the file load's.
+func (s *Session) loadsRepository(args []string) bool {
+	if len(args) == 0 {
+		return false
+	}
+	for _, arg := range args {
+		if strings.HasPrefix(arg, "--id") || strings.HasPrefix(arg, "--name") || strings.HasPrefix(arg, "--branch") {
+			return true
+		}
+	}
+	if len(args) != 1 || args[0] == "-" || strings.HasPrefix(args[0], "--") {
+		return false
+	}
+	return !namesPath(nameText(args[0]))
+}
+
+// namesPath tells a file argument from a project name: a path has a separator,
+// a model file's extension, a glob's wildcard, a home or relative prefix, or
+// is on disk. A project whose name reads as one is loaded by --name.
+func namesPath(arg string) bool {
+	if strings.ContainsAny(arg, `/\*?[`) || strings.HasPrefix(arg, "~") || strings.HasPrefix(arg, ".") {
+		return true
+	}
+	switch strings.ToLower(filepath.Ext(arg)) {
+	case ".sysml", ".kerml", ".ipynb":
+		return true
+	}
+	_, err := os.Stat(expandHome(arg))
+	return err == nil
+}
+
+// repoFlag reads `--name=value` as value; ok is false when arg is no such flag.
+func repoFlag(arg, name string) (value string, ok bool) {
+	return strings.CutPrefix(arg, "--"+name+"=")
+}
+
+// setRepoFlag stores the value of a `--option=value` argument in the field it
+// names, once: no field, no value and a second value are usage errors.
+func setRepoFlag(field *string, arg, usage, command string) error {
+	name, value, _ := strings.Cut(arg, "=")
+	if field == nil || value == "" {
+		return &UsageError{Lines: []string{usage, fmt.Sprintf("%s is not an option of %s", arg, command)}}
+	}
+	if *field != "" {
+		return &UsageError{Lines: []string{usage, fmt.Sprintf("%s was given twice", name)}}
+	}
+	*field = value
+	return nil
+}
+
+func (s *Session) doLoadRepository(args []string) metaResult {
+	var req replext.LoadRequest
+	for _, arg := range args {
+		switch {
+		case strings.HasPrefix(arg, "--"):
+			var field *string
+			switch {
+			case strings.HasPrefix(arg, "--id="):
+				field = &req.ProjectID
+			case strings.HasPrefix(arg, "--name="):
+				field = &req.Name
+			case strings.HasPrefix(arg, "--branch="):
+				field = &req.Branch
+			}
+			if err := setRepoFlag(field, arg, usageLoadRepo, "%load"); err != nil {
+				return metaOut(nil, false, err)
+			}
+		case req.Name != "" || req.ProjectID != "":
+			return usageError(usageLoadRepo, "name the project once: by --id, by --name or by itself")
+		default:
+			req.Name = nameText(arg)
+		}
+	}
+	if req.Name == "" && req.ProjectID == "" {
+		return usageError(usageLoadRepo, "name the project to load, or the files")
+	}
+	if req.Name != "" && req.ProjectID != "" {
+		return usageError(usageLoadRepo, "name the project once: by --id, by --name or by itself")
+	}
+	base, err := s.repoBase()
+	if err != nil {
+		return metaOut(nil, false, err)
+	}
+	loaded, err := replext.Repo().Load(s.command.context(), base, req)
+	if err != nil {
+		return metaOut(nil, false, err)
+	}
+	lines := []string{fmt.Sprintf("loaded project %s at branch %s, commit %s",
+		projectLine(loaded.State.ProjectName, loaded.State.ProjectID), branchLine(loaded.State), loaded.State.LastSeenCommit)}
+	for _, warning := range loaded.Warnings {
+		lines = append(lines, "warning: "+warning)
+	}
+	file := SourceFile{Name: repositoryDocName(loaded.State), Text: string(loaded.Notation), Kind: source.KindSysML}
+	found, declared := renderSplit(s.submitFiles([]SourceFile{file}), s.verbosity)
+	state := loaded.State
+	s.repoState = &state
+	return metaOut(append(append(lines, found...), declared...), false, nil)
+}
+
+func branchLine(state replext.ProjectState) string {
+	if state.BranchName == "" {
+		return state.Branch
+	}
+	return projectLine(state.BranchName, state.Branch)
+}
+
+// repositoryDocName is the session document a loaded project becomes: one per
+// project, so loading it again replaces the earlier load.
+func repositoryDocName(state replext.ProjectState) string {
+	return "project:" + state.ProjectID
+}
+
+func (s *Session) doPublish(args []string) metaResult {
+	req := replext.PublishRequest{Origin: sessionOrigin}
+	for _, arg := range args {
+		switch {
+		case arg == "-d":
+			if req.Derived {
+				return usageError(usagePublish, "-d was given twice")
+			}
+			req.Derived = true
+		case strings.HasPrefix(arg, "-"):
+			var field *string
+			switch {
+			case strings.HasPrefix(arg, "--project="):
+				field = &req.Project
+			case strings.HasPrefix(arg, "--branch="):
+				field = &req.Branch
+			}
+			if err := setRepoFlag(field, arg, usagePublish, "%publish"); err != nil {
+				return metaOut(nil, false, err)
+			}
+		case req.Root != "":
+			return usageError(usagePublish, "name one element to publish")
+		default:
+			req.Root = arg
+		}
+	}
+	if req.Root == "" {
+		return usageError(usagePublish, "name the element to publish")
+	}
+	_, fqn, err := s.lookupSymbol(req.Root)
+	if err != nil {
+		return metaOut([]string{errPrefix + err.Error()}, false, nil)
+	}
+	req.Root = fqn
+	req.Source = []byte(s.text())
+	req.State = s.repoState
+	base, err := s.repoBase()
+	if err != nil {
+		return metaOut(nil, false, err)
+	}
+	published, err := replext.Repo().Publish(s.command.context(), base, req)
+	if err != nil {
+		return metaOut(nil, false, err)
+	}
+	var lines []string
+	if published.NewProject {
+		lines = append(lines, "created project "+projectLine(published.State.ProjectName, published.State.ProjectID))
+	}
+	if published.Commit == "" {
+		lines = append(lines, fmt.Sprintf("nothing to publish: branch %s already holds %s", branchLine(published.State), fqn))
+	} else {
+		lines = append(lines, fmt.Sprintf("commit %s on branch %s of %s: %d created, %d updated, %d deleted",
+			published.Commit, branchLine(published.State), projectLine(published.State.ProjectName, published.State.ProjectID),
+			published.Created, published.Updated, published.Deleted))
+	}
+	lines = append(lines, published.Notes...)
+	state := published.State
+	s.repoState = &state
+	return metaOut(lines, false, nil)
+}
+
+// repositoryCompletions answers Tab after a repository command: the flags a
+// `-` starts (the file load's --cells among %load's), project names otherwise,
+// from the server when it answers in time.
+func (s *Session) repositoryCompletions(command, word string) ([]string, bool) {
+	if !repositoryLinked() {
+		return nil, false
+	}
+	flags := map[string][]string{
+		"%load":    {"--id=", "--name=", "--branch=", "--cells="},
+		"%publish": {"-d", "--project=", "--branch="},
+	}[command]
+	if flags == nil {
+		return nil, false
+	}
+	if strings.HasPrefix(word, "-") {
+		if value, ok := repoFlag(word, "name"); ok {
+			return prefixed("--name=", matchingPrefix(s.projectNames(), value)), true
+		}
+		if value, ok := repoFlag(word, "project"); ok {
+			return prefixed("--project=", matchingPrefix(s.projectNames(), value)), true
+		}
+		if value, ok := repoFlag(word, "id"); ok {
+			return prefixed("--id=", matchingPrefix(s.projectIDs(), value)), true
+		}
+		return matchingPrefix(flags, word), true
+	}
+	if command == "%load" {
+		return append(pathCompletions(word), matchingPrefix(s.projectNames(), word)...), true
+	}
+	return nil, false
+}
+
+func (s *Session) projectNames() []string {
+	return s.projectField(func(p replext.ProjectInfo) string { return p.Name })
+}
+
+func (s *Session) projectIDs() []string {
+	return s.projectField(func(p replext.ProjectInfo) string { return p.ID })
+}
+
+func (s *Session) projectField(field func(replext.ProjectInfo) string) []string {
+	base, err := s.repoBase()
+	if err != nil {
+		return nil
+	}
+	ctx, cancel := context.WithTimeout(context.Background(), completionTimeout)
+	defer cancel()
+	projects, err := replext.Repo().Projects(ctx, base)
+	if err != nil {
+		return nil
+	}
+	out := make([]string, 0, len(projects))
+	for _, p := range projects {
+		out = append(out, field(p))
+	}
+	return out
+}
diff --git a/internal/frontend/repl/repository_test.go b/internal/frontend/repl/repository_test.go
new file mode 100644
index 0000000000..a491675731
--- /dev/null
+++ b/internal/frontend/repl/repository_test.go
@@ -0,0 +1,629 @@
+package repl
+
+import (
+	"errors"
+	"sort"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext"
+)
+
+const vehicles = `package Vehicles {
+	part def Wheel { attribute radius : ScalarValues::Real; }
+	part def Car { part wheels : Wheel[4]; }
+}
+package Spare { part def Boat; }
+`
+
+// repoSession is a session addressing a fake server, started with the
+// environment the commands read their default from.
+func repoSession(t *testing.T) (*Session, *fakeAPI) {
+	t.Helper()
+	if replext.Repo() == nil {
+		t.Fatal("no repository extension is linked")
+	}
+	api := newFakeAPI()
+	t.Cleanup(api.Close)
+	t.Setenv("FLEXO_SYSMLV2_URL", api.URL())
+	t.Setenv("FLEXO_INTEROP_TOKEN", "")
+	return NewSession(), api
+}
+
+func runMeta(t *testing.T, s *Session, line string) []string {
+	t.Helper()
+	out, _, err := s.RunMeta(line)
+	if err != nil {
+		t.Fatalf("%s: %v\n%s", line, err, strings.Join(out, "\n"))
+	}
+	return out
+}
+
+func metaErr(t *testing.T, s *Session, line string) error {
+	t.Helper()
+	out, _, err := s.RunMeta(line)
+	if err == nil {
+		t.Fatalf("%s succeeded:\n%s", line, strings.Join(out, "\n"))
+	}
+	return err
+}
+
+func wantUsage(t *testing.T, err error, line string) {
+	t.Helper()
+	var usage *UsageError
+	if !errors.As(err, &usage) {
+		t.Fatalf("%s: %v is no *UsageError", line, err)
+	}
+	if len(usage.Lines) == 0 || !strings.HasPrefix(usage.Lines[0], "usage: ") {
+		t.Errorf("%s: usage error without a usage line: %q", line, usage.Lines)
+	}
+}
+
+func joined(lines []string) string { return strings.Join(lines, "\n") }
+
+// TestLoopPrintsEveryLineOfAUsageError drives repository usage errors through the
+// terminal loop: the usage line under the error prefix, then what was wrong.
+func TestLoopPrintsEveryLineOfAUsageError(t *testing.T) {
+	repoSession(t)
+	var out strings.Builder
+	if err := Loop(&scriptReader{lines: []string{"%load --id x", "%load --id=a --id=b", "%projects now"}}, &out, NewSession()); err != nil {
+		t.Fatalf("Loop error: %v", err)
+	}
+	got := strings.Split(strings.TrimSuffix(out.String(), "\n"), "\n")
+	want := []string{
+		"error: " + usageLoadRepo, "--id is not an option of %load",
+		"error: " + usageLoadRepo, "--id was given twice",
+		"error: " + usageProjects,
+	}
+	if strings.Join(got, "\n") != strings.Join(want, "\n") {
+		t.Errorf("the loop printed:\n%s\nwant:\n%s", strings.Join(got, "\n"), strings.Join(want, "\n"))
+	}
+}
+
+func TestRepoShowsAndSetsTheBaseURL(t *testing.T) {
+	s, api := repoSession(t)
+	if got := joined(runMeta(t, s, "%repo")); got != "API base path: "+api.URL() {
+		t.Errorf("%%repo = %q, want the environment's URL", got)
+	}
+	if got := joined(runMeta(t, s, "%repo http://127.0.0.1:1/api/")); got != "API base path: http://127.0.0.1:1/api" {
+		t.Errorf("%%repo <url> = %q", got)
+	}
+	if got := joined(runMeta(t, s, "%repo")); got != "API base path: http://127.0.0.1:1/api" {
+		t.Errorf("%%repo after setting = %q", got)
+	}
+	t.Setenv("FLEXO_ALLOW_PLAIN_HTTP", "")
+	if err := metaErr(t, s, "%repo http://models.example.com/api"); !strings.Contains(err.Error(), "FLEXO_ALLOW_PLAIN_HTTP") {
+		t.Errorf("plain HTTP off the loopback was taken: %v", err)
+	}
+	if got := joined(runMeta(t, s, "%repo")); got != "API base path: http://127.0.0.1:1/api" {
+		t.Errorf("a refused URL was kept: %q", got)
+	}
+	wantUsage(t, metaErr(t, s, "%repo a b"), "%repo a b")
+	if help := joined(runMeta(t, s, "%help")); !strings.Contains(help, "FLEXO_INTEROP_TOKEN") || strings.Contains(help, "secret") {
+		t.Error("help does not say the token comes from FLEXO_INTEROP_TOKEN")
+	}
+}
+
+func TestProjectsListsEveryPage(t *testing.T) {
+	s, api := repoSession(t)
+	if got := joined(runMeta(t, s, "%projects")); got != "no projects" {
+		t.Errorf("empty repository: %q", got)
+	}
+	for _, name := range []string{"Alpha", "Beta", "Gamma", "Delta", "Epsilon"} {
+		api.addProject(name)
+	}
+	out := runMeta(t, s, "%projects")
+	if len(out) != 5 {
+		t.Fatalf("%%projects listed %d of 5 projects over pages of %d:\n%s", len(out), api.pageSize, joined(out))
+	}
+	if out[0] != "Alpha (project-0001)" || out[4] != "Epsilon (project-0009)" {
+		t.Errorf("%%projects lines: %q", out)
+	}
+	wantUsage(t, metaErr(t, s, "%projects now"), "%projects now")
+
+	runMeta(t, s, "%repo http://127.0.0.1:9/nothing")
+	err := metaErr(t, s, "%projects")
+	if !strings.Contains(err.Error(), "did not answer") {
+		t.Errorf("unreachable server: %v", err)
+	}
+	if strings.Contains(err.Error(), "goroutine") {
+		t.Errorf("a stack trace leaked: %v", err)
+	}
+}
+
+func TestPublishCreatesAProjectThenCommitsOnIt(t *testing.T) {
+	s, api := repoSession(t)
+	s.Submit(vehicles)
+	out := runMeta(t, s, "%publish Vehicles")
+	if len(out) < 2 || out[0] != "created project Vehicles (project-0001)" || !strings.HasPrefix(out[1], "commit commit-") {
+		t.Fatalf("first publish:\n%s", joined(out))
+	}
+	if !strings.Contains(out[1], "deleted") || strings.Contains(out[1], " 0 created") {
+		t.Errorf("first publish reports no creations: %q", out[1])
+	}
+	held := api.elementCount("project-0001", "branch-0002")
+	if held == 0 {
+		t.Fatal("the project holds no elements")
+	}
+	if api.elementCount("project-0001", "branch-0002") != held {
+		t.Fatal("unstable count")
+	}
+	for _, id := range api.order {
+		if api.projects[id].name == "Spare" {
+			t.Error("Spare, outside Vehicles, was published")
+		}
+	}
+
+	again := runMeta(t, s, "%publish Vehicles")
+	if len(again) != 1 || !strings.HasPrefix(again[0], "nothing to publish") {
+		t.Errorf("republishing the same model:\n%s", joined(again))
+	}
+
+	s.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } part def Car { part wheels : Wheel[4]; } part def Truck; }")
+	out = runMeta(t, s, "%publish Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "on branch main (branch-0002) of Vehicles (project-0001)") {
+		t.Fatalf("second publish:\n%s", joined(out))
+	}
+	if strings.Contains(out[0], " 0 created") {
+		t.Errorf("Truck was not created: %q", out[0])
+	}
+	if len(api.order) != 1 {
+		t.Errorf("%d projects after publishing twice, want 1", len(api.order))
+	}
+
+	out = runMeta(t, s, "%publish --project=Fleet Vehicles::Car")
+	if out[0] != "created project Fleet ("+api.order[len(api.order)-1]+")" {
+		t.Errorf("--project:\n%s", joined(out))
+	}
+	err := metaErr(t, s, "%publish --branch=release Vehicles")
+	if !strings.Contains(err.Error(), "branch release doesn't exist") {
+		t.Errorf("unknown branch: %v", err)
+	}
+	wantUsage(t, metaErr(t, s, "%publish"), "%publish")
+	wantUsage(t, metaErr(t, s, "%publish --derived Vehicles"), "%publish --derived")
+	wantUsage(t, metaErr(t, s, "%publish Vehicles Spare"), "%publish two names")
+	if out := runMeta(t, s, "%publish Nowhere"); len(out) != 1 || !strings.HasPrefix(out[0], "error: ") {
+		t.Errorf("unknown element:\n%s", joined(out))
+	}
+
+	api.conflict = "head moved"
+	err = metaErr(t, s, "%publish -d --project=Fleet Vehicles")
+	if !strings.Contains(err.Error(), "Conflict") || !strings.Contains(err.Error(), "head moved") {
+		t.Errorf("409 is not reported with its status and the server's message: %v", err)
+	}
+}
+
+func TestPublishWithDerivedPropertiesSendsMore(t *testing.T) {
+	s, api := repoSession(t)
+	s.Submit(specialized)
+	runMeta(t, s, "%publish Chains")
+	plain, plainBytes := api.heldBytes("project-0001", "branch-0002")
+	s2 := NewSession()
+	s2.Submit(specialized)
+	runMeta(t, s2, "%publish -d --project=Derived Chains")
+	derived := api.order[len(api.order)-1]
+	with, withBytes := api.heldBytes(derived, api.projects[derived].defaults)
+	if with != plain {
+		t.Errorf("derived properties changed the element count: %d vs %d", with, plain)
+	}
+	if withBytes <= plainBytes {
+		t.Errorf("-d sent %d bytes, no more than the %d without", withBytes, plainBytes)
+	}
+}
+
+// specialized has subclassifications, whose owningClassifier is a derived
+// property the reader recomputes: the one a publish leaves out unless asked.
+const specialized = `package Chains {
+	part def A { part b : B; }
+	part def B :> A { attribute x : ScalarValues::Real; }
+	part def C :> B;
+}
+`
+
+func TestLoadReadsAProjectIntoTheSession(t *testing.T) {
+	s, api := repoSession(t)
+	s.Submit(vehicles)
+	runMeta(t, s, "%publish Vehicles")
+
+	fresh := NewSession()
+	out := runMeta(t, fresh, "%load Vehicles")
+	if !strings.HasPrefix(out[0], "loaded project Vehicles (project-0001) at branch main (branch-0002), commit commit-") {
+		t.Fatalf("%%load:\n%s", joined(out))
+	}
+	listed := joined(runMeta(t, fresh, "%list"))
+	for _, want := range []string{"package Vehicles", "part def Car", "part def Wheel", "part wheels : Wheel[4]"} {
+		if !strings.Contains(listed, want) {
+			t.Errorf("%s is not in the loaded session:\n%s", want, listed)
+		}
+	}
+	if strings.Contains(listed, "Spare") {
+		t.Errorf("Spare was loaded, and it was never published:\n%s", listed)
+	}
+	if fresh.repoState == nil || fresh.repoState.ProjectID != "project-0001" || fresh.repoState.Branch != "branch-0002" {
+		t.Fatalf("the loaded branch was not recorded: %+v", fresh.repoState)
+	}
+	printed := joined(runMeta(t, fresh, "%print Vehicles"))
+	if !strings.Contains(printed, "part wheels : Wheel[4]") {
+		t.Errorf("the loaded notation lost the multiplicity:\n%s", printed)
+	}
+
+	// A publish from the loaded session is a commit on the branch it came from.
+	fresh.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } part def Car { part wheels : Wheel[4]; } part def Bus; }")
+	out = runMeta(t, fresh, "%publish Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "of Vehicles (project-0001)") {
+		t.Fatalf("publish after load:\n%s", joined(out))
+	}
+	if len(api.order) != 1 {
+		t.Errorf("publishing a loaded project created another: %d projects", len(api.order))
+	}
+
+	byID := NewSession()
+	if out := runMeta(t, byID, "%load --id=project-0001 --branch=main"); !strings.HasPrefix(out[0], "loaded project Vehicles") {
+		t.Errorf("--id --branch:\n%s", joined(out))
+	}
+	if out := runMeta(t, NewSession(), "%load --name=Vehicles --branch=branch-0002"); !strings.HasPrefix(out[0], "loaded project Vehicles") {
+		t.Errorf("--name --branch=<id>:\n%s", joined(out))
+	}
+	if err := metaErr(t, NewSession(), "%load --id=project-9999"); !strings.Contains(err.Error(), "project project-9999 doesn't exist") {
+		t.Errorf("404 by id: %v", err)
+	}
+	if err := metaErr(t, NewSession(), "%load Nowhere"); !strings.Contains(err.Error(), "project Nowhere doesn't exist") {
+		t.Errorf("missing name: %v", err)
+	}
+	if err := metaErr(t, NewSession(), "%load Vehicles --branch=release"); !strings.Contains(err.Error(), "branch release doesn't exist") {
+		t.Errorf("missing branch: %v", err)
+	}
+	empty := api.addProject("Empty")
+	if err := metaErr(t, NewSession(), "%load Empty"); !strings.Contains(err.Error(), "has no head commit") {
+		t.Errorf("empty project %s: %v", empty.id, err)
+	}
+	api.addProject("Vehicles")
+	err := metaErr(t, NewSession(), "%load Vehicles")
+	if !strings.Contains(err.Error(), "project-0001") || strings.Count(err.Error(), "project-00") < 2 {
+		t.Errorf("ambiguous name does not list both ids: %v", err)
+	}
+	wantUsage(t, metaErr(t, s, "%load --id=project-0001 Vehicles"), "two ways to name")
+	wantUsage(t, metaErr(t, s, "%load --branch=main"), "branch alone")
+	wantUsage(t, metaErr(t, s, "%load --tag=x"), "unknown flag")
+	if _, _, err := s.RunMeta("%load /nonexistent/model.sysml"); err == nil || !strings.Contains(err.Error(), "nonexistent") {
+		t.Errorf("a path still loads files: %v", err)
+	}
+	if out, _, _ := s.RunMeta("%load"); joined(out) != usageLoadPath {
+		t.Errorf("%%load without arguments: %q", out)
+	}
+}
+
+func TestPublishLoadRoundTripKeepsTheModel(t *testing.T) {
+	s, _ := repoSession(t)
+	s.Submit(vehicles)
+	runMeta(t, s, "%publish Vehicles")
+	fresh := NewSession()
+	runMeta(t, fresh, "%load Vehicles")
+	want := joined(runMeta(t, s, "%print Vehicles"))
+	got := joined(runMeta(t, fresh, "%print Vehicles"))
+	if normalizeNotation(got) != normalizeNotation(want) {
+		t.Errorf("the model changed in the round trip:\n--- published\n%s\n--- loaded\n%s", want, got)
+	}
+	if fresh.repoState == nil || fresh.repoState.LastSeenCommit == "" {
+		t.Error("the loaded session does not know its commit")
+	}
+}
+
+// normalizeNotation reads notation as its sorted tokens, the ProjectRef the
+// load adds aside: the server orders the elements, and layout is the writer's.
+func normalizeNotation(text string) string {
+	var out []string
+	for _, line := range strings.Split(text, "\n") {
+		line = strings.TrimSpace(line)
+		if strings.HasPrefix(line, "@IdentityMetadata::ProjectRef") {
+			continue
+		}
+		line = strings.NewReplacer("{", " { ", "}", " } ", ";", " ; ").Replace(line)
+		out = append(out, strings.Fields(line)...)
+	}
+	sort.Strings(out)
+	return strings.Join(out, " ")
+}
+
+func TestRepositoryCommandsAreListedAndCompleted(t *testing.T) {
+	s, api := repoSession(t)
+	api.addProject("Vehicles")
+	api.addProject("Vessels")
+	help := joined(runMeta(t, s, "%help"))
+	for _, want := range []string{"Repository:", "%repo [<base path>]", "%projects", "%publish [-d] [--project=<project name>] [--branch=<branch name>] <name>", "--id=<project id>"} {
+		if !strings.Contains(help, want) {
+			t.Errorf("help lacks %q", want)
+		}
+	}
+	complete := func(line string) []string { return s.Complete(line, len(line)).Candidates }
+	if got := complete("%pub"); joined(got) != "%publish" {
+		t.Errorf("%%pub completes to %q", got)
+	}
+	if got := complete("%load --"); joined(got) != "--branch=\n--cells=\n--id=\n--name=" {
+		t.Errorf("%%load -- completes to %q", got)
+	}
+	if got := complete("%load --c"); joined(got) != "--cells=" {
+		t.Errorf("%%load --c completes to %q", got)
+	}
+	if got := complete("%load --name=Ve"); joined(got) != "--name=Vehicles\n--name=Vessels" {
+		t.Errorf("%%load --name=Ve completes to %q", got)
+	}
+	if got := complete("%load Veh"); joined(got) != "Vehicles" {
+		t.Errorf("%%load Veh completes to %q", got)
+	}
+	if got := complete("%publish -"); joined(got) != "--branch=\n--project=\n-d" {
+		t.Errorf("%%publish - completes to %q", got)
+	}
+	if got := complete("%publish --project=Ves"); joined(got) != "--project=Vessels" {
+		t.Errorf("%%publish --project=Ves completes to %q", got)
+	}
+	if got := complete("%load --id=project-"); len(got) != 2 {
+		t.Errorf("%%load --id= completes to %q", got)
+	}
+}
+
+// With a repository linked, %load still reads notebooks: --cells is the
+// notebook's option, not a project's, and an .ipynb name is a path even when
+// no such file exists.
+func TestLoadWithCellsReadsANotebookNotAProject(t *testing.T) {
+	s, _ := repoSession(t)
+	out := runMeta(t, s, "%load --cells 1,3-4 "+fixtureNotebook("tagged.ipynb"))
+	if joined(out) == "" || !strings.Contains(joined(out), "3 of 4 code cells (--cells 1,3-4)") {
+		t.Errorf("--cells was not read as the notebook's option:\n%s", joined(out))
+	}
+	out = runMeta(t, s, "%load --cells=tag:model "+fixtureNotebook("tagged.ipynb"))
+	if !strings.Contains(joined(out), "2 of 4 code cells (--cells tag:model)") {
+		t.Errorf("--cells= was not read as the notebook's option:\n%s", joined(out))
+	}
+	if err := metaErr(t, s, "%load missing.ipynb"); strings.Contains(err.Error(), "project") {
+		t.Errorf("a missing notebook was looked up as a project: %v", err)
+	}
+}
+
+func TestPublishAfterLoadingABranchCommitsOnThatBranch(t *testing.T) {
+	s, api := repoSession(t)
+	s.Submit(vehicles)
+	runMeta(t, s, "%publish Vehicles")
+	review := api.addBranch("project-0001", "review")
+	main := api.projects["project-0001"].branches["branch-0002"]
+	before := main.head
+
+	fresh := NewSession()
+	out := runMeta(t, fresh, "%load Vehicles --branch=review")
+	if !strings.HasPrefix(out[0], "loaded project Vehicles (project-0001) at branch review ("+review.id+")") {
+		t.Fatalf("%%load:\n%s", joined(out))
+	}
+	fresh.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } part def Car { part wheels : Wheel[4]; } part def Van; }")
+	out = runMeta(t, fresh, "%publish Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "on branch review ("+review.id+") of Vehicles (project-0001)") {
+		t.Fatalf("publish after loading a branch:\n%s", joined(out))
+	}
+	if main.head != before {
+		t.Errorf("the default branch moved from %s to %s; the loaded branch was review", before, main.head)
+	}
+	if review.head == before || !strings.HasPrefix(out[0], "commit "+review.head+" ") {
+		t.Errorf("review's head is %s, the publish reported %q", review.head, out[0])
+	}
+	if fresh.repoState.Branch != review.id {
+		t.Errorf("the session now tracks branch %s, not review", fresh.repoState.Branch)
+	}
+
+	// --branch still wins over the loaded branch.
+	fresh.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } part def Car { part wheels : Wheel[4]; } part def Van; part def Bus; }")
+	out = runMeta(t, fresh, "%publish --branch=main Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "on branch main (branch-0002)") {
+		t.Fatalf("publish --branch after loading another:\n%s", joined(out))
+	}
+	if main.head == before {
+		t.Errorf("--branch=main did not move main")
+	}
+}
+
+func TestPublishingOneRootLeavesTheOthersOnTheBranch(t *testing.T) {
+	s, api := repoSession(t)
+	s.Submit(vehicles)
+	runMeta(t, s, "%publish Vehicles")
+	held := api.elementCount("project-0001", "branch-0002")
+
+	out := runMeta(t, s, "%publish --project=Vehicles Spare")
+	if len(out) < 2 || !strings.Contains(out[0], " 0 deleted") || !strings.Contains(out[1], "left in place") {
+		t.Fatalf("publishing Spare next to Vehicles:\n%s", joined(out))
+	}
+	if now := api.elementCount("project-0001", "branch-0002"); now <= held {
+		t.Errorf("%d elements after adding Spare to %d", now, held)
+	}
+
+	// A session holding the branch's state and a Vehicles without Car: the
+	// publication deletes Car, inside its root, and leaves Spare alone.
+	reduced := NewSession()
+	reduced.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } }")
+	reduced.repoState = s.repoState
+	out = runMeta(t, reduced, "%publish Vehicles")
+	if len(out) != 2 || strings.Contains(out[0], " 0 deleted") || !strings.Contains(out[1], "left in place") {
+		t.Fatalf("removing Car from Vehicles:\n%s", joined(out))
+	}
+	if !strings.Contains(out[0], "Vehicles (project-0001)") {
+		t.Errorf("Vehicles went elsewhere: %q", out[0])
+	}
+	fresh := NewSession()
+	runMeta(t, fresh, "%load Vehicles")
+	if loaded := fresh.text(); !strings.Contains(loaded, "Boat") || strings.Contains(loaded, "Car") {
+		t.Errorf("after removing Car, the branch should hold Boat and no Car:\n%s", loaded)
+	}
+}
+
+func TestPublishForgetsTheStateOfAnotherServer(t *testing.T) {
+	s, api := repoSession(t)
+	other := newFakeAPI()
+	t.Cleanup(other.Close)
+	s.Submit(vehicles)
+	runMeta(t, s, "%publish Vehicles")
+
+	runMeta(t, s, "%repo "+other.URL())
+	runMeta(t, s, "%publish --project=Vehicles Spare")
+	if other.elementCount("project-0001", "branch-0002") == 0 || api.elementCount("project-0001", "branch-0002") == 0 {
+		t.Fatal("both servers should now hold a project-0001")
+	}
+	runMeta(t, s, "%repo "+api.URL())
+	runMeta(t, s, "%publish Vehicles")
+	runMeta(t, s, "%repo "+other.URL())
+
+	// The same ids on another server are no history of it: nothing it holds
+	// may be deleted on the strength of the first server's commits.
+	held := other.elementCount("project-0001", "branch-0002")
+	out := runMeta(t, s, "%publish Vehicles")
+	if len(out) < 1 || !strings.Contains(out[0], " 0 deleted") {
+		t.Fatalf("publishing to the other server:\n%s", joined(out))
+	}
+	if now := other.elementCount("project-0001", "branch-0002"); now < held {
+		t.Errorf("the other server lost elements: %d, had %d", now, held)
+	}
+}
+
+// A %load of --cells alone is the file load's to answer: it wants a notebook,
+// or a selection, and no repository option was given; a lone name beginning
+// with one dash is still a project's.
+func TestLoadWithCellsAloneWantsANotebook(t *testing.T) {
+	s, api := repoSession(t)
+	api.addProject("-demo")
+	if err := metaErr(t, s, "%load -demo"); err == nil || !strings.Contains(err.Error(), "has no head commit") {
+		t.Errorf("a lone -demo did not name the project: %v", err)
+	}
+	if out := joined(runMeta(t, s, "%load --cells=1")); out != usageLoadPath {
+		t.Errorf("%%load --cells=1 answered %q, want the file load's usage", out)
+	}
+	err := metaErr(t, s, "%load --cells")
+	if err == nil || !strings.Contains(err.Error(), "--cells needs a selection") {
+		t.Errorf("%%load --cells: %v", err)
+	}
+	err = metaErr(t, s, "%load --tags=x")
+	var usage *UsageError
+	if !errors.As(err, &usage) || !strings.Contains(joined(usage.Lines), "unknown option --tags") {
+		t.Errorf("%%load --tags=x: %v", err)
+	}
+}
+
+func TestRepositoryOptionsAreGivenOnce(t *testing.T) {
+	s, _ := repoSession(t)
+	s.Submit(vehicles)
+	for _, line := range []string{
+		"%load --id=p1 --id=p2",
+		"%load --name=Vehicles --name=Spare",
+		"%load --branch=main --branch=dev Vehicles",
+		"%publish --project=Fleet --project=Other Vehicles",
+		"%publish --branch=main --branch=dev Vehicles",
+		"%publish -d -d Vehicles",
+	} {
+		err := metaErr(t, s, line)
+		wantUsage(t, err, line)
+		var usage *UsageError
+		if errors.As(err, &usage) && !strings.Contains(joined(usage.Lines), "was given twice") {
+			t.Errorf("%s: %q does not name the repeated option", line, usage.Lines)
+		}
+	}
+}
+
+// The environment's URL is held to the rule %repo holds a URL it is given to:
+// a plaintext server off this machine gets no request, so no token in the clear.
+func TestDefaultURLIsHeldToThePlaintextRule(t *testing.T) {
+	if replext.Repo() == nil {
+		t.Fatal("no repository extension is linked")
+	}
+	t.Setenv("FLEXO_SYSMLV2_URL", "http://models.example.com/api")
+	t.Setenv("FLEXO_INTEROP_TOKEN", "secret")
+	t.Setenv("FLEXO_ALLOW_PLAIN_HTTP", "")
+	s := NewSession()
+	s.Submit(vehicles)
+	for _, line := range []string{"%repo", "%projects", "%load --id=project-0001", "%publish Vehicles"} {
+		err := metaErr(t, s, line)
+		if !strings.Contains(err.Error(), "FLEXO_ALLOW_PLAIN_HTTP") || !strings.Contains(err.Error(), "http://models.example.com/api") {
+			t.Errorf("%s: the environment's plaintext URL was taken: %v", line, err)
+		}
+		if strings.Contains(err.Error(), "secret") {
+			t.Errorf("%s: the refusal names the token: %v", line, err)
+		}
+		if strings.Contains(err.Error(), "did not answer") {
+			t.Errorf("%s: a request went out: %v", line, err)
+		}
+	}
+	if got := s.Complete("%load Veh", len("%load Veh")).Candidates; len(got) != 0 {
+		t.Errorf("completion asked the refused server: %q", got)
+	}
+
+	if got := joined(runMeta(t, s, "%repo http://127.0.0.1:1/api")); got != "API base path: http://127.0.0.1:1/api" {
+		t.Errorf("%%repo <loopback url> = %q", got)
+	}
+	if err := metaErr(t, s, "%projects"); !strings.Contains(err.Error(), "did not answer") {
+		t.Errorf("a loopback URL set by %%repo was still refused: %v", err)
+	}
+
+	t.Setenv("FLEXO_ALLOW_PLAIN_HTTP", "1")
+	if got := joined(runMeta(t, NewSession(), "%repo")); got != "API base path: http://models.example.com/api" {
+		t.Errorf("with the opt-in, %%repo = %q", got)
+	}
+}
+
+// A project the session loaded by id is the one a publish by its name means,
+// even when another project on the server has the same name.
+func TestPublishByNameUpdatesTheLoadedNamesake(t *testing.T) {
+	s, api := repoSession(t)
+	s.Submit(vehicles)
+	runMeta(t, s, "%publish Vehicles")
+	namesake := api.addProject("Vehicles")
+	held := api.elementCount("project-0001", "branch-0002")
+
+	untracked := NewSession()
+	untracked.Submit(vehicles)
+	if err := metaErr(t, untracked, "%publish Vehicles"); !strings.Contains(err.Error(), "project-0001") || !strings.Contains(err.Error(), namesake.id) {
+		t.Errorf("without a loaded project, the shared name is not refused naming both: %v", err)
+	}
+
+	fresh := NewSession()
+	runMeta(t, fresh, "%load --id=project-0001")
+	fresh.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } part def Car { part wheels : Wheel[4]; } part def Bus; }")
+	out := runMeta(t, fresh, "%publish Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "of Vehicles (project-0001)") {
+		t.Fatalf("publish by name after loading by id:\n%s", joined(out))
+	}
+	if now := api.elementCount("project-0001", "branch-0002"); now <= held {
+		t.Errorf("the loaded project holds %d elements, had %d; Bus was not added", now, held)
+	}
+	if api.elementCount(namesake.id, namesake.defaults) != 0 || len(api.order) != 2 {
+		t.Errorf("the namesake received elements or a project was created: %d projects", len(api.order))
+	}
+	fresh.Submit("package Spare { part def Boat; }")
+	out = runMeta(t, fresh, "%publish --project=Vehicles Spare")
+	if len(out) < 1 || !strings.Contains(out[0], "of Vehicles (project-0001)") {
+		t.Errorf("--project naming the tracked project's name:\n%s", joined(out))
+	}
+	if len(api.order) != 2 {
+		t.Errorf("--project=Vehicles created a project: %d projects", len(api.order))
+	}
+
+	// Renamed on the server, the tracked project no longer answers to the name:
+	// the namesake, now alone under it, is the one published to.
+	api.mu.Lock()
+	api.projects["project-0001"].name = "Fleet"
+	api.mu.Unlock()
+	out = runMeta(t, fresh, "%publish Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "of Vehicles ("+namesake.id+")") {
+		t.Fatalf("publish by a name the tracked project lost:\n%s", joined(out))
+	}
+	if api.elementCount(namesake.id, namesake.defaults) == 0 || len(api.order) != 2 {
+		t.Errorf("the namesake holds nothing or a project was created: %d projects", len(api.order))
+	}
+
+	// Deleted on the server, likewise: no project is created over the namesake.
+	api.mu.Lock()
+	delete(api.projects, "project-0001")
+	api.order = api.order[1:]
+	api.mu.Unlock()
+	fresh.Submit("package Vehicles { part def Wheel { attribute radius : ScalarValues::Real; } part def Car { part wheels : Wheel[4]; } part def Bus; part def Van; }")
+	out = runMeta(t, fresh, "%publish Vehicles")
+	if len(out) != 1 || !strings.Contains(out[0], "of Vehicles ("+namesake.id+")") {
+		t.Fatalf("publish by name after the tracked project was deleted:\n%s", joined(out))
+	}
+	if len(api.order) != 1 {
+		t.Errorf("a project was created over the namesake: %d projects", len(api.order))
+	}
+}
diff --git a/internal/frontend/repl/run.go b/internal/frontend/repl/run.go
index 3b38e8f872..ef204a0e4c 100644
--- a/internal/frontend/repl/run.go
+++ b/internal/frontend/repl/run.go
@@ -57,12 +57,15 @@ func errorLines(lines []string, _ []NamedValue, err error) ([]string, bool, erro
 // one named as the transcript is.
 func (s *Session) LoadFile(path string) ([]string, error) {
 	defer s.enter()()
-	files, err := s.readSources(s.withDependencies([]string{expandHome(path)}))
+	read, err := s.readWithDependencies([]string{expandHome(path)}, loadOptions{})
 	if err != nil {
 		return nil, err
 	}
-	lines := renderResult(s.submitFiles(files), s.verbosity)
-	return append(lines, conversionWarnings(files, s.verbosity)...), nil
+	lines := read.notes
+	if len(read.files) > 0 {
+		lines = append(lines, renderResult(s.submitFiles(read.files), s.verbosity)...)
+	}
+	return append(lines, conversionWarnings(read.files, s.verbosity)...), nil
 }
 
 // LoadFileSummary submits the contents of path and returns only what it
@@ -80,16 +83,20 @@ func (s *Session) LoadFileSummary(path string) ([]string, error) {
 // root namespace load too.
 func (s *Session) LoadFilesSummary(paths []string) ([]string, error) {
 	defer s.enter()()
-	files, err := s.readSources(s.withDependencies(expandHomes(paths)))
+	read, err := s.readWithDependencies(expandHomes(paths), loadOptions{})
 	if err != nil {
 		return nil, err
 	}
+	files := read.files
+	lines := read.notes
+	if len(files) == 0 {
+		return lines, nil
+	}
 	res, byFile, whole := s.submitEach(files)
-	var lines []string
 	for i, f := range files {
 		// The analysis is reported once every file is in, but a file that does not
 		// parse is a finding about that file alone and is reported with it.
-		own := res.within(s.fileSpan(f.Name))
+		own := res.within(s.fileSpan(f.key()))
 		lines = append(lines, renderSyntax(own, s.verbosity)...)
 		lines = append(lines, byFile[i]...)
 		lines = append(lines, conversionWarnings([]SourceFile{f}, s.verbosity)...)
diff --git a/internal/frontend/repl/session.go b/internal/frontend/repl/session.go
index d6c6fefa46..73548afcc3 100644
--- a/internal/frontend/repl/session.go
+++ b/internal/frontend/repl/session.go
@@ -4,6 +4,7 @@ package repl
 
 import (
 	"fmt"
+	"github.com/Open-MBEE/OpenSysML/internal/frontend/repl/replext"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -54,6 +55,10 @@ type snippet struct {
 	// can be written.
 	origin string
 	key    string
+	// of is the key of the file this snippet was read from along with others —
+	// a notebook, each of whose cells is a snippet — so that re-reading the
+	// file whole drops every snippet of it; empty for a source of its own file.
+	of string
 	// gen is the submission that appended this snippet, which is what scopes a
 	// report to the files just loaded rather than the whole buffer.
 	gen int
@@ -149,6 +154,11 @@ type Session struct {
 	// budgets bounds every runtime context this session creates.
 	budgets runtime.Budgets
 
+	// repoURL is the base URL %repo set, empty until it does; repoState is the
+	// branch the model was last loaded from or published to.
+	repoURL   string
+	repoState *replext.ProjectState
+
 	// schedule is the policy runs started from here on resolve choice points under.
 	schedule runtime.SchedulePolicy
 
@@ -411,6 +421,11 @@ func (s *Session) List() []string {
 func (s *Session) list() []string {
 	out := make([]string, 0, len(s.snippets))
 	for _, sn := range s.snippets {
+		// A file read whole that holds no text keeps a snippet, so re-reading it
+		// is a refresh; there is nothing of it to list.
+		if strings.TrimSpace(sn.src) == "" {
+			continue
+		}
 		out = append(out, sn.src)
 	}
 	return out
@@ -442,7 +457,7 @@ func (s *Session) accept(origin, src string) {
 // A loaded file supersedes only itself and what the prompt said about the same
 // names, since several files of one model commonly open the same package.
 func (s *Session) acceptFrom(origin, src string) (declared []string, drops []dropReport) {
-	return s.acceptParsed(origin, src, preparse(origin, src), source.KindUnknown)
+	return s.acceptParsed(origin, fileKeyOf(origin), "", src, preparse(origin, src), source.KindUnknown)
 }
 
 // parsed is what a submission's text parses to, taken before it is accepted so
@@ -473,8 +488,10 @@ func sourceForKind(name string, data []byte, kind source.Kind) *source.SourceFil
 	return source.NewWithKind(name, data, kind)
 }
 
-// acceptParsed is acceptFrom over a parse already taken.
-func (s *Session) acceptParsed(origin, src string, pre parsed, kind source.Kind) (declared []string, drops []dropReport) {
+// acceptParsed is acceptFrom over a parse already taken; key identifies origin
+// across its spellings, and of is the key of the file origin was read from along
+// with other sources, empty otherwise.
+func (s *Session) acceptParsed(origin, key, of, src string, pre parsed, kind source.Kind) (declared []string, drops []dropReport) {
 	p, root := pre.p, pre.root
 	names := declaredNames(root)
 	declared = names
@@ -483,7 +500,6 @@ func (s *Session) acceptParsed(origin, src string, pre parsed, kind source.Kind)
 	// rather than left to absorb the submissions after it, and declares nothing:
 	// what the parser recovered from it is not what was meant.
 	if !pre.closes {
-		key := fileKeyOf(origin)
 		if key != "" {
 			// Re-reading the file supersedes what it declared before, which it no
 			// longer does.
@@ -501,6 +517,7 @@ func (s *Session) acceptParsed(origin, src string, pre parsed, kind source.Kind)
 			src:    src,
 			origin: origin,
 			key:    key,
+			of:     of,
 			kind:   kind,
 			gen:    s.version,
 			open:   true,
@@ -514,7 +531,6 @@ func (s *Session) acceptParsed(origin, src string, pre parsed, kind source.Kind)
 	)
 	if origin != "" {
 		set := nameSet(names)
-		key := fileKeyOf(origin)
 		top := topLevelMembers(root)
 		kept := s.snippets[:0]
 		for _, sn := range s.snippets {
@@ -531,7 +547,7 @@ func (s *Session) acceptParsed(origin, src string, pre parsed, kind source.Kind)
 				kept = append(kept, sn)
 			}
 		}
-		s.snippets = append(kept, snippet{src: src, names: names, origin: origin, key: key, kind: kind, gen: s.version})
+		s.snippets = append(kept, snippet{src: src, names: names, origin: origin, key: key, of: of, kind: kind, gen: s.version})
 		return declared, append(drops, s.reopenedNamespaces(key, root)...)
 	}
 	if len(names) > 0 {
@@ -879,10 +895,28 @@ func (s *Session) Submit(src string) Result {
 // SourceFile is one source of a submission together with the file it was read
 // from, which is what diagnostics over a multi-file load are reported against.
 type SourceFile struct {
-	Name     string
-	Text     string
-	Kind     source.Kind
+	Name string
+	Text string
+	Kind source.Kind
+	// Of names the file this source was read from along with others — the
+	// notebook a cell is one of — empty for a source that is its own file.
+	Of string
+	// Whole is set when Of was read whole, so that re-reading it drops what an
+	// earlier reading declared and this one no longer holds.
+	Whole    bool
 	Warnings []string
+	// Key identifies the source across the spellings of its path where Name is
+	// no file's — a notebook cell's is its notebook's key and its position;
+	// empty for a source whose Name is its path.
+	Key string
+}
+
+// key identifies f across the spellings of its path.
+func (f SourceFile) key() string {
+	if f.Key != "" {
+		return f.Key
+	}
+	return fileKeyOf(f.Name)
 }
 
 // SubmitAll accumulates every src as one submission, from no file in particular.
@@ -950,8 +984,9 @@ func (s *Session) submitEach(files []SourceFile) (res Result, byFile [][]string,
 	model.ParallelFor(s.jobs, len(files), func(i int) {
 		parses[i] = preparseWithKind(files[i].Name, files[i].Text, files[i].Kind)
 	})
+	drops = s.dropReadWhole(files)
 	for i, f := range files {
-		names, dropped := s.acceptParsed(f.Name, f.Text, parses[i], f.Kind)
+		names, dropped := s.acceptParsed(f.Name, f.key(), fileKeyOf(f.Of), f.Text, parses[i], f.Kind)
 		for _, name := range names {
 			if !seen[name] {
 				seen[name] = true
@@ -993,6 +1028,32 @@ func (s *Session) submitEach(files []SourceFile) (res Result, byFile [][]string,
 	return res, byFile, whole
 }
 
+// dropReadWhole drops every snippet of a file the submission read whole, a
+// notebook's cells among them, so what the file no longer holds is gone; the
+// cells it still holds are then accepted afresh.
+func (s *Session) dropReadWhole(files []SourceFile) []dropReport {
+	whole := map[string]bool{}
+	for _, f := range files {
+		if f.Whole {
+			whole[fileKeyOf(f.Of)] = true
+		}
+	}
+	if len(whole) == 0 {
+		return nil
+	}
+	var drops []dropReport
+	kept := s.snippets[:0]
+	for _, sn := range s.snippets {
+		if sn.of != "" && whole[sn.of] {
+			drops = append(drops, dropReport{gone: sn.names})
+			continue
+		}
+		kept = append(kept, sn)
+	}
+	s.snippets = kept
+	return drops
+}
+
 // rebuildOver replaces the open documents and everything derived from them — the
 // runtime context, the resolutions held objects and debugging sessions were
 // made against — after the snippets changed, reporting what it carried over.
@@ -1016,10 +1077,10 @@ func (s *Session) rebuildOver(drops []dropReport) []string {
 	return whole
 }
 
-// fileSpan is where the current submission's text from the named file sits in the
-// joined buffer, through the newline closing it, where a parse that ran out of text reports.
-func (s *Session) fileSpan(name string) source.Span {
-	key := fileKeyOf(name)
+// fileSpan is where the current submission's text from the file key identifies
+// sits in the joined buffer, through the newline closing it, where a parse that
+// ran out of text reports.
+func (s *Session) fileSpan(key string) source.Span {
 	acc := 0
 	for _, sn := range s.snippets {
 		if sn.gen == s.version && sn.key == key {
@@ -1255,6 +1316,7 @@ func (s *Session) clear() []string {
 	}
 	s.snippets = nil
 	s.version = 0
+	s.repoState = nil
 	s.rtCtx, s.replaced = nil, nil
 	s.dropIndexedDocs()
 	s.instances = make(map[string]*runtime.Instance)
diff --git a/internal/frontend/repl/view.go b/internal/frontend/repl/view.go
index 3df08a4a13..936b97eb88 100644
--- a/internal/frontend/repl/view.go
+++ b/internal/frontend/repl/view.go
@@ -163,6 +163,12 @@ func (s *Session) renderLines(name string, form view.Form, opts view.Options, ov
 	if err != nil {
 		return nil, err
 	}
+	return s.artifact(rendering, form, opts)
+}
+
+// artifact writes a rendering in form at the session's width, linking elements
+// to their source when a link template is set.
+func (s *Session) artifact(rendering *view.Rendering, form view.Form, opts view.Options) ([]string, error) {
 	opts.Width = s.renderWidth
 	if opts.Links.Template != "" {
 		renderer, err := s.viewRenderer()
@@ -308,22 +314,41 @@ func (s *Session) renderPseudoView(spec string, overlay view.Overlay) (*view.Ren
 	if !ok {
 		return nil, fmt.Errorf("%s is no pseudo-view: write %s", spec, strings.Join(view.PseudoViewSpecs(), ", "))
 	}
+	var targets []string
+	if target != "" {
+		targets = []string{target}
+	}
+	return s.renderExposed(kind, targets, overlay)
+}
+
+// renderExposed renders the named elements directly, with no view declared, in
+// kind — or, when kind is empty, in the kind the elements call for (see
+// view.Renderer.DefaultKind). No name renders the loaded documents.
+func (s *Session) renderExposed(kind view.Kind, targets []string, overlay view.Overlay) (*view.Rendering, error) {
 	renderer, err := s.overlaidRenderer(overlay)
 	if err != nil {
 		return nil, err
 	}
 	var exposed []*symbols.Symbol
 	stated := "no view declared; rendering the loaded documents directly"
-	if target != "" {
-		sym, fqn, err := s.lookupSymbol(target)
-		if err != nil {
-			return nil, err
+	if len(targets) > 0 {
+		names := make([]string, 0, len(targets))
+		for _, target := range targets {
+			sym, fqn, err := s.lookupSymbol(target)
+			if err != nil {
+				return nil, err
+			}
+			exposed = append(exposed, sym)
+			names = append(names, notationName(fqn))
 		}
-		exposed = append(exposed, sym)
-		stated = fmt.Sprintf("no view declared; rendering %s directly", notationName(fqn))
+		stated = fmt.Sprintf("no view declared; rendering %s directly", strings.Join(names, ", "))
 	} else {
 		exposed = s.symbolsInLoadOrder(model.TopLevelDeclarations)
 	}
+	if kind == "" {
+		kind = renderer.DefaultKind(exposed)
+		stated += fmt.Sprintf(", as the %s rendering the elements call for", kind)
+	}
 	rendering, err := renderer.RenderExposed(exposed, kind, stated)
 	if err != nil {
 		return nil, err
diff --git a/internal/frontend/repl/view_viz_test.go b/internal/frontend/repl/view_viz_test.go
new file mode 100644
index 0000000000..7289f9f087
--- /dev/null
+++ b/internal/frontend/repl/view_viz_test.go
@@ -0,0 +1,293 @@
+package repl
+
+import (
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/diag"
+)
+
+const vizModel = `package P {
+  part def Wheel;
+  part def Car { part fl : Wheel; part fr : Wheel; connect fl to fr; }
+  part car : Car { part a : Wheel; part b : Wheel; connect a to b; }
+  part lone : Wheel;
+  part def Device { attribute y; }
+  part reader { part second : Device; attribute reading = second.y; }
+  state def Lamp { state off; state on; transition off then on; }
+  state lamp : Lamp;
+  action def Start { action a; action b; first a then b; }
+  action start : Start;
+  use case def Drive;
+  part 'text';
+}
+`
+
+func vizSession(t *testing.T) *Session {
+	t.Helper()
+	s := NewSession()
+	res := s.Submit(vizModel)
+	for _, d := range res.Diagnostics {
+		if d.Severity == diag.SeverityError {
+			t.Fatalf("model did not load: %v", res.Diagnostics)
+		}
+	}
+	return s
+}
+
+func TestVizChoosesTheKindTheElementsCallFor(t *testing.T) {
+	s := vizSession(t)
+	cases := []struct {
+		line string
+		kind string
+	}{
+		{"%viz P::Lamp", "state rendering"},
+		{"%viz P::lamp", "state rendering"},
+		{"%viz P::Start", "action rendering"},
+		{"%viz P::start", "action rendering"},
+		{"%viz P::car", "interconnection rendering"},
+		{"%viz P::reader", "interconnection rendering"},
+		{"%viz P::Car", "tree rendering"},
+		{"%viz P::lone", "tree rendering"},
+		{"%viz P", "tree rendering"},
+		{"%viz P::Drive", "case rendering"},
+		{"%viz P::Lamp P::lamp", "state rendering"},
+		{"%viz P::Lamp P::Start", "mixed rendering"},
+		{"%viz --view=DEFAULT P::Lamp", "state rendering"},
+	}
+	for _, c := range cases {
+		got := run(t, s, c.line)
+		if !strings.HasPrefix(got, c.kind) {
+			t.Errorf("%s drew %q, want the %s", c.line, strings.SplitN(got, "\n", 2)[0], c.kind)
+		}
+		if !strings.Contains(got, "the elements call for") {
+			t.Errorf("%s did not say the kind was chosen from the elements:\n%s", c.line, got)
+		}
+	}
+}
+
+func TestVizDrawsSeveralNamesInOneRendering(t *testing.T) {
+	s := vizSession(t)
+	got := run(t, s, "%viz P::Lamp P::Start")
+	wants(t, got, "rendering P::Lamp, P::Start directly", "state def P::Lamp", "action def P::Start", "off -> on", "a -> b")
+}
+
+func TestVizTakesTheViewInAnyCase(t *testing.T) {
+	s := vizSession(t)
+	cases := map[string]string{
+		"%viz --view STATE P::Lamp":          "state rendering",
+		"%viz --view=state P::Lamp":          "state rendering",
+		"%viz --view Tree P::Lamp":           "tree rendering",
+		"%viz P::Lamp --view=Mixed":          "mixed rendering",
+		"%viz --view INTERCONNECTION P::car": "interconnection rendering",
+		"%viz --view ACTION P::Start":        "action rendering",
+		"%viz --view SEQUENCE P::Car":        "sequence rendering",
+		"%viz --view CASE P::Drive":          "case rendering",
+	}
+	for line, want := range cases {
+		got := run(t, s, line)
+		if !strings.HasPrefix(got, want) || strings.Contains(got, "call for") {
+			t.Errorf("%s drew %q, want the %s as asked", line, strings.SplitN(got, "\n", 2)[0], want)
+		}
+	}
+}
+
+func TestVizTakesAFormWhereverItStands(t *testing.T) {
+	s := vizSession(t)
+	for _, line := range []string{"%viz mermaid P::Lamp", "%viz P::Lamp mermaid", "%viz --view STATE mermaid --style LR P::Lamp"} {
+		wants(t, run(t, s, line), "stateDiagram-v2")
+	}
+	wants(t, run(t, s, "%viz plantuml P::car"), "@startuml")
+	wants(t, run(t, s, "%viz --style PUMLCODE P::car"), "@startuml")
+	wants(t, run(t, s, "%viz --style pumlcode plantuml P::car"), "@startuml")
+	// A quoted word is a name, not a form.
+	wants(t, run(t, s, "%viz 'text'"), "tree rendering", "part P::text")
+	if got := run(t, s, "%viz text P::Car"); !strings.HasPrefix(got, "tree rendering") {
+		t.Errorf("the text form drew %q", strings.SplitN(got, "\n", 2)[0])
+	}
+}
+
+func TestVizMapsTheStylesItDraws(t *testing.T) {
+	s := vizSession(t)
+	wants(t, run(t, s, "%viz --style LR mermaid P::Lamp"), "direction LR")
+	wants(t, run(t, s, "%viz --style=lr mermaid P::Car"), "flowchart LR")
+	wants(t, run(t, s, "%viz --style BT mermaid P::Car"), "flowchart BT")
+	wants(t, run(t, s, "%viz --style cameo dot P::Car"), "Arial")
+	wants(t, run(t, s, "%viz --style okabe-ito --style full mermaid P::car"), "flowchart")
+	if got := run(t, s, "%viz --style DEFAULT mermaid P::Car"); !strings.Contains(got, "flowchart") || strings.Contains(got, "not represented") {
+		t.Errorf("the pilot's DEFAULT style is the pilot drawing style, not a note:\n%s", got)
+	}
+}
+
+func TestVizNotesThePilotStylesItDoesNotDraw(t *testing.T) {
+	s := vizSession(t)
+	got := run(t, s, "%viz --style ortholine --style LR --style ShowInherited --style ORTHOLINE P::Car")
+	wants(t, got, "tree rendering", "not represented:", "style ORTHOLINE (orthogonal line style) is not drawn", "style SHOWINHERITED (show inherited members) is not drawn")
+	if strings.Count(got, "ORTHOLINE") != 1 {
+		t.Errorf("a style given twice is noted once:\n%s", got)
+	}
+	wants(t, run(t, s, "%viz --style polyline mermaid P::Car"), "%% not represented: style POLYLINE (polyline style) is not drawn", "flowchart")
+	wants(t, run(t, s, "%viz --style compmost dot P::Car"), "// not represented: style COMPMOST")
+}
+
+func TestVizMisuseShowsUsage(t *testing.T) {
+	s := vizSession(t)
+	cases := map[string]string{
+		"%viz":                                        "name at least one element",
+		"%viz --view STATE":                           "name at least one element",
+		"%viz --view":                                 "--view takes a view name",
+		"%viz --style":                                "--style takes a style name",
+		"%viz --view nope P::Car":                     `unknown view "nope"; the views are DEFAULT, TREE, INTERCONNECTION, STATE, ACTION, SEQUENCE, MIXED, CASE`,
+		"%viz --view=TABLE P::Car":                    `unknown view "TABLE"`,
+		"%viz --view TREE --view TREE P::Car":         "--view is given twice",
+		"%viz --style nosuch P::Car":                  `unknown style "nosuch"; the styles are TB, LR, RL, BT, pilot, cameo, `,
+		"%viz --style LR --style TB P::Car":           "style LR and style TB both set the direction",
+		"%viz --style pilot --style cameo P::Car":     "both set the drawing style",
+		"%viz --style minimal --style full P::Car":    "both set the port display",
+		"%viz --style viridis --style cividis P::Car": "both set the palette",
+		"%viz --bogus P::Car":                         `unknown option "--bogus"; the options are --view and --style`,
+		"%viz mermaid dot P::Car":                     "mermaid and dot both name the form",
+		"%viz --style PUMLCODE mermaid P::Car":        "style PUMLCODE asks for the plantuml form, but the mermaid form was asked for",
+		"%viz mermaid --style PUMLCODE P::Car":        "style PUMLCODE asks for the plantuml form, but the mermaid form was asked for",
+	}
+	for line, want := range cases {
+		out, _, err := s.RunMeta(line)
+		if err != nil {
+			t.Fatal(err)
+		}
+		if len(out) != 2 || !strings.HasPrefix(out[0], errPrefix) || !strings.Contains(out[0], want) || out[1] != vizUsage {
+			t.Errorf("%q = %q, want %q and the usage line", line, out, want)
+		}
+		_, err = s.Viz(MetaArgs(line)[1:], view.FormText)
+		var usage *UsageError
+		if !asUsageError(err, &usage) || !slices.Equal(usage.Lines, out) || usage.Error() != strings.TrimPrefix(out[0], errPrefix) {
+			t.Errorf("Viz(%q) = %v, want a *UsageError holding %q", line, err, out)
+		}
+	}
+	for _, line := range []string{"%viz --help", "%viz -h", "%viz P::Car --help"} {
+		if out, _, _ := s.RunMeta(line); !slices.Equal(out, []string{vizUsage}) {
+			t.Errorf("%q = %q, want the usage line", line, out)
+		}
+	}
+}
+
+func TestVizNamesWhatItCannotResolve(t *testing.T) {
+	s := vizSession(t)
+	got := run(t, s, "%viz P::Car P::Nope")
+	if !strings.HasPrefix(got, errPrefix) || !strings.Contains(got, "P::Nope") {
+		t.Errorf("an unresolved name was not reported by name: %q", got)
+	}
+	if _, err := s.Viz([]string{"Nope"}, view.FormText); err == nil || !strings.Contains(err.Error(), "Nope") {
+		t.Errorf("Viz(Nope) = %v, want an error naming it", err)
+	}
+	var usage *UsageError
+	if _, err := s.Viz([]string{"Nope"}, view.FormText); asUsageError(err, &usage) {
+		t.Error("an unresolved name is no usage problem")
+	}
+}
+
+func TestVizFallsBackToTheFormsTheKindSupports(t *testing.T) {
+	s := vizSession(t)
+	rendered, err := s.Viz([]string{"P::Lamp"}, view.FormMermaid, view.FormDot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rendered) != 2 || rendered[0].Form != view.FormMermaid || rendered[1].Form != view.FormDot {
+		t.Fatalf("Viz fell back to %+v, want mermaid then dot", rendered)
+	}
+	wants(t, strings.Join(rendered[0].Lines, "\n"), "stateDiagram-v2")
+	wants(t, strings.Join(rendered[1].Lines, "\n"), "digraph")
+	// A sequence rendering has no DOT form, so DOT is left out.
+	rendered, err = s.Viz([]string{"--view", "SEQUENCE", "P::Car"}, view.FormMermaid, view.FormDot)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rendered) != 1 || rendered[0].Form != view.FormMermaid {
+		t.Errorf("a sequence rendering fell back to %+v, want mermaid alone", rendered)
+	}
+	// A form asked for is the only one written.
+	rendered, err = s.Viz([]string{"dot", "P::Lamp"}, view.FormMermaid)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rendered) != 1 || rendered[0].Form != view.FormDot {
+		t.Errorf("an asked-for form was answered with %+v", rendered)
+	}
+	// With no fallback and no form asked for, the text the prompt prints.
+	rendered, err = s.Viz([]string{"P::Lamp"})
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(rendered) != 1 || rendered[0].Form != view.FormText {
+		t.Fatalf("Viz with no fallback answered %+v, want text", rendered)
+	}
+	wants(t, strings.Join(rendered[0].Lines, "\n"), "state rendering")
+}
+
+func TestVizIsInHelpAndCompletion(t *testing.T) {
+	if !strings.Contains(strings.Join(helpText(), "\n"), "%viz [--view=<VIEW>] [--style=<STYLE>...] [form] <name> [<name>...]") {
+		t.Error("the viz command is not in help with the pilot's grammar")
+	}
+	if !slices.Contains(metaCommands(), "%viz") || !KnownMeta("%viz") {
+		t.Error("the viz command is not in the command table")
+	}
+	s := vizSession(t)
+	cases := []struct {
+		head      string
+		want      []string
+		forbidden []string
+	}{
+		{"%vi", []string{"%viz"}, nil},
+		{"%viz --", []string{"--view=", "--style="}, nil},
+		{"%viz --v", []string{"--view="}, []string{"--style="}},
+		{"%viz --view=", []string{"--view=DEFAULT", "--view=TREE", "--view=STATE", "--view=CASE"}, nil},
+		{"%viz --view=st", []string{"--view=state"}, []string{"--view=tree", "--view=STATE"}},
+		{"%viz --view=ST", []string{"--view=STATE"}, []string{"--view=state"}},
+		{"%viz --view=St", []string{"--view=StATE"}, nil},
+		{"%viz --view ", []string{"DEFAULT", "TREE", "INTERCONNECTION", "STATE", "ACTION", "SEQUENCE", "MIXED", "CASE"}, []string{"P::Car", "mermaid"}},
+		{"%viz --view tr", []string{"tree"}, []string{"state", "TREE"}},
+		{"%viz --view TR", []string{"TREE"}, []string{"STATE"}},
+		{"%viz --style ", []string{"LR", "TB", "pilot", "cameo", "okabe-ito", "minimal", "ORTHOLINE", "PUMLCODE"}, []string{"P::Car"}},
+		{"%viz --style=or", []string{"--style=ortholine"}, nil},
+		{"%viz --style=OR", []string{"--style=ORTHOLINE"}, nil},
+		{"%viz --style l", []string{"lr"}, []string{"LR"}},
+		{"%viz --style LR --style ca", []string{"cameo"}, []string{"P::Car"}},
+		{"%viz P::L", []string{"P::Lamp"}, []string{"mermaid"}},
+		{"%viz P::l", []string{"P::lamp", "P::lone"}, []string{"mermaid"}},
+		{"%viz --view STATE P::L", []string{"P::Lamp"}, nil},
+		{"%viz me", []string{"mermaid"}, nil},
+		{"%viz ", []string{"text", "mermaid", "dot", "--view=", "--style="}, nil},
+		{"%viz mermaid P::L", []string{"P::Lamp"}, nil},
+		{"%viz mermaid ", []string{"Car", "Lamp"}, []string{"markdown", "--view="}},
+		{"%viz mermaid P::Car ", []string{"Car", "Lamp"}, []string{"markdown"}},
+		{"%viz P::Car me", []string{"mermaid"}, nil},
+	}
+	for _, c := range cases {
+		got := s.Complete(c.head, len(c.head))
+		for _, want := range c.want {
+			if !slices.Contains(got.Candidates, want) {
+				t.Errorf("completing %q offered %v, want %s", c.head, got.Candidates, want)
+			}
+		}
+		for _, forbidden := range c.forbidden {
+			if slices.Contains(got.Candidates, forbidden) {
+				t.Errorf("completing %q offered %s", c.head, forbidden)
+			}
+		}
+		for _, cand := range got.Candidates {
+			if !strings.HasPrefix(cand, got.Prefix) {
+				t.Errorf("completing %q offered %q, which does not begin with the typed %q", c.head, cand, got.Prefix)
+			}
+		}
+	}
+}
+
+func asUsageError(err error, usage **UsageError) bool {
+	u, ok := err.(*UsageError)
+	if ok {
+		*usage = u
+	}
+	return ok
+}
diff --git a/internal/frontend/repl/viz.go b/internal/frontend/repl/viz.go
new file mode 100644
index 0000000000..3b873e04a4
--- /dev/null
+++ b/internal/frontend/repl/viz.go
@@ -0,0 +1,257 @@
+package repl
+
+import (
+	"fmt"
+	"slices"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+)
+
+const vizUsage = "usage: %viz [--view=<VIEW>|--view <VIEW>] [--style=<STYLE>...] [text|mermaid|markdown|dot|plantuml|d2|csv|tsv] <name> [<name>...]"
+
+// vizDefaultView is the view that chooses the rendering kind from what the names
+// resolve to; it is the view when --view is absent.
+const vizDefaultView = "DEFAULT"
+
+// vizViews are the views %viz draws, as the pilot kernel spells them: the
+// pilot's own list, and CASE for the case rendering the pilot chooses but does
+// not name.
+func vizViews() []string {
+	return []string{vizDefaultView, "TREE", "INTERCONNECTION", "STATE", "ACTION", "SEQUENCE", "MIXED", "CASE"}
+}
+
+// vizViewKind is the rendering kind a view name asks for, in any letter case;
+// the default view is the empty kind, chosen later from the elements.
+func vizViewKind(name string) (view.Kind, bool) {
+	upper := strings.ToUpper(name)
+	if !slices.Contains(vizViews(), upper) {
+		return "", false
+	}
+	if upper == vizDefaultView {
+		return "", true
+	}
+	return view.PseudoViewKind(strings.ToLower(upper))
+}
+
+// vizStyles are the words --style accepts, as they are offered: the pilot's
+// directions and styles as the pilot spells them, and this renderer's drawing
+// styles, palettes and port displays.
+func vizStyles() []string {
+	out := []string{string(view.DirectionTopBottom), string(view.DirectionLeftRight), string(view.DirectionRightLeft), string(view.DirectionBottomTop)}
+	for _, style := range view.DrawingStyles() {
+		out = append(out, string(style))
+	}
+	for _, palette := range view.Palettes() {
+		out = append(out, string(palette))
+	}
+	for _, ports := range view.PortsChoices() {
+		out = append(out, string(ports))
+	}
+	out = append(out, vizPilotDefaultStyle, vizPlantUMLCodeStyle)
+	for _, style := range view.PilotStyles() {
+		out = append(out, string(style))
+	}
+	return out
+}
+
+const (
+	// vizPilotDefaultStyle is the pilot's name for its standard black-and-white
+	// look, which is the pilot drawing style here.
+	vizPilotDefaultStyle = "DEFAULT"
+	// vizPlantUMLCodeStyle is the pilot's style asking for the PlantUML source
+	// rather than a picture, which is the plantuml form here.
+	vizPlantUMLCodeStyle = "PUMLCODE"
+)
+
+// vizRequest is a parsed %viz line: the kind asked for ("" chooses from the
+// elements), the form asked for ("" leaves it to the caller), the drawing
+// options, the notes on styles accepted but not drawn, and the names to draw.
+type vizRequest struct {
+	kind      view.Kind
+	form      view.Form
+	formStyle string // the style word that chose the form, when one did
+	opts      view.Options
+	notes     []string
+	names     []string
+}
+
+// parseVizArgs reads %viz's arguments; usage is what to print instead when they
+// do not read. Options and the form are read wherever they stand; an unquoted
+// word spelling a form is the form, so an element so named is written with its
+// quotes.
+func parseVizArgs(args []string) (vizRequest, []string) {
+	var req vizRequest
+	viewSet := false
+	value := func(i *int, option string) (string, bool) {
+		if *i+1 >= len(args) {
+			return "", false
+		}
+		*i++
+		return args[*i], true
+	}
+	for i := 0; i < len(args); i++ {
+		word := args[i]
+		switch {
+		case word == "--help" || word == "-h":
+			return req, []string{vizUsage}
+		case word == "--view" || strings.HasPrefix(word, "--view="):
+			name, ok := strings.CutPrefix(word, "--view=")
+			if !ok {
+				if name, ok = value(&i, word); !ok {
+					return req, vizUsageOf("--view takes a view name")
+				}
+			}
+			if viewSet {
+				return req, vizUsageOf("--view is given twice")
+			}
+			kind, ok := vizViewKind(name)
+			if !ok {
+				return req, vizUsageOf(fmt.Sprintf("unknown view %q; the views are %s", name, strings.Join(vizViews(), ", ")))
+			}
+			req.kind, viewSet = kind, true
+		case word == "--style" || strings.HasPrefix(word, "--style="):
+			name, ok := strings.CutPrefix(word, "--style=")
+			if !ok {
+				if name, ok = value(&i, word); !ok {
+					return req, vizUsageOf("--style takes a style name")
+				}
+			}
+			if usage := req.applyStyle(name); usage != nil {
+				return req, usage
+			}
+		case strings.HasPrefix(word, "-") && len(word) > 1:
+			return req, vizUsageOf(fmt.Sprintf("unknown option %q; the options are --view and --style", word))
+		case slices.Contains(view.Forms(), view.Form(word)):
+			if req.form != "" && req.form != view.Form(word) {
+				if req.formStyle != "" {
+					return req, vizUsageOf(fmt.Sprintf("style %s asks for the %s form, but the %s form was asked for", req.formStyle, req.form, word))
+				}
+				return req, vizUsageOf(fmt.Sprintf("%s and %s both name the form", req.form, word))
+			}
+			req.form = view.Form(word)
+		default:
+			req.names = append(req.names, word)
+		}
+	}
+	if len(req.names) == 0 {
+		return req, vizUsageOf("name at least one element to draw")
+	}
+	return req, nil
+}
+
+// applyStyle reads one --style word: a direction, a drawing style, a palette or
+// a port display is applied; a pilot style this renderer does not draw is noted;
+// any other word is refused with the list.
+func (req *vizRequest) applyStyle(name string) []string {
+	if direction, ok := view.ParseDirection(strings.ToUpper(name)); ok {
+		if req.opts.Direction != "" {
+			return vizUsageOf(fmt.Sprintf("style %s and style %s both set the direction", req.opts.Direction, name))
+		}
+		req.opts.Direction = direction
+		return nil
+	}
+	lower := strings.ToLower(name)
+	if strings.EqualFold(name, vizPilotDefaultStyle) {
+		lower = string(view.StylePilot)
+	}
+	if style, ok := view.ParseDrawingStyle(lower); ok && lower != "" {
+		if req.opts.Style != "" {
+			return vizUsageOf(fmt.Sprintf("style %s and style %s both set the drawing style", req.opts.Style, name))
+		}
+		req.opts.Style = style
+		return nil
+	}
+	if palette, ok := view.ParsePalette(lower); ok && palette != "" {
+		if req.opts.Palette != "" {
+			return vizUsageOf(fmt.Sprintf("style %s and style %s both set the palette", req.opts.Palette, name))
+		}
+		req.opts.Palette = palette
+		return nil
+	}
+	if ports, ok := view.ParsePorts(lower); ok && ports != "" {
+		if req.opts.Ports != "" {
+			return vizUsageOf(fmt.Sprintf("style %s and style %s both set the port display", req.opts.Ports, name))
+		}
+		req.opts.Ports = ports
+		return nil
+	}
+	if strings.EqualFold(name, vizPlantUMLCodeStyle) {
+		if req.form != "" && req.form != view.FormPlantUML {
+			return vizUsageOf(fmt.Sprintf("style %s asks for the plantuml form, but the %s form was asked for", name, req.form))
+		}
+		req.form, req.formStyle = view.FormPlantUML, name
+		return nil
+	}
+	if style, ok := view.ParsePilotStyle(name); ok {
+		if !slices.Contains(req.notes, style.Notice()) {
+			req.notes = append(req.notes, style.Notice())
+		}
+		return nil
+	}
+	return vizUsageOf(fmt.Sprintf("unknown style %q; the styles are %s", name, strings.Join(vizStyles(), ", ")))
+}
+
+func vizUsageOf(problem string) []string {
+	return []string{errPrefix + problem, vizUsage}
+}
+
+// metaViz runs %viz at the prompt, where a rendering with no form asked for is
+// written as %render writes one: as text.
+func (s *Session) metaViz(args []string) ([]string, bool, error) {
+	req, usage := parseVizArgs(args)
+	if usage != nil {
+		return usage, false, nil
+	}
+	rendered, err := s.viz(req)
+	if err != nil {
+		return []string{errPrefix + err.Error()}, false, nil
+	}
+	return rendered[0].Lines, false, nil
+}
+
+// Viz runs %viz with its arguments and answers what it drew: the artifact in
+// the form asked for, or, when none was, in each of the fallback forms the
+// chosen rendering kind is written in — the first alone when it is written in
+// none of them — or as text when no fallback is given. A usage problem is a *UsageError holding what the prompt
+// prints; a name that does not resolve is an error naming it.
+func (s *Session) Viz(args []string, fallback ...view.Form) ([]Rendered, error) {
+	defer s.enter()()
+	req, usage := parseVizArgs(args)
+	if usage != nil {
+		return nil, &UsageError{Lines: usage}
+	}
+	return s.viz(req, fallback...)
+}
+
+func (s *Session) viz(req vizRequest, fallback ...view.Form) ([]Rendered, error) {
+	if len(fallback) == 0 {
+		fallback = []view.Form{view.FormText}
+	}
+	rendering, err := s.renderExposed(req.kind, req.names, "")
+	if err != nil {
+		return nil, err
+	}
+	rendering.Notices = append(rendering.Notices, req.notes...)
+	forms := []view.Form{req.form}
+	if req.form == "" {
+		forms = forms[:0]
+		for _, form := range fallback {
+			if rendering.Kind.SupportsForm(form) {
+				forms = append(forms, form)
+			}
+		}
+		if len(forms) == 0 {
+			forms = fallback[:1]
+		}
+	}
+	out := make([]Rendered, 0, len(forms))
+	for _, form := range forms {
+		lines, err := s.artifact(rendering, form, req.opts)
+		if err != nil {
+			return nil, err
+		}
+		out = append(out, Rendered{Form: form, Lines: lines})
+	}
+	return out, nil
+}
diff --git a/internal/ir/lower/state_graph.go b/internal/ir/lower/state_graph.go
index 79d8987ad9..a0a3668a9f 100644
--- a/internal/ir/lower/state_graph.go
+++ b/internal/ir/lower/state_graph.go
@@ -1111,11 +1111,12 @@ func parallelOwnedMember(member ast.Node) bool {
 		*ast.EntryMember, *ast.DoMember, *ast.ExitMember,
 		*ast.PseudostateNode,
 		*ast.SuccessionEdge, *ast.TransitionEdge, *ast.TransitionMember,
-		*ast.Definition, *ast.Package, *ast.ErrorNode:
+		*ast.PrefixMetadata, *ast.Definition, *ast.Package, *ast.ErrorNode:
 		return true
 	case *ast.Usage:
 		switch n.Kind {
-		case ast.UsageAttribute, ast.UsageItem, ast.UsagePort, ast.UsageSuccession, ast.UsageMetadata:
+		case ast.UsageAttribute, ast.UsageItem, ast.UsagePort, ast.UsageSuccession, ast.UsageMetadata,
+			ast.UsageView, ast.UsageViewpoint, ast.UsageRendering, ast.UsageViewRendering:
 			return true
 		}
 		return IsTerminateUsage(n)
diff --git a/internal/ir/lower/state_inheritance.go b/internal/ir/lower/state_inheritance.go
index 2b9f816c2b..b6947e6775 100644
--- a/internal/ir/lower/state_inheritance.go
+++ b/internal/ir/lower/state_inheritance.go
@@ -426,12 +426,13 @@ func loweredElsewhere(member ast.Node) bool {
 	switch n := member.(type) {
 	case *ast.Comment, *ast.Documentation, *ast.TextualRepresentation,
 		*ast.SuccessionEdge, *ast.TransitionEdge, *ast.TransitionMember,
-		*ast.InitialNode, *ast.FinalNode,
+		*ast.InitialNode, *ast.FinalNode, *ast.PrefixMetadata,
 		*ast.Definition, *ast.Package, *ast.ErrorNode:
 		return true
 	case *ast.Usage:
 		switch n.Kind {
-		case ast.UsageSuccession, ast.UsageTransition, ast.UsagePort:
+		case ast.UsageSuccession, ast.UsageTransition, ast.UsagePort,
+			ast.UsageView, ast.UsageViewpoint, ast.UsageRendering, ast.UsageViewRendering, ast.UsageMetadata:
 			return true
 		}
 	}
diff --git a/internal/ir/lower/state_inherited_test.go b/internal/ir/lower/state_inherited_test.go
index 8d691d229c..b49e423d9a 100644
--- a/internal/ir/lower/state_inherited_test.go
+++ b/internal/ir/lower/state_inherited_test.go
@@ -462,3 +462,74 @@ func inheritedTarget(t *testing.T, graph *StateGraph, usage *ast.StateNode, name
 	t.Fatalf("no transition under %s ends at %s", usage.Name, name)
 	return nil
 }
+
+// A view, a viewpoint, a rendering or a metadata annotation a state definition
+// declares is not state content, so a usage of the definition inherits its
+// substates past them.
+func TestToStateGraphTypedStateUsageSkipsInheritedViewsAndMetadata(t *testing.T) {
+	graph := stateGraphOf(t, `
+		package test {
+			metadata def Note;
+			state def Inner {
+				view V : StandardViewDefinitions::StateTransitionView { expose Inner; render Views::asInterconnectionDiagram; }
+				viewpoint P;
+				rendering R;
+				@Note;
+				metadata Note about i1;
+				entry; then i1;
+				state i1;
+				state i2;
+			}
+			state def Machine {
+				entry; then nested;
+				state nested : Inner;
+			}
+		}
+	`, "Machine")
+
+	nested := stateNamed(graph, "nested")
+	if nested == nil {
+		t.Fatal("typed state usage was not collected")
+	}
+	for _, name := range []string{"i1", "i2"} {
+		child := stateNamed(graph, name)
+		if child == nil {
+			t.Fatalf("inherited substate %s was not collected", name)
+		}
+		if graph.ParentState[child] != nested {
+			t.Fatalf("parent of %s = %v, want nested", name, graph.ParentState[child])
+		}
+	}
+}
+
+// A parallel state definition's views and metadata are no regions, so a usage
+// typed by it still lowers to its regions.
+func TestToStateGraphTypedParallelStateUsageSkipsInheritedViewsAndMetadata(t *testing.T) {
+	graph := stateGraphOf(t, `
+		package test {
+			metadata def Note;
+			state def Inner parallel {
+				view V : StandardViewDefinitions::StateTransitionView { expose Inner; render Views::asInterconnectionDiagram; }
+				viewpoint P;
+				rendering R;
+				@Note;
+				state left { entry; then idle; state idle; }
+				state right { entry; then busy; state busy; }
+			}
+			state def Machine {
+				entry; then nested;
+				state nested : Inner;
+			}
+		}
+	`, "Machine")
+
+	nested := stateNamed(graph, "nested")
+	if nested == nil {
+		t.Fatal("typed parallel state usage was not collected")
+	}
+	for _, name := range []string{"idle", "busy"} {
+		if stateNamed(graph, name) == nil {
+			t.Fatalf("inherited region substate %s was not collected", name)
+		}
+	}
+}
diff --git a/internal/ir/view/default_kind.go b/internal/ir/view/default_kind.go
new file mode 100644
index 0000000000..61970ec67a
--- /dev/null
+++ b/internal/ir/view/default_kind.go
@@ -0,0 +1,73 @@
+package view
+
+import "github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+
+// DefaultKind chooses the rendering kind a set of elements is drawn in when
+// none is asked for: the kind each element calls for, and KindMixed when they
+// disagree. An element asks for a state rendering when it is a state def or
+// usage, an action rendering when it is an action def or usage, a case
+// rendering when it is a case def or usage of any kind, an interconnection
+// rendering when it is a structural usage holding a connector, binding or flow,
+// and a tree rendering otherwise — a definition, a package or a usage with no
+// connections to draw. An empty set is a tree.
+func (r *Renderer) DefaultKind(exposed []*symbols.Symbol) Kind {
+	chosen := Kind("")
+	for _, sym := range exposed {
+		kind := r.ElementKind(sym)
+		switch {
+		case chosen == "":
+			chosen = kind
+		case chosen != kind:
+			return KindMixed
+		}
+	}
+	if chosen == "" {
+		return KindTree
+	}
+	return chosen
+}
+
+// ElementKind is the rendering kind one element calls for; see DefaultKind.
+func (r *Renderer) ElementKind(sym *symbols.Symbol) Kind {
+	if sym == nil {
+		return KindTree
+	}
+	switch sym.Kind {
+	case symbols.SymbolStateDef, symbols.SymbolStateUsage:
+		return KindState
+	case symbols.SymbolActionDef, symbols.SymbolActionUsage:
+		return KindAction
+	case symbols.SymbolCaseDef, symbols.SymbolCaseUsage,
+		symbols.SymbolAnalysisCaseDef, symbols.SymbolAnalysisCaseUsage,
+		symbols.SymbolVerificationCaseDef, symbols.SymbolVerificationCaseUsage,
+		symbols.SymbolUseCaseDef, symbols.SymbolUseCaseUsage:
+		return KindCase
+	}
+	if sym.Kind.IsFeature() && featureLike(sym) && r.holdsConnections(sym) {
+		return KindInterconnection
+	}
+	return KindTree
+}
+
+// holdsConnections reports whether an element contains a connection an
+// interconnection rendering draws as an edge: a connector, binding or flow
+// usage, or a feature bound by its value to another feature.
+func (r *Renderer) holdsConnections(sym *symbols.Symbol) bool {
+	for _, member := range r.containedMembers(sym) {
+		if r.drawsConnector(member) || r.bindsByValue(member) {
+			return true
+		}
+	}
+	return false
+}
+
+// bindsByValue reports whether a feature's value names another feature that
+// resolves — the binding valueBindingEdges draws.
+func (r *Renderer) bindsByValue(sym *symbols.Symbol) bool {
+	value := featureValue(sym)
+	if value == nil {
+		return false
+	}
+	_, resolved := r.resolver.ResolveTarget(sym.OwnerScope, value)
+	return resolved
+}
diff --git a/internal/ir/view/default_kind_test.go b/internal/ir/view/default_kind_test.go
new file mode 100644
index 0000000000..aa1acc1481
--- /dev/null
+++ b/internal/ir/view/default_kind_test.go
@@ -0,0 +1,148 @@
+package view
+
+import (
+	"slices"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+)
+
+const defaultKindModel = `package Demo {
+  part def Wheel;
+  part def Car {
+    part fl : Wheel;
+    part fr : Wheel;
+    connect fl to fr;
+  }
+  part def Bare { part w : Wheel; }
+  part car : Car {
+    part a : Wheel;
+    part b : Wheel;
+    connect a to b;
+  }
+  part lone : Wheel;
+  part def Device { attribute y : Real; }
+  part reader {
+    part second : Device;
+    attribute reading : Real = second.y;
+  }
+  part literal { attribute n : Real = 3; }
+  item def Cargo;
+  state def Lamp { state off; state on; transition off then on; }
+  state lamp : Lamp;
+  action def Start { action a; action b; first a then b; }
+  action start : Start;
+  calc def Sum { in x : Real; return x; }
+  use case def Drive;
+  use case drive : Drive;
+  analysis case def Study;
+}
+`
+
+func defaultKindFixture(t *testing.T) (*Renderer, *symbols.Index) {
+	t.Helper()
+	return loadSources(t, []string{"default-kind.sysml"}, [][]byte{[]byte(defaultKindModel)})
+}
+
+func TestElementKindFollowsWhatTheElementIs(t *testing.T) {
+	r, idx := defaultKindFixture(t)
+	cases := map[string]Kind{
+		"Demo":          KindTree,
+		"Demo::Wheel":   KindTree,
+		"Demo::Car":     KindTree,
+		"Demo::Bare":    KindTree,
+		"Demo::Cargo":   KindTree,
+		"Demo::Sum":     KindTree,
+		"Demo::lone":    KindTree,
+		"Demo::car":     KindInterconnection,
+		"Demo::reader":  KindInterconnection,
+		"Demo::literal": KindTree,
+		"Demo::Lamp":    KindState,
+		"Demo::lamp":    KindState,
+		"Demo::Start":   KindAction,
+		"Demo::start":   KindAction,
+		"Demo::Drive":   KindCase,
+		"Demo::drive":   KindCase,
+		"Demo::Study":   KindCase,
+	}
+	for fqn, want := range cases {
+		if got := r.ElementKind(lookup(t, idx, fqn)); got != want {
+			t.Errorf("ElementKind(%s) = %q, want %q", fqn, got, want)
+		}
+	}
+	if got := r.ElementKind(nil); got != KindTree {
+		t.Errorf("ElementKind(nil) = %q, want %q", got, KindTree)
+	}
+}
+
+func TestDefaultKindAgreesOrIsMixed(t *testing.T) {
+	r, idx := defaultKindFixture(t)
+	syms := func(fqns ...string) []*symbols.Symbol {
+		out := make([]*symbols.Symbol, 0, len(fqns))
+		for _, fqn := range fqns {
+			out = append(out, lookup(t, idx, fqn))
+		}
+		return out
+	}
+	cases := []struct {
+		names []string
+		want  Kind
+	}{
+		{nil, KindTree},
+		{[]string{"Demo::Lamp"}, KindState},
+		{[]string{"Demo::Lamp", "Demo::lamp"}, KindState},
+		{[]string{"Demo::Start", "Demo::start"}, KindAction},
+		{[]string{"Demo::Wheel", "Demo::Car"}, KindTree},
+		{[]string{"Demo::car"}, KindInterconnection},
+		{[]string{"Demo::car", "Demo::reader"}, KindInterconnection},
+		{[]string{"Demo::Lamp", "Demo::Start"}, KindMixed},
+		{[]string{"Demo::Car", "Demo::car"}, KindMixed},
+	}
+	for _, c := range cases {
+		if got := r.DefaultKind(syms(c.names...)); got != c.want {
+			t.Errorf("DefaultKind(%v) = %q, want %q", c.names, got, c.want)
+		}
+	}
+}
+
+// Every kind DefaultKind chooses renders through RenderExposed, so the choice
+// never names a kind the renderer refuses.
+func TestDefaultKindsAreRenderable(t *testing.T) {
+	r, idx := defaultKindFixture(t)
+	for _, fqn := range []string{"Demo", "Demo::car", "Demo::reader", "Demo::Lamp", "Demo::Start", "Demo::drive"} {
+		sym := lookup(t, idx, fqn)
+		kind := r.DefaultKind([]*symbols.Symbol{sym})
+		if _, ok := PseudoViewKind(string(kind)); !ok {
+			t.Errorf("%s: DefaultKind %q is no pseudo-view kind", fqn, kind)
+		}
+		if _, err := r.RenderExposed([]*symbols.Symbol{sym}, kind, ""); err != nil {
+			t.Errorf("%s: RenderExposed(%q): %v", fqn, kind, err)
+		}
+	}
+}
+
+func TestPilotStylesParseInAnyCaseAndNoteWhatTheyDo(t *testing.T) {
+	for _, name := range []string{"ortholine", "ORTHOLINE", "OrthoLine"} {
+		style, ok := ParsePilotStyle(name)
+		if !ok || style != "ORTHOLINE" {
+			t.Errorf("ParsePilotStyle(%q) = %q, %t", name, style, ok)
+		}
+	}
+	if _, ok := ParsePilotStyle("nosuch"); ok {
+		t.Error("an unknown name parsed as a pilot style")
+	}
+	styles := PilotStyles()
+	if !slices.IsSorted(styles) || len(styles) != len(pilotStyles) {
+		t.Errorf("PilotStyles() = %v, want every style sorted", styles)
+	}
+	for _, style := range styles {
+		notice := style.Notice()
+		if !strings.Contains(notice, string(style)) || !strings.Contains(notice, "not drawn") || strings.Contains(notice, "()") {
+			t.Errorf("%s.Notice() = %q", style, notice)
+		}
+	}
+	if got := PilotStyle("ORTHOLINE").Notice(); got != "style ORTHOLINE (orthogonal line style) is not drawn" {
+		t.Errorf("Notice = %q", got)
+	}
+}
diff --git a/internal/ir/view/pilot_style.go b/internal/ir/view/pilot_style.go
new file mode 100644
index 0000000000..830514b0ba
--- /dev/null
+++ b/internal/ir/view/pilot_style.go
@@ -0,0 +1,58 @@
+package view
+
+import (
+	"sort"
+	"strings"
+)
+
+// PilotStyle is a style name the OMG pilot kernel's %viz accepts that no form
+// here draws: a PlantUML line routing, a compartment layout, a visibility
+// switch of the pilot's own visualizer. Such a style is accepted so a notebook
+// written for the pilot runs, and is reported as not represented so it is not
+// dropped silently.
+type PilotStyle string
+
+// pilotStyles are the pilot's style names, each with the pilot's description
+// of what it does.
+var pilotStyles = map[PilotStyle]string{
+	"STDCOLOR":             "standard style with colors",
+	"PLANTUML":             "PlantUML style",
+	"POLYLINE":             "polyline style",
+	"ORTHOLINE":            "orthogonal line style",
+	"SHOWLIB":              "show elements of the standard libraries",
+	"SHOWINHERITED":        "show inherited members",
+	"COMPMOST":             "show as many memberships in a compartment as possible",
+	"COMPTREE":             "show nested ports in a compartment",
+	"SHOWIMPORTED":         "show imported elements",
+	"HIDEMETADATA":         "hide metadata",
+	"SHOWMETACLASS":        "show metaclasses of metaobjects",
+	"EVAL":                 "evaluate expressions",
+	"NODEMULTIPLICITY":     "show multiplicities in nodes",
+	"EDGEMULTIPLICITY":     "show multiplicities on edges",
+	"IMPLICITMULTIPLICITY": "show implicit multiplicities",
+}
+
+// PilotStyles are the pilot's undrawn style names in alphabetical order, as
+// the pilot spells them.
+func PilotStyles() []PilotStyle {
+	out := make([]PilotStyle, 0, len(pilotStyles))
+	for style := range pilotStyles {
+		out = append(out, style)
+	}
+	sort.Slice(out, func(i, j int) bool { return out[i] < out[j] })
+	return out
+}
+
+// ParsePilotStyle reports the pilot style name names, in any letter case, and
+// whether it names one.
+func ParsePilotStyle(name string) (PilotStyle, bool) {
+	style := PilotStyle(strings.ToUpper(name))
+	_, ok := pilotStyles[style]
+	return style, ok
+}
+
+// Notice is what a rendering reports for a pilot style it was asked for and
+// does not draw.
+func (s PilotStyle) Notice() string {
+	return "style " + string(s) + " (" + pilotStyles[s] + ") is not drawn"
+}
diff --git a/internal/ir/view/view.go b/internal/ir/view/view.go
index ba53196297..00c0b88cf9 100644
--- a/internal/ir/view/view.go
+++ b/internal/ir/view/view.go
@@ -96,6 +96,11 @@ func (k Kind) Supported() bool {
 // Tabular reports whether k is rendered as rows and columns.
 func (k Kind) Tabular() bool { return k == KindTable || k == KindMatrix }
 
+// GraphShaped reports whether k is drawn as a graph of nodes and edges: every
+// produced kind that is not tabular, the kinds a document's diagrams and the
+// DOT, Mermaid, PlantUML and D2 forms draw.
+func (k Kind) GraphShaped() bool { return k.Supported() && !k.Tabular() }
+
 // article is the indefinite article the kind reads with, so a message says "an
 // action rendering" rather than "a action rendering".
 func (k Kind) article() string {
diff --git a/internal/semantic/resolve/document.go b/internal/semantic/resolve/document.go
index cc8db81ada..230350b665 100644
--- a/internal/semantic/resolve/document.go
+++ b/internal/semantic/resolve/document.go
@@ -1918,7 +1918,7 @@ func (r *Resolver) IsBaseThat(sym *symbols.Symbol) bool {
 	if sym == nil {
 		return false
 	}
-	return sym.Name == baseThatFQN || r.registeredFQN(sym) == baseThatFQN
+	return sym.Name == baseThatFQN || (r.idx != nil && symbols.HasFQN(sym, baseThatFQN))
 }
 
 // getUsageType returns the type symbol of a usage by resolving its typing relationship.
diff --git a/internal/semantic/resolve/frames_test.go b/internal/semantic/resolve/frames_test.go
index f9b6a6b171..6acc0d34ca 100644
--- a/internal/semantic/resolve/frames_test.go
+++ b/internal/semantic/resolve/frames_test.go
@@ -224,3 +224,37 @@ func TestFramesReadingTheWholeIndexSurviveAJudgmentChange(t *testing.T) {
 		t.Fatalf("the refreshed table still declares X as %v", got)
 	}
 }
+
+// A document replaced by one stating the same wildcard import registers the
+// names the import surfaces again, as they were; a document that resolved
+// through one keeps what it memoized. Stated otherwise, the import moves them.
+func TestFramesSurviveAReexportRegisteredAgainAsItWas(t *testing.T) {
+	w := newTrackedIndex(t, map[string]string{
+		"lib.sysml":  "package Lib { part def Base; }",
+		"gate.sysml": "package P { public import Lib::*; }",
+		"user.sysml": "package P { part def Derived :> P::Base; }",
+	})
+	w.idx.ExpandWildcardImports()
+	w.idx.TakeChanges()
+	w.analyzeAll()
+	// As the workspace does: the imports are expanded again before the changes
+	// are read.
+	edit := func(src string) []string {
+		w.roots["gate.sysml"] = parsedRoot(t, "gate.sysml", src)
+		w.idx.AddDocument("gate.sysml", w.roots["gate.sysml"])
+		w.idx.ExpandWildcardImports()
+		ch := w.idx.TakeChanges()
+		ch.Docs = map[string]bool{"gate.sysml": true}
+		return w.r.Invalidate(ch)
+	}
+	if dropped := edit("package P { public import Lib::*; } // edited"); !reflect.DeepEqual(dropped, []string{"gate.sysml"}) {
+		t.Fatalf("dropped %v, want [gate.sysml]", dropped)
+	}
+	if !w.owned("user.sysml") {
+		t.Fatal("user.sysml, resolving through a re-export registered again as it was, lost what it memoized")
+	}
+	w.analyzeAll()
+	if dropped := edit("package P { private import Lib::*; }"); !reflect.DeepEqual(dropped, []string{"gate.sysml", "user.sysml"}) {
+		t.Fatalf("dropped %v, want [gate.sysml user.sysml]", dropped)
+	}
+}
diff --git a/internal/semantic/resolve/this_context.go b/internal/semantic/resolve/this_context.go
index e77382a203..e04b387d6d 100644
--- a/internal/semantic/resolve/this_context.go
+++ b/internal/semantic/resolve/this_context.go
@@ -19,7 +19,12 @@ func (r *Resolver) IsOccurrenceThis(sym *symbols.Symbol) bool {
 	if sym == nil {
 		return false
 	}
-	return sym.Name == thisFeatureName || strings.HasSuffix(sym.Name, thisFeatureSuffix) ||
+	if sym.Name == thisFeatureName || strings.HasSuffix(sym.Name, thisFeatureSuffix) {
+		return true
+	}
+	// Only a name that is itself a tail of `::this` can qualify to that suffix,
+	// so the qualified name is built for those alone.
+	return strings.HasSuffix(thisFeatureSuffix, sym.Name) &&
 		strings.HasSuffix(r.registeredFQN(sym), thisFeatureSuffix)
 }
 
diff --git a/internal/semantic/semantics/eval.go b/internal/semantic/semantics/eval.go
index 6331d0eee3..381a3f0ecc 100644
--- a/internal/semantic/semantics/eval.go
+++ b/internal/semantic/semantics/eval.go
@@ -172,6 +172,45 @@ type Value struct {
 	ext  *big.Rat
 }
 
+// Packed is an Integer, Rational, Real or Boolean Value in three words, for a
+// holder that keeps or passes many; Unpack restores the Value it was packed from.
+type Packed struct {
+	Kind ValueKind
+	Den  uint32
+	Bits uint64
+	Ext  *big.Rat
+}
+
+// Pack is v as a Packed.
+func (v Value) Pack() Packed {
+	p := Packed{Kind: v.Kind, Den: v.den, Ext: v.ext}
+	switch v.Kind {
+	case ValReal:
+		p.Bits = math.Float64bits(v.Real)
+	case ValBool:
+		if v.Bool {
+			p.Bits = 1
+		}
+	default:
+		p.Bits = uint64(v.Int) // #nosec G115 -- the Integer's two's-complement bits are stored, not its magnitude.
+	}
+	return p
+}
+
+// Unpack is the Value p packs.
+func (p Packed) Unpack() Value {
+	v := Value{Kind: p.Kind, den: p.Den, ext: p.Ext}
+	switch p.Kind {
+	case ValReal:
+		v.Real = math.Float64frombits(p.Bits)
+	case ValBool:
+		v.Bool = p.Bits != 0
+	default:
+		v.Int = int64(p.Bits) // #nosec G115 -- the inverse of Pack: the same bits read back as an Integer.
+	}
+	return v
+}
+
 // IsNumeric reports whether the value is an Integer, a Rational or a Real.
 func (v Value) IsNumeric() bool {
 	return v.Kind == ValInt || v.Kind == ValReal || v.Kind == ValRational
diff --git a/internal/semantic/semantics/packed_test.go b/internal/semantic/semantics/packed_test.go
new file mode 100644
index 0000000000..c275bf6b23
--- /dev/null
+++ b/internal/semantic/semantics/packed_test.go
@@ -0,0 +1,48 @@
+package semantics
+
+import (
+	"math"
+	"math/big"
+	"testing"
+)
+
+// Every Value a Packed can hold unpacks to the Value it was packed from, field
+// for field, the big form sharing its immutable big.Rat.
+func TestPackedRoundTrip(t *testing.T) {
+	bigRat, _ := new(big.Rat).SetString("12345678901234567890123/7")
+	values := []Value{
+		{},
+		{Kind: ValInfinity},
+		IntValue(0), IntValue(1), IntValue(-1), IntValue(math.MaxInt64), IntValue(math.MinInt64),
+		bigVal("1180591620717411303424"), bigVal("-1180591620717411303424"),
+		mustFrac(t, 1, 3), mustFrac(t, -7, 2), mustFrac(t, 6, 3), mustFrac(t, math.MaxInt64, math.MaxUint32),
+		RatValue(bigRat),
+		{Kind: ValReal, Real: 0}, {Kind: ValReal, Real: math.Copysign(0, -1)}, {Kind: ValReal, Real: 1.5},
+		{Kind: ValReal, Real: math.Inf(1)}, {Kind: ValReal, Real: math.Inf(-1)}, {Kind: ValReal, Real: math.NaN()},
+		{Kind: ValBool, Bool: true}, {Kind: ValBool, Bool: false},
+	}
+	for _, v := range values {
+		got := v.Pack().Unpack()
+		if v.Kind == ValReal && math.IsNaN(v.Real) {
+			if got.Kind != ValReal || !math.IsNaN(got.Real) || math.Float64bits(got.Real) != math.Float64bits(v.Real) {
+				t.Errorf("NaN round-trips to %+v", got)
+			}
+			continue
+		}
+		if got != v {
+			t.Errorf("%+v round-trips to %+v", v, got)
+		}
+		if got.ext != v.ext {
+			t.Errorf("%+v round-trips to another big.Rat", v)
+		}
+	}
+}
+
+func mustFrac(t *testing.T, num, den int64) Value {
+	t.Helper()
+	v, ok := FracValue(num, den)
+	if !ok {
+		t.Fatalf("FracValue(%d, %d) declined", num, den)
+	}
+	return v
+}
diff --git a/internal/semantic/semantics/state_activity.go b/internal/semantic/semantics/state_activity.go
index cdd15e631b..8507ec3126 100644
--- a/internal/semantic/semantics/state_activity.go
+++ b/internal/semantic/semantics/state_activity.go
@@ -14,7 +14,7 @@ const StateActivityFQN = StateActivityPackage + "::isActive"
 
 // IsStateActivity reports whether sym is the StateActivity::isActive feature.
 func IsStateActivity(sym *symbols.Symbol) bool {
-	return sym != nil && symbols.FQNOf(sym) == StateActivityFQN
+	return sym != nil && symbols.HasFQN(sym, StateActivityFQN)
 }
 
 // FeaturingTypes are the types sym declares itself `featured by` (KerML
diff --git a/internal/semantic/symbols/changes.go b/internal/semantic/symbols/changes.go
index 0acecfa54a..f725d3157f 100644
--- a/internal/semantic/symbols/changes.go
+++ b/internal/semantic/symbols/changes.go
@@ -80,13 +80,15 @@ func (idx *Index) noteBefore(fqn string) {
 // tables: the symbols registered under it, in order, each with its re-export
 // and hidden marks and the claims and routes that surfaced it. It holds the
 // symbols themselves, so one dropped since cannot have its address reused by
-// a new symbol that would then compare equal to it.
+// a new symbol that would then compare equal to it. The claims are the index's
+// own maps, not copies: a write replaces a claims map rather than changing it
+// (see Index.reexportDocs), so the one noted stays as it was read.
 type registration []registeredSymbol
 
 type registeredSymbol struct {
 	sym                *Symbol
 	reexported, hidden bool
-	claims             map[string]reexportClaim
+	claims             map[string]*reexportClaim
 }
 
 func registrationOf(idx *Index, fqn string) registration {
@@ -98,12 +100,11 @@ func registrationOf(idx *Index, fqn string) registration {
 	hidden, _ := idx.hidden.get(fqn)
 	out := make(registration, len(syms))
 	for i, sym := range syms {
-		out[i] = registeredSymbol{sym: sym, reexported: reexported.has(sym), hidden: hidden.has(sym)}
-		if claims := idx.reexportDocs.at(reexportKey{fqn: fqn, sym: sym}); len(claims) > 0 {
-			out[i].claims = make(map[string]reexportClaim, len(claims))
-			for doc, claim := range claims {
-				out[i].claims[doc] = reexportClaim{public: claim.public, routes: append([]gateRoute(nil), claim.routes...)}
-			}
+		out[i] = registeredSymbol{
+			sym:        sym,
+			reexported: reexported.has(sym),
+			hidden:     hidden.has(sym),
+			claims:     idx.reexportDocs.at(reexportKey{fqn: fqn, sym: sym}),
 		}
 	}
 	return out
diff --git a/internal/semantic/symbols/changes_test.go b/internal/semantic/symbols/changes_test.go
index 2f3795fe75..6dd02204dc 100644
--- a/internal/semantic/symbols/changes_test.go
+++ b/internal/semantic/symbols/changes_test.go
@@ -145,3 +145,68 @@ func TestTakeChangesLeavesOutWhatIsRegisteredAgainAsItWas(t *testing.T) {
 		t.Errorf("a library parsed again leaves its declarations and their re-exports unchanged: %v", keys(ch.Names))
 	}
 }
+
+// A re-export two documents surface outlives the replacement of one of them
+// under the other's claim. The replacement's claim is compared with the one it
+// held before: the same import is no change, a differently stated one is.
+func TestTakeChangesComparesAReplacedClaimBesideTheOnesThatStayed(t *testing.T) {
+	idx := buildIndex(t, map[string]string{
+		"base.sysml": "package L { metadata def M; part def A; }",
+		"a.sysml":    "package P { public import L::*; }",
+		"b.sysml":    "package P { public import L::*; }",
+	})
+	idx.TrackChanges()
+	replace := func(src string) Changes {
+		addDoc(t, idx, "b.sysml", src)
+		idx.ExpandWildcardImports()
+		return idx.TakeChanges()
+	}
+	if ch := replace("package P { public import L::*; } // edited"); ch.Names["P::A"] {
+		t.Errorf("a re-export claimed again as it was is a change: %v", keys(ch.Names))
+	}
+	// Claimed privately beside a public claim, the name stays exported; the
+	// claims alone read differently.
+	if ch := replace("package P { private import L::*; }"); !ch.Names["P::A"] {
+		t.Errorf("a re-export claimed privately where it was public is not a change: %v", keys(ch.Names))
+	}
+	if ch := replace("package P { private import L::*; } // edited"); ch.Names["P::A"] {
+		t.Errorf("a re-export claimed privately again is a change: %v", keys(ch.Names))
+	}
+	// A second import widens the claim's routes after the first recorded them.
+	if ch := replace("package P { private import L::*; public import L::*; }"); !ch.Names["P::A"] {
+		t.Errorf("a re-export whose routes widened is not a change: %v", keys(ch.Names))
+	}
+	if ch := replace("package P { private import L::*; public import L::*; } // edited"); ch.Names["P::A"] {
+		t.Errorf("a re-export whose routes were recorded again as they were is a change: %v", keys(ch.Names))
+	}
+	// A filter's condition is the expression declaring it, so one parsed again
+	// is another condition and the route it gates another route.
+	if ch := replace("package P { private import L::*[@M]; }"); !ch.Names["P::A"] {
+		t.Errorf("a re-export gated where it was not is not a change: %v", keys(ch.Names))
+	}
+	if ch := replace("package P { private import L::*[@M]; } // edited"); !ch.Names["P::A"] {
+		t.Errorf("a re-export gated by a condition parsed again is not a change: %v", keys(ch.Names))
+	}
+}
+
+// What a registration noted before a write reads is what the index held then,
+// whatever the writes since did to the claims under the same key.
+func TestNotedRegistrationIsUnmovedByLaterClaims(t *testing.T) {
+	idx := buildIndex(t, map[string]string{
+		"base.sysml": "package L { part def A; }",
+		"a.sysml":    "package P { public import L::*; }",
+		"b.sysml":    "package P { private import L::*; }",
+	})
+	idx.TrackChanges()
+	before := registrationOf(idx, "P::A")
+	addDoc(t, idx, "b.sysml", "package P { private import L::*; public import L::*; }")
+	idx.ExpandWildcardImports()
+	if before.same(registrationOf(idx, "P::A")) {
+		t.Fatal("the registration noted before b.sysml widened its claim reads as the one after")
+	}
+	addDoc(t, idx, "b.sysml", "package P { private import L::*; }")
+	idx.ExpandWildcardImports()
+	if !before.same(registrationOf(idx, "P::A")) {
+		t.Fatal("b.sysml claiming as it first did does not read as the registration noted then")
+	}
+}
diff --git a/internal/semantic/symbols/index.go b/internal/semantic/symbols/index.go
index b855d9a4c7..0c3539dc41 100644
--- a/internal/semantic/symbols/index.go
+++ b/internal/semantic/symbols/index.go
@@ -81,6 +81,10 @@ type Index struct {
 	// This is deliberately not folded into contributions: that is an append-only
 	// slice per document, and a re-export has to be found by (FQN, symbol) to
 	// drop one document's claim, or purged across all documents at once.
+	//
+	// A claims map and the claims in it are never written once installed: a
+	// write installs a new map, so a registration noted before it (noteBefore)
+	// keeps reading what it read without copying.
 	reexportDocs *layer[reexportKey, map[string]*reexportClaim]
 	docReexports *layer[string, map[reexportKey]bool]
 
@@ -1221,14 +1225,10 @@ func filtersSubsume(a, b []ElementFilter) bool {
 // a name is a member of the importing namespace when any one of them admits it,
 // so an unfiltered import re-exports it whatever another route filters out.
 func (idx *Index) reexportGated(fqn string, sym *Symbol, doc string, private bool, gates [][]ElementFilter) {
-	claim := idx.reexport(fqn, sym, doc, private)
-	if claim == nil {
+	if !idx.reexport(fqn, sym) {
 		return // the namespace declares it; nothing was borrowed
 	}
-	widened := false
-	for _, gate := range gates {
-		widened = claim.record(gateRoute{private: private, filters: gate}) || widened
-	}
+	widened := idx.claimReexport(reexportKey{fqn: fqn, sym: sym}, doc, !private, gates)
 	if widened {
 		idx.changedName(fqn)
 	}
@@ -1244,14 +1244,15 @@ func (idx *Index) reexportGated(fqn string, sym *Symbol, doc string, private boo
 // beside it redundant, and re-expanding an importer records nothing new. Keeping
 // only the routes no other subsumes also bounds the set, which is what lets a
 // cycle of filtered imports settle. It reports whether the claim now admits more
-// than it did.
+// than it did. The routes are replaced, not written in place: a claim installed
+// in the index may share them (see claimReexport).
 func (c *reexportClaim) record(route gateRoute) bool {
 	for _, have := range c.routes {
 		if have.private == route.private && filtersSubsume(have.filters, route.filters) {
 			return false
 		}
 	}
-	kept := c.routes[:0]
+	kept := make([]gateRoute, 0, len(c.routes)+1)
 	for _, have := range c.routes {
 		if have.private != route.private || !filtersSubsume(route.filters, have.filters) {
 			kept = append(kept, have)
@@ -1333,58 +1334,80 @@ func nonZeroFilters(filters []ElementFilter) []ElementFilter {
 	return out
 }
 
-// reexport registers sym under fqn on doc's behalf and returns doc's writable
-// claim on it, or nil when the namespace declares sym there itself.
-func (idx *Index) reexport(fqn string, sym *Symbol, doc string, private bool) *reexportClaim {
+// reexport registers sym under fqn as a re-export and reports whether it is
+// one, which it is not when the namespace declares sym there itself.
+func (idx *Index) reexport(fqn string, sym *Symbol) bool {
 	if idx.hasFQN(fqn, sym) {
-		if !idx.reexported.at(fqn).has(sym) {
-			return nil // declared here, not borrowed
-		}
-	} else {
-		idx.link(fqn, sym) // claimReexport notes the gain
+		return idx.reexported.at(fqn).has(sym) // else declared here, not borrowed
 	}
-	return idx.claimReexport(reexportKey{fqn: fqn, sym: sym}, doc, !private)
+	idx.link(fqn, sym) // claimReexport notes the gain
+	return true
 }
 
 // claimReexport records that doc's wildcard import surfaces the re-export key,
-// publicly or not, and updates the marks a lookup reads. A name is exported when
-// any import that surfaced it was public, so a public claim clears the hidden
-// mark a private one left. It returns doc's writable claim.
-func (idx *Index) claimReexport(key reexportKey, doc string, public bool) *reexportClaim {
-	docs := idx.writableClaims(key)
-	claim, claimed := docs[doc]
-	if claimed && (claim.public || !public) {
-		return claim // nothing new
-	}
-	if !claimed {
-		claim = &reexportClaim{}
-		docs[doc] = claim
+// publicly or not and by the given routes, and updates the marks a lookup reads.
+// A name is exported when any import that surfaced it was public, so a public
+// claim clears the hidden mark a private one left. It reports whether the routes
+// now admit more than they did.
+//
+// The claims on key are replaced rather than written: the map and the claims in
+// it may be what a registration noted before this write reads (noteBefore).
+func (idx *Index) claimReexport(key reexportKey, doc string, public bool, gates [][]ElementFilter) bool {
+	idx.noteBefore(key.fqn)
+	docs := idx.reexportDocs.at(key)
+	have, claimed := docs[doc]
+	var claim reexportClaim
+	if claimed {
+		claim = *have
 	}
+	upgraded := !claimed || (public && !claim.public)
 	claim.public = claim.public || public
-	idx.changedName(key.fqn)
-	writableMap(idx.docReexports, doc)[key] = true
-	idx.applyReexportMarks(key, docs)
-	parent, _ := splitFQN(key.fqn)
-	idx.markGained(parent) // a public claim can un-hide it, which exports it onward
-	return claim
+	widened := false
+	for _, gate := range gates {
+		widened = claim.record(gateRoute{private: !public, filters: gate}) || widened
+	}
+	if !upgraded && !widened {
+		return false // nothing new
+	}
+	next := make(map[string]*reexportClaim, len(docs)+1)
+	for other, c := range docs {
+		next[other] = c
+	}
+	next[doc] = &claim
+	idx.reexportDocs.set(key, next)
+	if upgraded {
+		idx.changedName(key.fqn)
+		writableMap(idx.docReexports, doc)[key] = true
+		idx.applyReexportMarks(key, next)
+		parent, _ := splitFQN(key.fqn)
+		idx.markGained(parent) // a public claim can un-hide it, which exports it onward
+	}
+	return widened
 }
 
 // dropClaim forgets doc's claim on a re-export, deregistering the name once no
 // document surfaces it any more and re-hiding it when only private imports
-// remain.
+// remain. The surviving claims go into a new map (see claimReexport).
 func (idx *Index) dropClaim(key reexportKey, doc string) {
-	if _, claimed := idx.reexportDocs.at(key)[doc]; !claimed {
+	docs := idx.reexportDocs.at(key)
+	if _, claimed := docs[doc]; !claimed {
 		return
 	}
-	docs := idx.writableClaims(key)
-	delete(docs, doc) // the routes this document recorded go with its claim
+	idx.noteBefore(key.fqn)
 	idx.changedName(key.fqn)
-	if len(docs) == 0 {
+	if len(docs) == 1 {
 		idx.reexportDocs.del(key)
 		idx.deregister(key.fqn, key.sym)
 		return
 	}
-	idx.applyReexportMarks(key, docs)
+	kept := make(map[string]*reexportClaim, len(docs)-1)
+	for other, c := range docs {
+		if other != doc { // the routes this document recorded go with its claim
+			kept[other] = c
+		}
+	}
+	idx.reexportDocs.set(key, kept)
+	idx.applyReexportMarks(key, kept)
 	parent, _ := splitFQN(key.fqn)
 	idx.markLost(parent) // only private imports may remain, hiding it again
 }
@@ -1404,26 +1427,6 @@ func (idx *Index) purgeReexport(key reexportKey) {
 	idx.deregister(key.fqn, key.sym)
 }
 
-// writableClaims returns the claims on key that this index may write to. A claim
-// the frozen base recorded is copied with them: recording a route on it would
-// otherwise change what every index over that base re-exports.
-func (idx *Index) writableClaims(key reexportKey) map[string]*reexportClaim {
-	idx.noteBefore(key.fqn)
-	if docs, owned := idx.reexportDocs.own[key]; owned {
-		idx.reexportDocs.gen.bump()
-		return docs
-	}
-	shared, _ := idx.reexportDocs.below(key)
-	docs := make(map[string]*reexportClaim, len(shared)+1)
-	for doc, claim := range shared {
-		copied := *claim
-		copied.routes = append([]gateRoute(nil), claim.routes...)
-		docs[doc] = &copied
-	}
-	idx.reexportDocs.set(key, docs)
-	return docs
-}
-
 // applyReexportMarks brings the reexported and hidden marks in line with docs,
 // the claims on key: a claimed name is re-exported, and hidden while every
 // document that surfaced it did so with a private import (KerML 8.2.3.3).
diff --git a/internal/translate/export/behavior.go b/internal/translate/export/behavior.go
index a5828dbfb2..a36e4d8938 100644
--- a/internal/translate/export/behavior.go
+++ b/internal/translate/export/behavior.go
@@ -572,17 +572,25 @@ func (e *encoder) encodeGuardedTarget(n *ast.ControlFlowEdge, head func(rdf.Term
 
 // targetTransitionText writes a decision's branch, `if g then b;` or `else b;`.
 // That notation states no source, which the branch reads from the member
-// before it, and no effect or body; a branch the graph gives another source,
-// an effect or a body, or neither a guard nor `else`, which would read back as
-// a succession, is refused rather than written as a different branch.
-func (d *decoder) targetTransitionText(el *element, guard, target string) (string, string, error) {
+// before it, and no trigger, effect or body; a branch the graph gives another
+// source, a trigger, an effect or a body, or neither a guard nor `else`, which
+// would read back as a succession, is refused rather than written as a
+// different branch.
+func (d *decoder) targetTransitionText(el *element, triggerWords []string, guard, target string) (string, string, error) {
 	refuse := func(note string) error {
 		return &UnsupportedError{What: fmt.Sprintf("the transition <%s>", el.iri), Note: note}
 	}
-	if stated := d.graph.Objects(rdf.IRI(el.iri), rdf.SysML+pSource); len(stated) > 0 {
-		before := d.precedingSource(el)
-		if before == nil || stated[0].Value != before.iri {
-			return "", "", refuse(fmt.Sprintf("its sysml:source <%s> is not the member before it, which `if … then` and `else` take their source from", stated[0].Value))
+	if len(triggerWords) > 0 {
+		return "", "", refuse("it states a trigger, which a decision's branch has no notation for")
+	}
+	// Every source the graph states, in either spelling, must be the member
+	// before it: a second one has nowhere to go in the branch's notation.
+	before := d.precedingSource(el)
+	for _, property := range []string{pSource, pSourceFeature} {
+		for _, stated := range d.graph.Objects(rdf.IRI(el.iri), rdf.SysML+property) {
+			if before == nil || stated != rdf.IRI(before.iri) {
+				return "", "", refuse(fmt.Sprintf("its source %s is not the member before it, which `if … then` and `else` take their source from", termText(stated)))
+			}
 		}
 	}
 	effect, body, hasEffect, hasBody, err := d.transitionMembers(el)
@@ -2031,7 +2039,7 @@ func (d *decoder) transitionText(el *element, annotations []string, depth int) (
 		return "", "", err
 	}
 	if syntax == targetTransitionSyntax {
-		return d.targetTransitionText(el, guard, target)
+		return d.targetTransitionText(el, triggerWords, guard, target)
 	}
 	if guard != "" {
 		words = append(words, "if", guard)
diff --git a/internal/translate/interop/flexo/apply_measure.go b/internal/translate/interop/flexo/apply_measure.go
index bb0e7fc60b..cf01ec1fc7 100644
--- a/internal/translate/interop/flexo/apply_measure.go
+++ b/internal/translate/interop/flexo/apply_measure.go
@@ -210,7 +210,7 @@ func (run *applyRun) round(ctx context.Context, name string, local *rdf.Graph, g
 		round.Changes = append(round.Changes, fmt.Sprintf("%s\t%s\t%s", change.Kind, change.ID, orNone(change.Metaclass)))
 	}
 
-	before, err := run.client.Commits(ctx, run.repo.project)
+	before, err := run.client.Commits(ctx, run.repo.Project())
 	if err != nil {
 		return nil, fmt.Errorf("list commits: %w", err)
 	}
@@ -265,7 +265,7 @@ func (run *applyRun) round(ctx context.Context, name string, local *rdf.Graph, g
 
 // commitCount lists the project's commits; want >= 0 asserts the count held.
 func (run *applyRun) commitCount(ctx context.Context, want int) (int, error) {
-	commits, err := run.client.Commits(ctx, run.repo.project)
+	commits, err := run.client.Commits(ctx, run.repo.Project())
 	if err != nil {
 		return 0, fmt.Errorf("list commits: %w", err)
 	}
@@ -280,7 +280,7 @@ func (run *applyRun) commitCount(ctx context.Context, want int) (int, error) {
 func (run *applyRun) readBack(ctx context.Context, round *ApplyRound, result *reposync.Result) error {
 	commit := run.state.LastSeenCommit
 	for _, change := range result.Applied {
-		element, err := run.client.ElementByID(ctx, run.repo.project, commit, change.ID)
+		element, err := run.client.ElementByID(ctx, run.repo.Project(), commit, change.ID)
 		switch {
 		case change.Kind == reposync.KindDelete && Status(err) == http.StatusNotFound:
 			round.Absent++
diff --git a/internal/translate/interop/flexo/client.go b/internal/translate/interop/flexo/client.go
index 2623ef1e8d..3331ea576b 100644
--- a/internal/translate/interop/flexo/client.go
+++ b/internal/translate/interop/flexo/client.go
@@ -5,47 +5,46 @@
 // `-sync-apply` sync element-wise, `sysml -convert` reads a branch URL as
 // notation or pushes a whole Turtle graph to it.
 //
+// The standard API — projects, branches, commits, elements — is package
+// sysmlapi's; this package adds what only Flexo has: the Layer 1 org a project
+// lives under, its Turtle graph store, and the SPARQL read of a commit's graph.
+//
 // The stack is external and opt-in; see .agents/skills/flexo-interop for how to
 // bring it up and what the gate reports.
 package flexo
 
 import (
-	"bytes"
 	"context"
 	"encoding/json"
 	"errors"
 	"fmt"
-	"io"
-	"net"
 	"net/http"
 	"net/url"
 	"os"
-	"strconv"
 	"strings"
 	"time"
 
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/sysmlapi"
 	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
 )
 
-const projectsPath = "/projects/"
-
 // Environment variables read by ConfigFromEnv. FLEXO_INTEROP is the gate: the
 // live test skips unless it is set, exactly as the corpus gates skip on an
 // absent corpus.
 const (
 	EnvGate       = "FLEXO_INTEROP"
 	EnvLayer1URL  = "FLEXO_LAYER1_URL"
-	EnvSysMLV2URL = "FLEXO_SYSMLV2_URL"
-	EnvToken      = "FLEXO_INTEROP_TOKEN" // #nosec G101 -- a variable name, not a credential
+	EnvSysMLV2URL = sysmlapi.EnvBaseURL
+	EnvToken      = sysmlapi.EnvToken
 	EnvOrg        = "FLEXO_SYSMLV2_ORG"
-	EnvPlainHTTP  = "FLEXO_ALLOW_PLAIN_HTTP"
+	EnvPlainHTTP  = sysmlapi.EnvPlainHTTP
 )
 
 // Defaults matching flexo-mms-sysmlv2/docker-compose/docker-compose.yml, so a
 // stack brought up from that file needs no configuration beyond the token.
 const (
 	DefaultLayer1URL  = "http://localhost:8080"
-	DefaultSysMLV2URL = "http://localhost:8083"
+	DefaultSysMLV2URL = sysmlapi.DefaultBaseURL
 	DefaultOrg        = "sysmlv2"
 )
 
@@ -80,13 +79,7 @@ func ConfigFromEnv() (Config, error) {
 
 // PlaintextError is a bearer token about to cross the network unencrypted: an
 // http:// URL whose host is not this machine.
-type PlaintextError struct {
-	URL string
-}
-
-func (e *PlaintextError) Error() string {
-	return fmt.Sprintf("%s would send the bearer token in the clear; use https://, or set %s=1 for a stack you trust the network to", e.URL, EnvPlainHTTP)
-}
+type PlaintextError = sysmlapi.PlaintextError
 
 // CheckTransport refuses a token over plaintext to anything but a loopback
 // host, unless the environment opts in with FLEXO_ALLOW_PLAIN_HTTP=1.
@@ -99,22 +92,13 @@ func (cfg Config) CheckTransport() error {
 		if err != nil {
 			return fmt.Errorf("stack url %q: %w", raw, err)
 		}
-		if u.Scheme == "http" && !loopback(u.Hostname()) {
+		if u.Scheme == "http" && !sysmlapi.Loopback(u.Hostname()) {
 			return &PlaintextError{URL: raw}
 		}
 	}
 	return nil
 }
 
-// loopback reports a host name that resolves to this machine without a lookup.
-func loopback(host string) bool {
-	if host == "localhost" || strings.HasSuffix(host, ".localhost") {
-		return true
-	}
-	ip := net.ParseIP(host)
-	return ip != nil && ip.IsLoopback()
-}
-
 func envOr(name, fallback string) string {
 	if value := os.Getenv(name); value != "" {
 		return value
@@ -122,89 +106,38 @@ func envOr(name, fallback string) string {
 	return fallback
 }
 
-// Client talks to one stack. It is safe for sequential use by one test.
+// Client talks to one stack: the standard API through a sysmlapi client, Layer
+// 1 directly. It is safe for sequential use by one test.
 type Client struct {
-	cfg  Config
-	http *http.Client
+	cfg Config
+	api *sysmlapi.Client
 }
 
 // New returns a client for cfg.
 func New(cfg Config) *Client {
-	timeout := cfg.Timeout
-	if timeout <= 0 {
-		timeout = 60 * time.Second
-	}
-	return &Client{cfg: cfg, http: &http.Client{Timeout: timeout}}
+	api := sysmlapi.New(sysmlapi.Config{BaseURL: cfg.SysMLV2URL, Token: cfg.Token, Timeout: cfg.Timeout})
+	return &Client{cfg: cfg, api: api}
 }
 
 // Config returns the configuration the client was built with.
 func (c *Client) Config() Config { return c.cfg }
 
-// statusError is a response the harness did not ask for. It carries the body,
-// because both services answer with a diagnostic there.
-type statusError struct {
-	method string
-	url    string
-	status int
-	body   string
-}
-
-func (e *statusError) Error() string {
-	body := strings.TrimSpace(e.body)
-	if len(body) > 400 {
-		body = body[:400] + "..."
-	}
-	return fmt.Sprintf("%s %s: %s: %s", e.method, e.url, http.StatusText(e.status), body)
-}
+// API is the standard SysML v2 API client the stack is driven through.
+func (c *Client) API() *sysmlapi.Client { return c.api }
 
 // Status returns the HTTP status of a failed request, or 0 if err is not one.
-func Status(err error) int {
-	var se *statusError
-	if errors.As(err, &se) {
-		return se.status
-	}
-	return 0
-}
-
-// do performs one authorized request and returns the response body, failing on
-// any status outside 2xx.
-func (c *Client) do(ctx context.Context, method, url string, body []byte, contentType string, headers map[string]string) ([]byte, http.Header, error) {
-	var reader io.Reader
-	if body != nil {
-		reader = bytes.NewReader(body)
-	}
-	req, err := http.NewRequestWithContext(ctx, method, url, reader)
-	if err != nil {
-		return nil, nil, err
-	}
-	req.Header.Set("Authorization", "Bearer "+c.cfg.Token)
-	if contentType != "" {
-		req.Header.Set("Content-Type", contentType)
-	}
-	for name, value := range headers {
-		req.Header.Set(name, value)
-	}
+func Status(err error) int { return sysmlapi.Status(err) }
 
-	resp, err := c.http.Do(req)
-	if err != nil {
-		return nil, nil, err
-	}
-	defer func() { _ = resp.Body.Close() }()
-
-	content, err := io.ReadAll(resp.Body)
-	if err != nil {
-		return nil, resp.Header, err
-	}
-	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
-		return content, resp.Header, &statusError{method: method, url: url, status: resp.StatusCode, body: string(content)}
-	}
-	return content, resp.Header, nil
+// do performs one authorized request against either service and returns the
+// response body, failing on any status outside 2xx.
+func (c *Client) do(ctx context.Context, method, target string, body []byte, contentType string, headers map[string]string) ([]byte, http.Header, error) {
+	return c.api.Do(ctx, method, target, body, contentType, headers)
 }
 
 // Reachable reports whether both services answer. The SysML v2 project list is
 // the cheapest authorized read on the stack.
 func (c *Client) Reachable(ctx context.Context) error {
-	if _, _, err := c.do(ctx, http.MethodGet, c.cfg.SysMLV2URL+"/projects", nil, "", nil); err != nil {
+	if err := c.api.Reachable(ctx); err != nil {
 		return fmt.Errorf("sysmlv2 at %s: %w", c.cfg.SysMLV2URL, err)
 	}
 	// The org list, not the org itself: a fresh cluster has no org yet.
@@ -232,10 +165,7 @@ func (c *Client) EnsureOrg(ctx context.Context) error {
 }
 
 // Project is the part of a created project the harness uses.
-type Project struct {
-	ID   string
-	Name string
-}
+type Project = sysmlapi.Project
 
 // CreateProject creates a project through the SysML v2 API, which also creates
 // its default branch and the queries scratch. The id doubles as the Layer 1 repo
@@ -243,31 +173,7 @@ type Project struct {
 // rather than left to the service, which would otherwise mint a uuid the graph
 // endpoint's path needs.
 func (c *Client) CreateProject(ctx context.Context, id, name, branch string) (Project, error) {
-	request := map[string]any{
-		"@type":         "Project",
-		"@id":           id,
-		"name":          name,
-		"defaultBranch": map[string]any{"@id": branch},
-	}
-	body, err := json.Marshal(request)
-	if err != nil {
-		return Project{}, err
-	}
-	content, _, err := c.do(ctx, http.MethodPost, c.cfg.SysMLV2URL+"/projects", body, "application/json", nil)
-	if err != nil {
-		return Project{}, err
-	}
-	var created struct {
-		ID   string `json:"@id"`
-		Name string `json:"name"`
-	}
-	if err := json.Unmarshal(content, &created); err != nil {
-		return Project{}, fmt.Errorf("decode created project: %w", err)
-	}
-	if created.ID == "" {
-		created.ID = id
-	}
-	return Project{ID: created.ID, Name: created.Name}, nil
+	return c.api.CreateProject(ctx, id, name, branch)
 }
 
 // branchGraphURL is the Graph Store Protocol endpoint of one branch's model.
@@ -329,46 +235,19 @@ func (c *Client) BranchETag(ctx context.Context, project, branch string) (string
 // PostChanges commits SysML v2 JSON changes through the service's own commit
 // path and returns the commit it made. An empty branch takes the default one.
 func (c *Client) PostChanges(ctx context.Context, project, branch string, changes []byte) (Commit, error) {
-	target := c.cfg.SysMLV2URL + projectsPath + url.PathEscape(project) + "/commits"
-	if branch != "" {
-		target += "?branchId=" + url.QueryEscape(branch)
-	}
-	content, _, err := c.do(ctx, http.MethodPost, target, changes, "application/json", nil)
-	if err != nil {
-		return Commit{}, err
-	}
-	var commit Commit
-	if err := json.Unmarshal(content, &commit); err != nil {
-		return Commit{}, fmt.Errorf("decode commit: %w", err)
-	}
-	return commit, nil
+	return c.api.PostChanges(ctx, project, branch, changes)
 }
 
 // Commit identifies one commit of a project.
-type Commit struct {
-	ID   string `json:"@id"`
-	Type string `json:"@type"`
-}
+type Commit = sysmlapi.Commit
 
 // Branch is one branch as the SysML v2 API describes it: its id and the
 // commit at its head.
-type Branch struct {
-	ID   string `json:"@id"`
-	Head Commit `json:"head"`
-}
+type Branch = sysmlapi.Branch
 
 // Branch reads one branch of a project, head commit included.
 func (c *Client) Branch(ctx context.Context, project, branch string) (Branch, error) {
-	content, _, err := c.do(ctx, http.MethodGet,
-		c.cfg.SysMLV2URL+projectsPath+url.PathEscape(project)+"/branches/"+url.PathEscape(branch), nil, "", nil)
-	if err != nil {
-		return Branch{}, err
-	}
-	var read Branch
-	if err := json.Unmarshal(content, &read); err != nil {
-		return Branch{}, fmt.Errorf("decode branch: %w", err)
-	}
-	return read, nil
+	return c.api.Branch(ctx, project, branch)
 }
 
 // ErrBlankNode is a blank node in a graph read back from the stack; elements
@@ -455,133 +334,39 @@ func (c *Client) selectGraph(ctx context.Context, target string) (*rdf.Graph, er
 
 // Commits lists a project's commits, newest first as the service returns them.
 func (c *Client) Commits(ctx context.Context, project string) ([]Commit, error) {
-	content, _, err := c.do(ctx, http.MethodGet,
-		c.cfg.SysMLV2URL+projectsPath+url.PathEscape(project)+"/commits", nil, "", nil)
-	if err != nil {
-		return nil, err
-	}
-	var commits []Commit
-	if err := json.Unmarshal(content, &commits); err != nil {
-		return nil, fmt.Errorf("decode commits: %w", err)
-	}
-	return commits, nil
-}
-
-// Element is one element as the SysML v2 API delivers it: property name to raw
-// JSON value, kept raw so a value's shape — reference, literal, array — is
-// observable rather than normalized away by decoding into a Go type.
-type Element map[string]json.RawMessage
-
-// ID returns an element's identity, preferring @id over elementId.
-func (e Element) ID() string {
-	for _, key := range []string{"@id", "elementId"} {
-		if raw, ok := e[key]; ok {
-			var id string
-			if json.Unmarshal(raw, &id) == nil && id != "" {
-				return id
-			}
-		}
-	}
-	return ""
-}
-
-// Type returns an element's @type, or "" when it carries none.
-func (e Element) Type() string {
-	var name string
-	if raw, ok := e["@type"]; ok && json.Unmarshal(raw, &name) == nil {
-		return name
-	}
-	return ""
+	return c.api.Commits(ctx, project)
 }
 
-func (c *Client) commitPath(project, commit string) string {
-	return fmt.Sprintf("%s/projects/%s/commits/%s",
-		c.cfg.SysMLV2URL, url.PathEscape(project), url.PathEscape(commit))
-}
+// Element is one element as the SysML v2 API delivers it.
+type Element = sysmlapi.Element
 
 // Listing is one element listing: the elements it delivered, the number of
 // responses it took, and whether the service ignored the paging parameters.
-type Listing struct {
-	Elements      []Element
-	Responses     int
-	IgnoredPaging bool
-}
+type Listing = sysmlapi.Listing
 
-// Elements reads a commit's elements a page at a time. A page that overruns
-// pageSize or repeats an element is a service ignoring paging; the repeat is
-// dropped rather than counted twice.
+// Elements reads a commit's elements a page at a time.
 func (c *Client) Elements(ctx context.Context, project, commit string, pageSize int) (Listing, error) {
-	var listing Listing
-	seen := make(map[string]bool)
-	after := ""
-	for {
-		target := c.commitPath(project, commit) + "/elements?pageSize=" + strconv.Itoa(pageSize)
-		if after != "" {
-			target += "&pageAfter=" + url.QueryEscape(after)
-		}
-		content, _, err := c.do(ctx, http.MethodGet, target, nil, "", nil)
-		if err != nil {
-			return listing, err
-		}
-		var page []Element
-		if err := json.Unmarshal(content, &page); err != nil {
-			return listing, fmt.Errorf("decode elements page %d: %w", listing.Responses+1, err)
-		}
-		listing.Responses++
-
-		fresh := 0
-		for _, element := range page {
-			if id := element.ID(); id != "" {
-				if seen[id] {
-					continue
-				}
-				seen[id] = true
-			}
-			listing.Elements = append(listing.Elements, element)
-			fresh++
-		}
-
-		switch {
-		case len(page) > pageSize, fresh < len(page):
-			listing.IgnoredPaging = true
-			return listing, nil
-		case len(page) < pageSize:
-			return listing, nil
-		}
-		last := page[len(page)-1].ID()
-		if last == "" || last == after || listing.Responses > 1000 {
-			return listing, nil
-		}
-		after = last
-	}
+	return c.api.Elements(ctx, project, commit, pageSize)
 }
 
 // ElementByID reads one element directly. A non-2xx answer is returned as the
 // error, with Status(err) carrying the code: a rejected id is a finding, not a
 // harness failure.
 func (c *Client) ElementByID(ctx context.Context, project, commit, id string) (Element, error) {
-	content, _, err := c.do(ctx, http.MethodGet,
-		c.commitPath(project, commit)+"/elements/"+url.PathEscape(id), nil, "", nil)
-	if err != nil {
-		return nil, err
-	}
-	var element Element
-	if err := json.Unmarshal(content, &element); err != nil {
-		return nil, fmt.Errorf("decode element %s: %w", id, err)
-	}
-	return element, nil
+	return c.api.ElementByID(ctx, project, commit, id)
 }
 
 // Roots lists the elements the service considers roots of a commit: those with
 // neither an owner nor an owning related element.
 func (c *Client) Roots(ctx context.Context, project, commit string) ([]Element, error) {
-	content, _, err := c.do(ctx, http.MethodGet, c.commitPath(project, commit)+"/roots", nil, "", nil)
-	if err != nil {
-		return nil, err
-	}
-	var roots []Element
-	if err := json.Unmarshal(content, &roots); err != nil {
-		return nil, fmt.Errorf("decode roots: %w", err)
-	}
-	return roots, nil
+	return c.api.Roots(ctx, project, commit)
 }
+
+// Representation is what the service stores of a posted graph: sysml:
+// properties only, values as JSON spells them. A diff under it converges with
+// an apply.
+type Representation = sysmlapi.Representation
+
+// UnrepresentableError is a value the service's JSON commit path has no
+// spelling for; the diff refuses it rather than approximating.
+type UnrepresentableError = sysmlapi.UnrepresentableError
diff --git a/internal/translate/interop/flexo/measure.go b/internal/translate/interop/flexo/measure.go
index 50f2e8648c..8e6600b916 100644
--- a/internal/translate/interop/flexo/measure.go
+++ b/internal/translate/interop/flexo/measure.go
@@ -15,6 +15,7 @@ import (
 
 	"github.com/Open-MBEE/OpenSysML/internal/translate/convert"
 	"github.com/Open-MBEE/OpenSysML/internal/translate/export"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/sysmlapi"
 	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
 )
 
@@ -466,11 +467,11 @@ func deliveredKind(raw json.RawMessage) string {
 // refusalReason is the refused write's diagnostic, kept to one stable line:
 // no request shape, no fresh project id, no line breaks.
 func refusalReason(err error, projectID string) string {
-	var se *statusError
+	var se *sysmlapi.StatusError
 	if !errors.As(err, &se) {
 		return "the write failed"
 	}
-	reason := strings.Join(strings.Fields(se.body), " ")
+	reason := strings.Join(strings.Fields(se.Body), " ")
 	reason = strings.ReplaceAll(reason, projectID, "<project>")
 	if len(reason) > 200 {
 		reason = reason[:200]
diff --git a/internal/translate/interop/flexo/repository.go b/internal/translate/interop/flexo/repository.go
index 4cc236e500..9ac8a84b27 100644
--- a/internal/translate/interop/flexo/repository.go
+++ b/internal/translate/interop/flexo/repository.go
@@ -2,44 +2,33 @@ package flexo
 
 import (
 	"context"
-	"encoding/json"
-	"errors"
 	"fmt"
 	"net/http"
 	"net/url"
 	"strings"
 
-	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/sysmlapi"
 	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
 )
 
-// Repository is one project branch as a sync's repository: read as a graph,
-// written through the service's commit path so every element keeps its id.
-// It remembers the head its last read stood at and refuses to commit past a
-// head that has since moved.
+// Repository is one project branch as a sync's repository: read as a graph
+// through Layer 1, written through the service's commit path so every element
+// keeps its id, or replaced whole by a Turtle push. It remembers the head its
+// last read stood at and refuses to commit past a head that has since moved.
 type Repository struct {
-	client  *Client
-	project string
-	branch  string
-	seen    string
+	*sysmlapi.Repository
+	client *Client
 }
 
 // Repository addresses one project branch for a sync.
 func (c *Client) Repository(project, branch string) *Repository {
-	return &Repository{client: c, project: project, branch: branch}
+	return &Repository{Repository: c.api.Repository(project, branch), client: c}
 }
 
 // StaleBranchError is a branch whose head moved between the read a change set
 // was computed against and the commit that would have written it; nothing was
 // written, and the change set has to be recomputed against the new head.
-type StaleBranchError struct {
-	Project, Branch, Seen, Head string
-}
-
-func (e *StaleBranchError) Error() string {
-	return fmt.Sprintf("branch %s of %s moved from commit %s to %s since the change set was computed; nothing was written, so diff again against the new head",
-		e.Branch, e.Project, e.Seen, e.Head)
-}
+type StaleBranchError = sysmlapi.StaleBranchError
 
 // UnrecordedPushError is a graph write the branch accepted but whose response
 // named no commit; a later head read could be another writer's, so none is recorded.
@@ -63,26 +52,19 @@ func (e *SupersededPushError) Error() string {
 		e.Project, e.Branch, e.Commit, e.Head)
 }
 
-// Head is the branch's current head commit.
+// Head is the branch's current head commit; a branch naming none is an error,
+// as every Flexo branch stands at a commit.
 func (r *Repository) Head(ctx context.Context) (string, error) {
-	branch, err := r.client.Branch(ctx, r.project, r.branch)
+	head, err := r.Repository.Head(ctx)
 	if err != nil {
 		return "", err
 	}
-	if branch.Head.ID == "" {
-		return "", fmt.Errorf("branch %s of %s names no head commit", r.branch, r.project)
+	if head == "" {
+		return "", fmt.Errorf("branch %s of %s names no head commit", r.Branch(), r.Project())
 	}
-	return branch.Head.ID, nil
+	return head, nil
 }
 
-// Seen is the head commit the last Graph read stood at, or the last commit
-// this repository wrote; empty before either.
-func (r *Repository) Seen() string { return r.seen }
-
-// Resume records the last-seen commit a saved sync state carries, so a head
-// that has since moved is refused instead of written past.
-func (r *Repository) Resume(commit string) { r.seen = commit }
-
 // Graph reads the branch as its head commit left it, so the read is of one
 // commit rather than of a branch that may move under it.
 func (r *Repository) Graph(ctx context.Context) (*rdf.Graph, error) {
@@ -90,26 +72,28 @@ func (r *Repository) Graph(ctx context.Context) (*rdf.Graph, error) {
 	if err != nil {
 		return nil, err
 	}
-	graph, err := r.client.CommitGraph(ctx, r.project, head)
+	graph, err := r.client.CommitGraph(ctx, r.Project(), head)
 	if err != nil {
 		return nil, err
 	}
-	r.seen = head
+	r.Resume(head)
 	return graph, nil
 }
 
-// GraphAt reads the branch as one earlier commit left it: the last-seen graph
-// a diff needs to tell a repository change from its own.
+// GraphAt reads the branch as one earlier commit left it, through Layer 1's
+// SPARQL endpoint: the last-seen graph a diff needs to tell a repository
+// change from its own.
 func (r *Repository) GraphAt(ctx context.Context, commit string) (*rdf.Graph, error) {
-	return r.client.CommitGraph(ctx, r.project, commit)
+	return r.client.CommitGraph(ctx, r.Project(), commit)
 }
 
 // Push replaces the branch's whole model graph with the given Turtle and
 // returns the commit made; a head that moved past what was seen is refused.
 func (r *Repository) Push(ctx context.Context, turtle []byte, message string) (string, error) {
+	project, branch := r.Project(), r.Branch()
 	// The etag is read first: a head read after it can only race into a 412,
 	// never into a write past a moved head.
-	etag, err := r.client.BranchETag(ctx, r.project, r.branch)
+	etag, err := r.client.BranchETag(ctx, project, branch)
 	if err != nil {
 		return "", err
 	}
@@ -117,10 +101,10 @@ func (r *Repository) Push(ctx context.Context, turtle []byte, message string) (s
 	if err != nil {
 		return "", err
 	}
-	if r.seen != "" && head != r.seen {
-		return "", &StaleBranchError{Project: r.project, Branch: r.branch, Seen: r.seen, Head: head}
+	if seen := r.Seen(); seen != "" && head != seen {
+		return "", &StaleBranchError{Project: project, Branch: branch, Seen: seen, Head: head}
 	}
-	res, err := r.client.PutGraph(ctx, r.project, r.branch, turtle, message, etag)
+	res, err := r.client.PutGraph(ctx, project, branch, turtle, message, etag)
 	if err != nil {
 		if Status(err) == http.StatusPreconditionFailed {
 			current, readErr := r.Head(ctx)
@@ -131,22 +115,22 @@ func (r *Repository) Push(ctx context.Context, turtle []byte, message string) (s
 			// and only a head still at it counts it as ours.
 			if c := committedFrom(res); c != "" {
 				if c == current {
-					r.seen = c
+					r.Resume(c)
 					return c, nil
 				}
-				return "", &SupersededPushError{Project: r.project, Branch: r.branch, Commit: c, Head: current}
+				return "", &SupersededPushError{Project: project, Branch: branch, Commit: c, Head: current}
 			}
-			return "", &StaleBranchError{Project: r.project, Branch: r.branch, Seen: head, Head: current}
+			return "", &StaleBranchError{Project: project, Branch: branch, Seen: head, Head: current}
 		}
 		return "", err
 	}
 	// Trust the commit the write itself reported; the head may have moved on.
 	if res.Commit != "" {
-		r.seen = res.Commit
+		r.Resume(res.Commit)
 		return res.Commit, nil
 	}
-	r.seen = ""
-	return "", &UnrecordedPushError{Project: r.project, Branch: r.branch}
+	r.Resume("")
+	return "", &UnrecordedPushError{Project: project, Branch: branch}
 }
 
 // committedFrom trusts an ETag only when the response's Location names the
@@ -165,132 +149,3 @@ func committedFrom(res PutResult) string {
 	}
 	return ""
 }
-
-// Commit writes one batch as one SysML v2 commit. Creates and updates send
-// the element whole under its identity; deletes send a null payload. The API
-// takes no precondition, so the head is re-read first and a moved one refuses
-// the write as a StaleBranchError.
-func (r *Repository) Commit(ctx context.Context, changes []reposync.ElementChange, message string) (string, error) {
-	body, err := commitRequest(changes, message)
-	if err != nil {
-		return "", err
-	}
-	if r.seen != "" {
-		head, err := r.Head(ctx)
-		if err != nil {
-			return "", err
-		}
-		if head != r.seen {
-			return "", &StaleBranchError{Project: r.project, Branch: r.branch, Seen: r.seen, Head: head}
-		}
-	}
-	commit, err := r.client.PostChanges(ctx, r.project, r.branch, body)
-	if err != nil {
-		return "", err
-	}
-	r.seen = commit.ID
-	return commit.ID, nil
-}
-
-// commitRequest encodes a batch as the service's CommitRequest.
-func commitRequest(changes []reposync.ElementChange, message string) ([]byte, error) {
-	versions := make([]map[string]any, 0, len(changes))
-	for _, change := range changes {
-		version := map[string]any{
-			"@type":    "DataVersion",
-			"identity": map[string]string{"@id": change.ID},
-			"payload":  nil,
-		}
-		switch change.Kind {
-		case reposync.KindDelete:
-		case reposync.KindCreate, reposync.KindUpdate:
-			content, err := payload(change)
-			if err != nil {
-				return nil, fmt.Errorf("%s %s: %w", change.Kind, change.ID, err)
-			}
-			version["payload"] = content
-		default:
-			return nil, fmt.Errorf("%s %s: the service has no commit for a %s", change.Kind, change.ID, change.Kind)
-		}
-		versions = append(versions, version)
-	}
-	request := map[string]any{"@type": "Commit", "change": versions}
-	if message != "" {
-		request["description"] = message
-	}
-	return json.Marshal(request)
-}
-
-// ErrUntyped is an element with no single sysml: metaclass, which the
-// service's payload cannot state.
-var ErrUntyped = errors.New("the element has no single SysML metaclass")
-
-// payload renders an element's content as the service's JSON: @id and @type,
-// then each sysml: property as a value or, when multi-valued, an array.
-func payload(change reposync.ElementChange) (map[string]json.RawMessage, error) {
-	out := map[string]json.RawMessage{}
-	values := map[string][]json.RawMessage{}
-	metaclass := ""
-	for _, triple := range change.Content {
-		predicate := triple.Predicate.Value
-		if predicate == rdf.RDFType {
-			name, ok := strings.CutPrefix(triple.Object.Value, rdf.SysML)
-			if !ok || !triple.Object.IsIRI() || metaclass != "" {
-				return nil, ErrUntyped
-			}
-			metaclass = name
-			continue
-		}
-		name, ok := strings.CutPrefix(predicate, rdf.SysML)
-		if !ok {
-			return nil, &UnrepresentableError{Term: triple.Predicate, Reason: "the service stores sysml: properties only"}
-		}
-		value, err := jsonValue(triple.Object)
-		if err != nil {
-			return nil, err
-		}
-		values[name] = append(values[name], value)
-	}
-	if metaclass == "" {
-		return nil, ErrUntyped
-	}
-	for name, list := range values {
-		if len(list) == 1 {
-			out[name] = list[0]
-			continue
-		}
-		array, err := json.Marshal(list)
-		if err != nil {
-			return nil, err
-		}
-		out[name] = array
-	}
-	id, err := json.Marshal(change.ID)
-	if err != nil {
-		return nil, err
-	}
-	out["@id"] = id
-	if out["@type"], err = json.Marshal(metaclass); err != nil {
-		return nil, err
-	}
-	return out, nil
-}
-
-// jsonValue spells one carried term as the service reads it back from JSON.
-func jsonValue(term rdf.Term) (json.RawMessage, error) {
-	carried, err := carryTerm(term)
-	if err != nil {
-		return nil, err
-	}
-	if carried.IsIRI() {
-		if carried.Value == rdfNil {
-			return json.RawMessage("null"), nil
-		}
-		return json.Marshal(map[string]string{"@id": rdf.LocalName(carried.Value)})
-	}
-	switch carried.Datatype {
-	case rdf.XSD + "boolean", rdf.XSD + "integer", rdf.XSD + "decimal":
-		return json.RawMessage(carried.Value), nil
-	}
-	return json.Marshal(carried.Value)
-}
diff --git a/internal/translate/interop/flexo/repository_test.go b/internal/translate/interop/flexo/repository_test.go
index 0b95d1b2ae..8a3ec67f4d 100644
--- a/internal/translate/interop/flexo/repository_test.go
+++ b/internal/translate/interop/flexo/repository_test.go
@@ -2,13 +2,11 @@ package flexo
 
 import (
 	"context"
-	"encoding/json"
 	"errors"
 	"fmt"
 	"io"
 	"net/http"
 	"net/http/httptest"
-	"reflect"
 	"strings"
 	"testing"
 
@@ -16,141 +14,6 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
 )
 
-func triple(subject, predicate string, object rdf.Term) rdf.Triple {
-	return rdf.Triple{Subject: rdf.IRI(subject), Predicate: rdf.IRI(predicate), Object: object}
-}
-
-func TestCommitRequestSpellsEveryChangeKind(t *testing.T) {
-	x := rdf.Element + "X1"
-	changes := []reposync.ElementChange{
-		{Kind: reposync.KindUpdate, ID: "X1", Content: []rdf.Triple{
-			triple(x, rdf.RDFType, rdf.IRI(rdf.SysML+"PartDefinition")),
-			triple(x, rdf.SysML+"declaredName", rdf.String("renamed")),
-			triple(x, rdf.SysML+"isAbstract", rdf.TypedLiteral("true", rdf.XSD+"boolean")),
-			triple(x, rdf.SysML+"ownedMember", rdf.IRI(rdf.Element+"Y1")),
-			triple(x, rdf.SysML+"ownedMember", rdf.IRI(rdf.Expression+"Y2")),
-			triple(x, rdf.SysML+"count", rdf.TypedLiteral("3", rdf.XSD+"integer")),
-			triple(x, rdf.SysML+"mass", rdf.TypedLiteral("1.5", rdf.XSD+"decimal")),
-			triple(x, rdf.SysML+"owner", rdf.IRI(rdf.RDFNS+"nil")),
-		}},
-		{Kind: reposync.KindCreate, ID: "N1", Content: []rdf.Triple{
-			triple(rdf.Element+"N1", rdf.RDFType, rdf.IRI(rdf.SysML+"Package")),
-		}},
-		{Kind: reposync.KindDelete, ID: "D1"},
-	}
-	body, err := commitRequest(changes, "sync")
-	if err != nil {
-		t.Fatal(err)
-	}
-	var got map[string]any
-	if err := json.Unmarshal(body, &got); err != nil {
-		t.Fatal(err)
-	}
-	want := map[string]any{
-		"@type":       "Commit",
-		"description": "sync",
-		"change": []any{
-			map[string]any{
-				"@type":    "DataVersion",
-				"identity": map[string]any{"@id": "X1"},
-				"payload": map[string]any{
-					"@id":          "X1",
-					"@type":        "PartDefinition",
-					"declaredName": "renamed",
-					"isAbstract":   true,
-					"ownedMember":  []any{map[string]any{"@id": "Y1"}, map[string]any{"@id": "Y2"}},
-					"count":        float64(3),
-					"mass":         1.5,
-					"owner":        nil,
-				},
-			},
-			map[string]any{
-				"@type":    "DataVersion",
-				"identity": map[string]any{"@id": "N1"},
-				"payload":  map[string]any{"@id": "N1", "@type": "Package"},
-			},
-			map[string]any{
-				"@type":    "DataVersion",
-				"identity": map[string]any{"@id": "D1"},
-				"payload":  nil,
-			},
-		},
-	}
-	if !reflect.DeepEqual(got, want) {
-		t.Errorf("commit request:\n got %s\nwant %+v", body, want)
-	}
-}
-
-func TestCommitRequestRefusesWhatTheServiceCannotHold(t *testing.T) {
-	x := rdf.Element + "X1"
-	typed := triple(x, rdf.RDFType, rdf.IRI(rdf.SysML+"PartDefinition"))
-	cases := []struct {
-		name    string
-		content []rdf.Triple
-		want    error
-	}{
-		{"untyped", []rdf.Triple{triple(x, rdf.SysML+"declaredName", rdf.String("a"))}, ErrUntyped},
-		{"two types", []rdf.Triple{typed, triple(x, rdf.RDFType, rdf.IRI(rdf.SysML+"Package"))}, ErrUntyped},
-		{"foreign property", []rdf.Triple{typed, triple(x, "urn:opensysml:sysml:memberIndex", rdf.String("0"))}, &UnrepresentableError{}},
-		{"language tag", []rdf.Triple{typed, triple(x, rdf.SysML+"declaredName", rdf.Term{Kind: rdf.TermLiteral, Value: "a", Lang: "en"})}, &UnrepresentableError{}},
-		{"foreign IRI", []rdf.Triple{typed, triple(x, rdf.SysML+"owner", rdf.IRI("http://example.org/x"))}, &UnrepresentableError{}},
-		{"odd datatype", []rdf.Triple{typed, triple(x, rdf.SysML+"when", rdf.TypedLiteral("2020-01-01", rdf.XSD+"date"))}, &UnrepresentableError{}},
-		{"non-numeric integer", []rdf.Triple{typed, triple(x, rdf.SysML+"n", rdf.TypedLiteral("+07", rdf.XSD+"integer"))}, &UnrepresentableError{}},
-	}
-	for _, tc := range cases {
-		t.Run(tc.name, func(t *testing.T) {
-			_, err := commitRequest([]reposync.ElementChange{{Kind: reposync.KindCreate, ID: "X1", Content: tc.content}}, "")
-			if err == nil {
-				t.Fatal("accepted")
-			}
-			var unrepresentable *UnrepresentableError
-			switch tc.want.(type) {
-			case *UnrepresentableError:
-				if !errors.As(err, &unrepresentable) {
-					t.Errorf("want an UnrepresentableError, got %v", err)
-				}
-			default:
-				if !errors.Is(err, tc.want) {
-					t.Errorf("want %v, got %v", tc.want, err)
-				}
-			}
-		})
-	}
-}
-
-func TestRepresentationCarriesWhatTheServiceStores(t *testing.T) {
-	x := rdf.Element + "X1"
-	rep := Representation{}
-	dropped, ok, err := rep.Carry(triple(x, "urn:opensysml:sysml:memberIndex", rdf.String("0")))
-	if err != nil || ok {
-		t.Errorf("a foreign property was carried: %+v, %v", dropped, err)
-	}
-	cases := []struct {
-		in, want rdf.Term
-	}{
-		{rdf.TypedLiteral("a", rdf.XSD+"string"), rdf.String("a")},
-		{rdf.TypedLiteral("2", rdf.XSD+"decimal"), rdf.TypedLiteral("2", rdf.XSD+"integer")},
-		{rdf.TypedLiteral("2.5", rdf.XSD+"decimal"), rdf.TypedLiteral("2.5", rdf.XSD+"decimal")},
-		{rdf.TypedLiteral("-4", rdf.XSD+"integer"), rdf.TypedLiteral("-4", rdf.XSD+"integer")},
-		{rdf.TypedLiteral("false", rdf.XSD+"boolean"), rdf.TypedLiteral("false", rdf.XSD+"boolean")},
-		{rdf.IRI(rdf.Expression + "E"), rdf.IRI(rdf.Expression + "E")},
-		{rdf.IRI(rdf.RDFNS + "nil"), rdf.IRI(rdf.RDFNS + "nil")},
-	}
-	for _, tc := range cases {
-		got, ok, err := rep.Carry(triple(x, rdf.SysML+"p", tc.in))
-		if err != nil || !ok {
-			t.Errorf("%s: not carried: %v", tc.in, err)
-			continue
-		}
-		if got.Object != tc.want {
-			t.Errorf("%s: carried as %s, want %s", tc.in, got.Object, tc.want)
-		}
-	}
-	if _, _, err := rep.Carry(triple(x, rdf.SysML+"p", rdf.TypedLiteral("1e3", rdf.XSD+"decimal"))); err == nil {
-		t.Error("a non-JSON number was carried")
-	}
-}
-
 // fakePut is a whole-graph write the fake Layer 1 received: the path it hit,
 // the entity tag it was preconditioned on, the media type and the Turtle body.
 type fakePut struct {
diff --git a/internal/translate/interop/modelsync/modelsync.go b/internal/translate/interop/modelsync/modelsync.go
new file mode 100644
index 0000000000..6cbddcff49
--- /dev/null
+++ b/internal/translate/interop/modelsync/modelsync.go
@@ -0,0 +1,321 @@
+// Package modelsync is what `sysml -sync` and the REPL's repository commands
+// share above reposync: reading a model as the graph a sync compares, cutting
+// the graph rooted in one element, stamping a graph with the project branch it
+// came from so its notation declares a ProjectRef, and applying a change set
+// while advancing the sync state. Neither client diffs or applies on its own.
+package modelsync
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/translate/convert"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/export"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf/ontology"
+)
+
+// Repository is a project branch a sync reads and writes: the surface
+// sysmlapi.Repository and flexo.Repository both offer.
+type Repository interface {
+	reposync.Committer
+	// Head is the branch's current head commit, empty for a branch no commit
+	// has reached yet.
+	Head(ctx context.Context) (string, error)
+	// Seen is the head the last read stood at or the last commit written.
+	Seen() string
+	// Resume records the last-seen commit a saved state carries.
+	Resume(commit string)
+	// Graph reads the branch at its head.
+	Graph(ctx context.Context) (*rdf.Graph, error)
+	// GraphAt reads the branch as one commit left it.
+	GraphAt(ctx context.Context, commit string) (*rdf.Graph, error)
+}
+
+// Baseline reads the repository as the state's last-seen commit left it: the
+// graph a diff tells repository changes since then apart against. Nil when the
+// state names no commit.
+func Baseline(ctx context.Context, repo Repository, state *reposync.State) (*rdf.Graph, error) {
+	if state == nil || state.LastSeenCommit == "" {
+		return nil, nil
+	}
+	base, err := repo.GraphAt(ctx, state.LastSeenCommit)
+	if err != nil {
+		return nil, fmt.Errorf("read the repository at last-seen commit %s: %w", state.LastSeenCommit, err)
+	}
+	return base, nil
+}
+
+// Applied is what one apply left behind: the commit it ended on and how many
+// changes of each kind landed. Commit is empty when the repository already
+// agreed with the model.
+type Applied struct {
+	Commit                    string
+	Created, Updated, Deleted int
+	Result                    *reposync.Result
+}
+
+// Apply writes an appliable change set and advances the state: to the last
+// commit written, or, when nothing needed writing, to the head the repository
+// was read at. A partial apply returns the result with the error.
+func Apply(ctx context.Context, repo Repository, set *reposync.ChangeSet, state *reposync.State, message string) (*Applied, error) {
+	if err := set.Appliable(); err != nil {
+		return nil, err
+	}
+	result, err := reposync.Apply(ctx, repo, set, reposync.ApplyOptions{Message: message})
+	if err != nil {
+		return &Applied{Result: result}, err
+	}
+	applied := &Applied{Result: result}
+	for _, change := range result.Applied {
+		switch change.Kind {
+		case reposync.KindCreate:
+			applied.Created++
+		case reposync.KindUpdate:
+			applied.Updated++
+		case reposync.KindDelete:
+			applied.Deleted++
+		}
+	}
+	if len(result.Applied) == 0 {
+		if head := repo.Seen(); head != "" {
+			state.LastSeenCommit = head
+		}
+		return applied, nil
+	}
+	if err := state.Advance(result); err != nil {
+		return applied, err
+	}
+	applied.Commit = result.LastCommit()
+	return applied, nil
+}
+
+// Scope predicates: the provenance an exported graph carries on its scope roots,
+// the ones reposync.GraphScope reads.
+const (
+	predProjectID = rdf.OpenSysML + "projectId"
+	predBranch    = rdf.OpenSysML + "branch"
+	predOrg       = rdf.OpenSysML + "org"
+)
+
+// ownerPredicates lead from an element to what owns it, in the forms the
+// mapping writes; owningRelationship leads to the relationship, whose own
+// owner is the element's.
+var ownerPredicates = []string{
+	rdf.SysML + "owner",
+	rdf.SysML + "owningRelatedElement",
+	rdf.SysML + "membershipOwningNamespace",
+	rdf.SysML + "owningNamespace",
+	rdf.SysML + "owningMembership",
+	rdf.SysML + "owningRelationship",
+}
+
+// Scoped returns graph with scope stamped on every root element — each
+// element of the graph that nothing in it owns and that is not a library
+// reference — in place of any scope it carried, so the notation written from
+// it declares the ProjectRef a later sync finds the branch by.
+func Scoped(graph *rdf.Graph, scope reposync.Scope) *rdf.Graph {
+	out := rdf.NewGraphWithCapacity(graph.Len())
+	for _, triple := range graph.Triples() {
+		switch triple.Predicate.Value {
+		case predProjectID, predBranch, predOrg:
+			continue
+		}
+		out.AddTriple(triple)
+	}
+	if scope.IsZero() {
+		return out
+	}
+	for _, root := range Roots(graph) {
+		for _, field := range []struct{ predicate, value string }{
+			{predProjectID, scope.ProjectID}, {predBranch, scope.Branch}, {predOrg, scope.Org},
+		} {
+			if field.value != "" {
+				out.Add(root, rdf.IRI(field.predicate), rdf.String(field.value))
+			}
+		}
+	}
+	return out
+}
+
+// Roots lists the elements the graph declares and nothing in it owns, in the
+// graph's subject order: the elements a document's namespace would hold.
+func Roots(graph *rdf.Graph) []rdf.Term {
+	var roots []rdf.Term
+	for _, subject := range graph.Subjects() {
+		if !strings.HasPrefix(subject.Value, rdf.Element) || !strings.HasPrefix(graph.Type(subject), rdf.SysML) {
+			continue
+		}
+		if ownerOf(graph, subject).Value != "" || export.LibraryReference(graph, subject) {
+			continue
+		}
+		roots = append(roots, subject)
+	}
+	return roots
+}
+
+// ownerOf is the element or relationship that owns subject in the graph; the
+// zero term when the graph states none.
+func ownerOf(graph *rdf.Graph, subject rdf.Term) rdf.Term {
+	for _, predicate := range ownerPredicates {
+		if owner, ok := graph.Object(subject, predicate); ok && owner.IsIRI() {
+			return owner
+		}
+	}
+	return rdf.Term{}
+}
+
+// Notation writes a graph as SysML notation, each warning the writer raises
+// passed to warn.
+func Notation(graph *rdf.Graph, warn func(string)) ([]byte, error) {
+	return convert.FromGraphWith(graph, convert.FormatSysML, convert.Options{Warn: warn})
+}
+
+// NotFoundError is a qualified name no element of the graph carries.
+type NotFoundError struct {
+	QualifiedName string
+}
+
+func (e *NotFoundError) Error() string {
+	return fmt.Sprintf("no element of the model is named %s", e.QualifiedName)
+}
+
+// Rooted cuts the graph down to the element of the given qualified name and
+// everything it owns, directly or through its relationships. The element
+// becomes a root: the triples tying it to its own owner are dropped, as a
+// project's root element has none. Elements the cut references but does not
+// own stay references.
+func Rooted(graph *rdf.Graph, qualifiedName string) (*rdf.Graph, error) {
+	for _, subject := range graph.Subjects() {
+		if name, ok := graph.Lexical(subject, rdf.SysML+"qualifiedName"); ok && name == qualifiedName {
+			return RootedAt(graph, subject), nil
+		}
+	}
+	return nil, &NotFoundError{QualifiedName: qualifiedName}
+}
+
+// RootedAt is Rooted at a given element. An element the graph does not hold
+// cuts to an empty graph.
+func RootedAt(graph *rdf.Graph, root rdf.Term) *rdf.Graph {
+	inside := map[rdf.Term]bool{root: true}
+	reaches := func(subject rdf.Term) bool {
+		seen := map[rdf.Term]bool{}
+		var chain []rdf.Term
+		for current := subject; current.Value != "" && !seen[current]; current = ownerOf(graph, current) {
+			if known, ok := inside[current]; ok {
+				for _, c := range chain {
+					inside[c] = known
+				}
+				return known
+			}
+			seen[current] = true
+			chain = append(chain, current)
+		}
+		for _, c := range chain {
+			inside[c] = false
+		}
+		return false
+	}
+	out := rdf.NewGraph()
+	for _, triple := range graph.Triples() {
+		subject := triple.Subject
+		if !subject.IsIRI() || !reaches(subject) {
+			continue
+		}
+		if subject == root && isOwnerPredicate(triple.Predicate.Value) {
+			continue
+		}
+		out.AddTriple(triple)
+	}
+	return out
+}
+
+func isOwnerPredicate(predicate string) bool {
+	for _, p := range ownerPredicates {
+		if predicate == p {
+			return true
+		}
+	}
+	return false
+}
+
+// readerDerived are the derived properties the notation reader takes from the
+// graph rather than recomputing — a collection's order among them — so a
+// publish without derived properties keeps them: a project written without
+// them could not be loaded back as notation.
+// TestWithoutDerivedReadsBackEveryExample pins the list against the reader.
+var readerDerived = map[string]bool{}
+
+func init() {
+	for _, name := range strings.Fields(`annotatedElement annotatingElement argument chainingFeature condition
+		conjugatedPortDefinition connectorEnd effectAction featureChained featureWithValue
+		function guardExpression importOwningNamespace input isLibraryElement isReference
+		lowerBound membershipOwningNamespace multiplicity operand ownedActorParameter
+		ownedAnnotation ownedConcern ownedConstraint ownedEndFeature ownedFeature
+		ownedFeatureChaining ownedFeatureMembership ownedImport ownedMember ownedMemberElement
+		ownedMemberFeature ownedMemberParameter ownedMembership ownedObjectiveRequirement
+		ownedPortConjugator ownedRedefinition ownedReferenceSubsetting ownedRendering
+		ownedRequirement ownedResultExpression ownedSpecialization ownedSubclassification
+		ownedSubjectParameter ownedSubsetting ownedTyping ownedVariantUsage owner owningFeature
+		owningMembership owningNamespace owningType parameter payloadArgument payloadParameter
+		qualifiedName referencedElement referencingFeature referent relatedElement relatedFeature
+		result source sourceFeature succession target targetFeature transitionFeature
+		triggerAction type upperBound value variant variantMembership`) {
+		readerDerived[name] = true
+	}
+}
+
+// WithoutDerived returns graph without the sysml: properties the metamodel
+// derives on each subject's metaclass, readerDerived aside: what a publish
+// without derived properties sends. The pilot's sends none of them; this
+// writer's reader needs most, so only the ones it recomputes are left out.
+func WithoutDerived(graph *rdf.Graph) *rdf.Graph {
+	out := rdf.NewGraphWithCapacity(graph.Len())
+	for _, triple := range graph.Triples() {
+		if derived(graph, triple) {
+			continue
+		}
+		out.AddTriple(triple)
+	}
+	return out
+}
+
+// derived tells a derived property's triple, or the collection annotation that
+// would restate one, from the properties the reader needs.
+func derived(graph *rdf.Graph, triple rdf.Triple) bool {
+	name, ok := strings.CutPrefix(triple.Predicate.Value, rdf.SysML)
+	if !ok {
+		name, ok = strings.CutPrefix(triple.Predicate.Value, rdf.AnnotationJSON)
+	}
+	if !ok || readerDerived[name] {
+		return false
+	}
+	metaclass, ok := strings.CutPrefix(graph.Type(triple.Subject), rdf.SysML)
+	if !ok {
+		return false
+	}
+	property, ok := ontology.PropertyOf(metaclass, name)
+	return ok && property.Derived
+}
+
+// ErrAmbiguousName is a name several projects share.
+var ErrAmbiguousName = errors.New("ambiguous project name")
+
+// AmbiguousNameError names the projects that share one name, so the caller
+// can pick one by id.
+type AmbiguousNameError struct {
+	Name string
+	IDs  []string
+}
+
+func (e *AmbiguousNameError) Error() string {
+	ids := append([]string(nil), e.IDs...)
+	sort.Strings(ids)
+	return fmt.Sprintf("%d projects are named %q (%s); choose one with --id", len(ids), e.Name, strings.Join(ids, ", "))
+}
+
+func (e *AmbiguousNameError) Is(target error) bool { return target == ErrAmbiguousName }
diff --git a/internal/translate/interop/modelsync/modelsync_test.go b/internal/translate/interop/modelsync/modelsync_test.go
new file mode 100644
index 0000000000..6c2c86147b
--- /dev/null
+++ b/internal/translate/interop/modelsync/modelsync_test.go
@@ -0,0 +1,176 @@
+package modelsync
+
+import (
+	"bytes"
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/translate/convert"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/export"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+const model = `package Vehicles {
+	part def Wheel { attribute radius : ScalarValues::Real; }
+	part def Car { part wheels : Wheel[4]; }
+}
+package Other { part def Boat; }
+`
+
+func graphOf(t *testing.T, notation string) *rdf.Graph {
+	t.Helper()
+	graph, err := convert.SysMLToRDF("session.sysml", []byte(notation))
+	if err != nil {
+		t.Fatal(err)
+	}
+	return graph
+}
+
+func TestRootedCutsOneElementAndWhatItOwns(t *testing.T) {
+	graph := graphOf(t, model)
+	cut, err := Rooted(graph, "Vehicles")
+	if err != nil {
+		t.Fatal(err)
+	}
+	roots := Roots(cut)
+	if len(roots) != 1 {
+		t.Fatalf("roots of the cut: %v, want just Vehicles", roots)
+	}
+	for _, subject := range cut.Subjects() {
+		if name, _ := cut.Lexical(subject, rdf.SysML+"qualifiedName"); strings.HasPrefix(name, "Other") {
+			t.Errorf("%s is outside Vehicles but in the cut", name)
+		}
+	}
+	found := false
+	for _, subject := range cut.Subjects() {
+		if name, _ := cut.Lexical(subject, rdf.SysML+"qualifiedName"); name == "Vehicles::Car::wheels" {
+			found = true
+		}
+	}
+	if !found {
+		t.Error("Vehicles::Car::wheels is owned by Vehicles but missing from the cut")
+	}
+	if _, err := Rooted(graph, "Nowhere"); err == nil {
+		t.Error("an unknown name was cut")
+	}
+}
+
+func TestRootedCutReadsBackAsNotation(t *testing.T) {
+	graph := graphOf(t, model)
+	for _, derived := range []bool{true, false} {
+		cut, err := Rooted(graph, "Vehicles")
+		if err != nil {
+			t.Fatal(err)
+		}
+		if !derived {
+			cut = WithoutDerived(cut)
+		}
+		data, err := export.WriteAPIJSON(cut)
+		if err != nil {
+			t.Fatalf("derived=%v: write: %v", derived, err)
+		}
+		back, err := export.ReadAPIJSON(data)
+		if err != nil {
+			t.Fatalf("derived=%v: read: %v", derived, err)
+		}
+		notation, err := Notation(Scoped(back, reposync.Scope{ProjectID: "p1", Branch: "main"}), nil)
+		if err != nil {
+			t.Fatalf("derived=%v: notation: %v", derived, err)
+		}
+		text := string(notation)
+		for _, want := range []string{"package Vehicles", "part def Wheel", "part wheels : Wheel[4]", "projectId = \"p1\"", "branch = \"main\""} {
+			if !strings.Contains(text, want) {
+				t.Errorf("derived=%v: notation lacks %q:\n%s", derived, want, text)
+			}
+		}
+		if strings.Contains(text, "Boat") {
+			t.Errorf("derived=%v: notation holds Boat, outside Vehicles:\n%s", derived, text)
+		}
+	}
+}
+
+const chained = `package Chains {
+	part def A { part b : B; }
+	part def B { attribute x : ScalarValues::Real; }
+	part a : A { attribute y = a.b.x; }
+	variation part def Choice { variant part one : A; }
+}
+`
+
+func TestWithoutDerivedDropsDerivedPropertiesTheReaderRecomputes(t *testing.T) {
+	full := graphOf(t, chained)
+	cut := WithoutDerived(full)
+	for _, triple := range full.Triples() {
+		if cut.Has(triple) {
+			continue
+		}
+		name := rdf.LocalName(triple.Predicate.Value)
+		if readerDerived[name] || !derived(full, triple) {
+			t.Errorf("%s was dropped from %s", name, triple.Subject)
+		}
+	}
+	for _, name := range []string{"declaredName", "qualifiedName", "owner"} {
+		found := false
+		for _, triple := range cut.Triples() {
+			if triple.Predicate.Value == rdf.SysML+name {
+				found = true
+				break
+			}
+		}
+		if !found {
+			t.Errorf("no %s is left", name)
+		}
+	}
+}
+
+// TestWithoutDerivedReadsBackEveryExample pins readerDerived against the
+// notation reader: every example publishes without derived properties to the
+// notation it publishes with them.
+func TestWithoutDerivedReadsBackEveryExample(t *testing.T) {
+	files, err := filepath.Glob("../../../../examples/*.sysml")
+	if err != nil || len(files) == 0 {
+		t.Fatalf("no examples: %v", err)
+	}
+	roundTrip := func(graph *rdf.Graph) ([]byte, error) {
+		data, err := export.WriteAPIJSON(graph)
+		if err != nil {
+			return nil, err
+		}
+		back, err := export.ReadAPIJSON(data)
+		if err != nil {
+			return nil, err
+		}
+		return Notation(back, nil)
+	}
+	dropped := 0
+	for _, file := range files {
+		data, err := os.ReadFile(file)
+		if err != nil {
+			t.Fatal(err)
+		}
+		graph, err := convert.SysMLToRDF(file, data)
+		if err != nil {
+			continue
+		}
+		want, err := roundTrip(graph)
+		if err != nil {
+			continue
+		}
+		cut := WithoutDerived(graph)
+		dropped += graph.Len() - cut.Len()
+		got, err := roundTrip(cut)
+		if err != nil {
+			t.Errorf("%s: without derived properties: %v", filepath.Base(file), err)
+			continue
+		}
+		if !bytes.Equal(got, want) {
+			t.Errorf("%s: the notation differs without derived properties", filepath.Base(file))
+		}
+	}
+	if dropped == 0 {
+		t.Error("no example has a derived property to leave out")
+	}
+}
diff --git a/internal/translate/interop/sysmlapi/client.go b/internal/translate/interop/sysmlapi/client.go
new file mode 100644
index 0000000000..accea20d20
--- /dev/null
+++ b/internal/translate/interop/sysmlapi/client.go
@@ -0,0 +1,644 @@
+// Package sysmlapi drives any server speaking the standard SysML v2 API: the
+// projects, branches, commits and elements resources the OMG pilot's
+// SysML-v2-API-Services and Flexo MMS alike serve. It knows nothing of a
+// server's extras — Flexo's Layer 1, orgs and Turtle graph writes live in
+// package flexo, which builds on this client.
+package sysmlapi
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Environment variables a client is configured from. The base URL and the token
+// are the ones `sysml -sync` reads, so a REPL and the command line address one
+// server the same way; the token is optional, as the pilot's server takes none.
+const (
+	EnvBaseURL   = "FLEXO_SYSMLV2_URL"
+	EnvToken     = "FLEXO_INTEROP_TOKEN" // #nosec G101 -- a variable name, not a credential
+	EnvPlainHTTP = "FLEXO_ALLOW_PLAIN_HTTP"
+)
+
+// DefaultBaseURL is the SysML v2 API port of flexo-mms-sysmlv2's compose file.
+const DefaultBaseURL = "http://localhost:8083"
+
+// DefaultTimeout bounds one request when the configuration names none.
+const DefaultTimeout = 60 * time.Second
+
+// pageSize is how many items one listing request asks for.
+const pageSize = 200
+
+// maxPages bounds a listing against a server that pages forever.
+const maxPages = 1000
+
+// maxRedirects is how many redirects one request follows, as net/http does.
+const maxRedirects = 10
+
+// Config addresses one SysML v2 API server.
+type Config struct {
+	BaseURL string        // the API's base path, without a trailing slash
+	Token   string        // bearer token, sent only when set
+	Timeout time.Duration // per-request bound; DefaultTimeout when zero
+}
+
+// ConfigFromEnv reads the base URL and the token from the environment; the URL
+// defaults to the compose file's port, the token to none.
+func ConfigFromEnv() Config {
+	base := os.Getenv(EnvBaseURL)
+	if base == "" {
+		base = DefaultBaseURL
+	}
+	return Config{BaseURL: strings.TrimRight(base, "/"), Token: os.Getenv(EnvToken), Timeout: DefaultTimeout}
+}
+
+// PlaintextError is a bearer token about to cross the network unencrypted: an
+// http:// URL whose host is not this machine.
+type PlaintextError struct {
+	URL string
+}
+
+func (e *PlaintextError) Error() string {
+	return fmt.Sprintf("%s would send the bearer token in the clear; use https://, or set %s=1 for a server you trust the network to", e.URL, EnvPlainHTTP)
+}
+
+// CheckURL refuses a plaintext URL to anything but a loopback host, unless the
+// environment opts in with FLEXO_ALLOW_PLAIN_HTTP=1, and any URL that is not
+// http(s).
+func CheckURL(raw string) error {
+	u, err := url.Parse(raw)
+	if err != nil {
+		return fmt.Errorf("server url %q: %w", raw, err)
+	}
+	if u.Scheme != "http" && u.Scheme != "https" || u.Host == "" {
+		return fmt.Errorf("server url %q is not an http(s) URL", raw)
+	}
+	if u.Scheme == "http" && !Loopback(u.Hostname()) && os.Getenv(EnvPlainHTTP) != "1" {
+		return &PlaintextError{URL: raw}
+	}
+	return nil
+}
+
+// Loopback reports a host name that resolves to this machine without a lookup.
+func Loopback(host string) bool {
+	if host == "localhost" || strings.HasSuffix(host, ".localhost") {
+		return true
+	}
+	ip := net.ParseIP(host)
+	return ip != nil && ip.IsLoopback()
+}
+
+// Client talks to one server. It is safe for sequential use.
+type Client struct {
+	cfg  Config
+	http *http.Client
+}
+
+// New returns a client for cfg.
+func New(cfg Config) *Client {
+	timeout := cfg.Timeout
+	if timeout <= 0 {
+		timeout = DefaultTimeout
+	}
+	cfg.BaseURL = strings.TrimRight(cfg.BaseURL, "/")
+	c := &Client{cfg: cfg}
+	c.http = &http.Client{Timeout: timeout, CheckRedirect: c.checkRedirect}
+	return c
+}
+
+// checkRedirect holds a redirect to the rule of the first request when there
+// is a bearer token to carry: it stays on the server's host, off plaintext and
+// on https once there, so a redirect cannot take the token elsewhere or into
+// the clear — not even on loopback, where a first request may be plain.
+func (c *Client) checkRedirect(req *http.Request, via []*http.Request) error {
+	if len(via) >= maxRedirects {
+		return fmt.Errorf("stopped after %d redirects", maxRedirects)
+	}
+	from := via[len(via)-1].URL
+	if err := c.tokenStays(from, req.URL); err != nil {
+		return fmt.Errorf("redirect from %s refused: %w", from, err)
+	}
+	return nil
+}
+
+// tokenStays is the rule a request's successor — a redirect's target, a linked
+// next page — is held to when there is a bearer token to carry: no plaintext,
+// no leaving https once there, and no other server than the configured one.
+func (c *Client) tokenStays(from, to *url.URL) error {
+	if c.cfg.Token == "" {
+		return nil
+	}
+	if err := CheckURL(to.String()); err != nil {
+		return err
+	}
+	if from.Scheme == "https" && to.Scheme != "https" {
+		return fmt.Errorf("%s: the token stays on https", to.Scheme)
+	}
+	if base, err := url.Parse(c.cfg.BaseURL); err == nil && !sameServer(to, base) {
+		return fmt.Errorf("%s: the token is for %s only", to.Host, base.Host)
+	}
+	return nil
+}
+
+// sameServer compares two URLs by host name and effective port, so that
+// https://api.example and https://api.example:443 are one server.
+func sameServer(a, b *url.URL) bool {
+	return strings.EqualFold(a.Hostname(), b.Hostname()) && effectivePort(a) == effectivePort(b)
+}
+
+func effectivePort(u *url.URL) string {
+	if port := u.Port(); port != "" {
+		return port
+	}
+	if u.Scheme == "https" {
+		return "443"
+	}
+	return "80"
+}
+
+// Config returns the configuration the client was built with.
+func (c *Client) Config() Config { return c.cfg }
+
+// BaseURL is the server's base path.
+func (c *Client) BaseURL() string { return c.cfg.BaseURL }
+
+// StatusError is a response outside 2xx. It carries the body, because servers
+// answer with their diagnostic there.
+type StatusError struct {
+	Method string
+	URL    string
+	Status int
+	Body   string
+}
+
+func (e *StatusError) Error() string {
+	return fmt.Sprintf("%s %s: %s: %s", e.Method, e.URL, http.StatusText(e.Status), e.Message())
+}
+
+// Message is the server's diagnostic: the body's message field when it is a
+// JSON object stating one, else the body itself, trimmed to a line's worth.
+func (e *StatusError) Message() string {
+	body := strings.TrimSpace(e.Body)
+	var object map[string]json.RawMessage
+	if json.Unmarshal([]byte(body), &object) == nil {
+		for _, key := range []string{"message", "error", "detail"} {
+			var text string
+			if raw, ok := object[key]; ok && json.Unmarshal(raw, &text) == nil && text != "" {
+				body = text
+				break
+			}
+		}
+	}
+	if len(body) > 400 {
+		body = body[:400] + "..."
+	}
+	return body
+}
+
+// Status returns the HTTP status of a failed request, or 0 if err is not one.
+func Status(err error) int {
+	var se *StatusError
+	if errors.As(err, &se) {
+		return se.Status
+	}
+	return 0
+}
+
+// UnreachableError is a server that answered nothing: the connection failed
+// before any status came back.
+type UnreachableError struct {
+	URL string
+	Err error
+}
+
+func (e *UnreachableError) Error() string {
+	return fmt.Sprintf("the server at %s did not answer: %v", e.URL, e.Err)
+}
+
+func (e *UnreachableError) Unwrap() error { return e.Err }
+
+// Do performs one request, authorized when the configuration holds a token,
+// and returns the response body and headers, failing on any status outside 2xx.
+func (c *Client) Do(ctx context.Context, method, target string, body []byte, contentType string, headers map[string]string) ([]byte, http.Header, error) {
+	var reader io.Reader
+	if body != nil {
+		reader = bytes.NewReader(body)
+	}
+	req, err := http.NewRequestWithContext(ctx, method, target, reader)
+	if err != nil {
+		return nil, nil, err
+	}
+	if c.cfg.Token != "" {
+		req.Header.Set("Authorization", "Bearer "+c.cfg.Token)
+	}
+	if contentType != "" {
+		req.Header.Set("Content-Type", contentType)
+	}
+	for name, value := range headers {
+		req.Header.Set(name, value)
+	}
+
+	resp, err := c.http.Do(req)
+	if err != nil {
+		return nil, nil, &UnreachableError{URL: c.cfg.BaseURL, Err: err}
+	}
+	defer func() { _ = resp.Body.Close() }()
+
+	content, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, resp.Header, err
+	}
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return content, resp.Header, &StatusError{Method: method, URL: target, Status: resp.StatusCode, Body: string(content)}
+	}
+	return content, resp.Header, nil
+}
+
+func (c *Client) getJSON(ctx context.Context, target string, into any, what string) error {
+	content, _, err := c.Do(ctx, http.MethodGet, target, nil, "", nil)
+	if err != nil {
+		return err
+	}
+	if err := json.Unmarshal(content, into); err != nil {
+		return fmt.Errorf("decode %s: %w", what, err)
+	}
+	return nil
+}
+
+func (c *Client) postJSON(ctx context.Context, target string, request any, into any, what string) error {
+	body, err := json.Marshal(request)
+	if err != nil {
+		return err
+	}
+	content, _, err := c.Do(ctx, http.MethodPost, target, body, "application/json", nil)
+	if err != nil {
+		return err
+	}
+	if err := json.Unmarshal(content, into); err != nil {
+		return fmt.Errorf("decode %s: %w", what, err)
+	}
+	return nil
+}
+
+// Reachable reports whether the server answers: the project list is the
+// cheapest read every server has.
+func (c *Client) Reachable(ctx context.Context) error {
+	_, _, err := c.Do(ctx, http.MethodGet, c.cfg.BaseURL+"/projects", nil, "", nil)
+	return err
+}
+
+// Ref is a reference to another resource, as the API spells it.
+type Ref struct {
+	ID string `json:"@id"`
+}
+
+// Project is one project as the API describes it.
+type Project struct {
+	ID            string `json:"@id"`
+	Name          string `json:"name"`
+	DefaultBranch Ref    `json:"defaultBranch"`
+}
+
+// Branch is one branch as the API describes it: its id, its name and the
+// commit at its head.
+type Branch struct {
+	ID   string `json:"@id"`
+	Name string `json:"name"`
+	Head Commit `json:"head"`
+}
+
+// Commit identifies one commit of a project.
+type Commit struct {
+	ID   string `json:"@id"`
+	Type string `json:"@type"`
+}
+
+// Element is one element as the API delivers it: property name to raw JSON
+// value, kept raw so a value's shape — reference, literal, array — is
+// observable rather than normalized away by decoding into a Go type.
+type Element map[string]json.RawMessage
+
+// ID returns an element's identity, preferring @id over elementId.
+func (e Element) ID() string {
+	for _, key := range []string{"@id", "elementId"} {
+		if raw, ok := e[key]; ok {
+			var id string
+			if json.Unmarshal(raw, &id) == nil && id != "" {
+				return id
+			}
+		}
+	}
+	return ""
+}
+
+// Type returns an element's @type, or "" when it carries none.
+func (e Element) Type() string {
+	var name string
+	if raw, ok := e["@type"]; ok && json.Unmarshal(raw, &name) == nil {
+		return name
+	}
+	return ""
+}
+
+func (c *Client) projectPath(project string) string {
+	return c.cfg.BaseURL + "/projects/" + url.PathEscape(project)
+}
+
+func (c *Client) commitPath(project, commit string) string {
+	return c.projectPath(project) + "/commits/" + url.PathEscape(commit)
+}
+
+// paged walks one collection to its end. The API spells the paging parameters
+// `page[size]` and `page[after]` and links the next page in a Link header;
+// Flexo spells them `pageSize` and `pageAfter` and links nothing, so both
+// spellings are sent and the next page is the linked one, else the one after
+// the last item. A short page ends the walk; so does a page repeating an item.
+func (c *Client) paged(ctx context.Context, target string, what string, each func(json.RawMessage) (id string, fresh bool)) error {
+	next := withPaging(target, "")
+	for page := 1; page <= maxPages; page++ {
+		content, header, err := c.Do(ctx, http.MethodGet, next, nil, "", nil)
+		if err != nil {
+			return err
+		}
+		var items []json.RawMessage
+		if err := json.Unmarshal(content, &items); err != nil {
+			return fmt.Errorf("decode %s page %d: %w", what, page, err)
+		}
+		last, repeated := "", false
+		for _, item := range items {
+			id, fresh := each(item)
+			if !fresh {
+				repeated = true
+			}
+			last = id
+		}
+		if repeated || last == "" {
+			return nil
+		}
+		// A server linking its pages is followed to the end whatever each
+		// page holds; without a link, a short page is the last.
+		linked, err := c.nextPage(header, next)
+		if err != nil {
+			return err
+		}
+		if linked != "" && linked != next {
+			next = linked
+			continue
+		}
+		if len(items) < pageSize {
+			return nil
+		}
+		next = withPaging(target, last)
+	}
+	return fmt.Errorf("%s: the server paged on past %d pages", what, maxPages)
+}
+
+// withPaging adds both spellings of the page size and, when after is set, of
+// the cursor to a collection URL.
+func withPaging(target, after string) string {
+	sep := "?"
+	if strings.Contains(target, "?") {
+		sep = "&"
+	}
+	size := strconv.Itoa(pageSize)
+	out := target + sep + "page%5Bsize%5D=" + size + "&pageSize=" + size
+	if after != "" {
+		out += "&page%5Bafter%5D=" + url.QueryEscape(after) + "&pageAfter=" + url.QueryEscape(after)
+	}
+	return out
+}
+
+// nextPage is the page a response links as next, held to the rule a redirect
+// is: a link to another server, or into the clear, is refused rather than
+// followed with the token.
+func (c *Client) nextPage(header http.Header, requested string) (string, error) {
+	linked := nextLink(header, requested)
+	if linked == "" {
+		return "", nil
+	}
+	from, err := url.Parse(requested)
+	if err != nil {
+		return "", err
+	}
+	to, err := url.Parse(linked)
+	if err != nil {
+		return "", err
+	}
+	if err := c.tokenStays(from, to); err != nil {
+		return "", fmt.Errorf("next page linked from %s refused: %w", from, err)
+	}
+	return linked, nil
+}
+
+// nextLink is the rel="next" target of a Link header, resolved against the
+// request's URL; empty when the response links no next page.
+func nextLink(header http.Header, requested string) string {
+	base, err := url.Parse(requested)
+	if err != nil {
+		return ""
+	}
+	for _, field := range header.Values("Link") {
+		for _, link := range strings.Split(field, ",") {
+			target, params, _ := strings.Cut(strings.TrimSpace(link), ";")
+			if !strings.Contains(params, `rel="next"`) && !strings.Contains(params, "rel=next") {
+				continue
+			}
+			target = strings.TrimSuffix(strings.TrimPrefix(strings.TrimSpace(target), "<"), ">")
+			u, err := url.Parse(target)
+			if err != nil {
+				return ""
+			}
+			return base.ResolveReference(u).String()
+		}
+	}
+	return ""
+}
+
+// Projects lists every project, paged through to the end.
+func (c *Client) Projects(ctx context.Context) ([]Project, error) {
+	var projects []Project
+	seen := make(map[string]bool)
+	err := c.paged(ctx, c.cfg.BaseURL+"/projects", "projects", func(raw json.RawMessage) (string, bool) {
+		var p Project
+		if json.Unmarshal(raw, &p) != nil || p.ID == "" || seen[p.ID] {
+			return p.ID, false
+		}
+		seen[p.ID] = true
+		projects = append(projects, p)
+		return p.ID, true
+	})
+	return projects, err
+}
+
+// Project reads one project by id.
+func (c *Client) Project(ctx context.Context, id string) (Project, error) {
+	var p Project
+	err := c.getJSON(ctx, c.projectPath(id), &p, "project")
+	return p, err
+}
+
+// CreateProject creates a project. An id names the project when the server
+// honours client ids, as Flexo does; a default branch names the branch the
+// server creates with it. Either empty leaves the choice to the server.
+func (c *Client) CreateProject(ctx context.Context, id, name, branch string) (Project, error) {
+	request := map[string]any{"@type": "Project", "name": name}
+	if id != "" {
+		request["@id"] = id
+	}
+	if branch != "" {
+		request["defaultBranch"] = map[string]any{"@id": branch, "name": branch}
+	}
+	var created Project
+	if err := c.postJSON(ctx, c.cfg.BaseURL+"/projects", request, &created, "created project"); err != nil {
+		return Project{}, err
+	}
+	if created.ID == "" {
+		created.ID = id
+	}
+	if created.Name == "" {
+		created.Name = name
+	}
+	return created, nil
+}
+
+// Branches lists every branch of a project, paged through to the end.
+func (c *Client) Branches(ctx context.Context, project string) ([]Branch, error) {
+	var branches []Branch
+	seen := make(map[string]bool)
+	err := c.paged(ctx, c.projectPath(project)+"/branches", "branches", func(raw json.RawMessage) (string, bool) {
+		var b Branch
+		if json.Unmarshal(raw, &b) != nil || b.ID == "" || seen[b.ID] {
+			return b.ID, false
+		}
+		seen[b.ID] = true
+		branches = append(branches, b)
+		return b.ID, true
+	})
+	return branches, err
+}
+
+// Branch reads one branch of a project, head commit included.
+func (c *Client) Branch(ctx context.Context, project, branch string) (Branch, error) {
+	var b Branch
+	err := c.getJSON(ctx, c.projectPath(project)+"/branches/"+url.PathEscape(branch), &b, "branch")
+	return b, err
+}
+
+// Commits lists a project's commits, in the order the server returns them.
+func (c *Client) Commits(ctx context.Context, project string) ([]Commit, error) {
+	var commits []Commit
+	err := c.getJSON(ctx, c.projectPath(project)+"/commits", &commits, "commits")
+	return commits, err
+}
+
+// PostChanges commits a CommitRequest body through the server's commit path
+// and returns the commit it made. An empty branch takes the default one.
+func (c *Client) PostChanges(ctx context.Context, project, branch string, changes []byte) (Commit, error) {
+	target := c.projectPath(project) + "/commits"
+	if branch != "" {
+		target += "?branchId=" + url.QueryEscape(branch)
+	}
+	content, _, err := c.Do(ctx, http.MethodPost, target, changes, "application/json", nil)
+	if err != nil {
+		return Commit{}, err
+	}
+	var commit Commit
+	if err := json.Unmarshal(content, &commit); err != nil {
+		return Commit{}, fmt.Errorf("decode commit: %w", err)
+	}
+	return commit, nil
+}
+
+// Listing is one element listing: the elements it delivered, the number of
+// responses it took, and whether the server ignored the paging parameters.
+type Listing struct {
+	Elements      []Element
+	Responses     int
+	IgnoredPaging bool
+}
+
+// Elements reads a commit's elements a page at a time. A page that overruns
+// size or repeats an element is a server ignoring paging; the repeat is
+// dropped rather than counted twice.
+func (c *Client) Elements(ctx context.Context, project, commit string, size int) (Listing, error) {
+	var listing Listing
+	seen := make(map[string]bool)
+	first := c.commitPath(project, commit) + "/elements?pageSize=" + strconv.Itoa(size) + "&page%5Bsize%5D=" + strconv.Itoa(size)
+	target := first
+	for {
+		content, header, err := c.Do(ctx, http.MethodGet, target, nil, "", nil)
+		if err != nil {
+			return listing, err
+		}
+		var page []Element
+		if err := json.Unmarshal(content, &page); err != nil {
+			return listing, fmt.Errorf("decode elements page %d: %w", listing.Responses+1, err)
+		}
+		listing.Responses++
+
+		fresh := 0
+		for _, element := range page {
+			if id := element.ID(); id != "" {
+				if seen[id] {
+					continue
+				}
+				seen[id] = true
+			}
+			listing.Elements = append(listing.Elements, element)
+			fresh++
+		}
+
+		if len(page) > size || fresh < len(page) {
+			listing.IgnoredPaging = true
+			return listing, nil
+		}
+		if len(page) == 0 || listing.Responses > maxPages {
+			return listing, nil
+		}
+		linked, err := c.nextPage(header, target)
+		if err != nil {
+			return listing, err
+		}
+		switch {
+		case linked != "" && linked != target:
+			// A server linking its pages names the continuation itself,
+			// whatever its cursor is; the link is followed as given.
+			target = linked
+		case len(page) < size:
+			// Without a link to a next page, a short page is the last.
+			return listing, nil
+		default:
+			last := page[len(page)-1].ID()
+			if last == "" {
+				return listing, nil
+			}
+			target = first + "&pageAfter=" + url.QueryEscape(last) + "&page%5Bafter%5D=" + url.QueryEscape(last)
+		}
+	}
+}
+
+// ElementByID reads one element directly. A non-2xx answer is returned as the
+// error, with Status(err) carrying the code.
+func (c *Client) ElementByID(ctx context.Context, project, commit, id string) (Element, error) {
+	var element Element
+	err := c.getJSON(ctx, c.commitPath(project, commit)+"/elements/"+url.PathEscape(id), &element, "element "+id)
+	return element, err
+}
+
+// Roots lists the elements the server considers roots of a commit: those with
+// neither an owner nor an owning related element.
+func (c *Client) Roots(ctx context.Context, project, commit string) ([]Element, error) {
+	var roots []Element
+	err := c.getJSON(ctx, c.commitPath(project, commit)+"/roots", &roots, "roots")
+	return roots, err
+}
diff --git a/internal/translate/interop/sysmlapi/client_test.go b/internal/translate/interop/sysmlapi/client_test.go
new file mode 100644
index 0000000000..083030c9a3
--- /dev/null
+++ b/internal/translate/interop/sysmlapi/client_test.go
@@ -0,0 +1,166 @@
+package sysmlapi
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync/atomic"
+	"testing"
+)
+
+// TestElementsFollowLinksWithAnyCursor pages a server whose next links name an
+// offset, not an id: every page is read as the server links it.
+func TestElementsFollowLinksWithAnyCursor(t *testing.T) {
+	const total = 7
+	var requests []string
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		requests = append(requests, r.URL.RequestURI())
+		if r.URL.Query().Get("page[after]") != "" || r.URL.Query().Get("pageAfter") != "" {
+			http.Error(w, "this server pages by offset", http.StatusBadRequest)
+			return
+		}
+		offset, _ := strconv.Atoi(r.URL.Query().Get("page[offset]"))
+		var page []map[string]any
+		for i := offset; i < total && len(page) < 3; i++ {
+			page = append(page, map[string]any{"@id": fmt.Sprintf("e%d", i), "@type": "Package"})
+		}
+		if offset+len(page) < total {
+			next := *r.URL
+			q := next.Query()
+			q.Set("page[offset]", strconv.Itoa(offset+len(page)))
+			next.RawQuery = q.Encode()
+			w.Header().Set("Link", fmt.Sprintf(`<%s>; rel="next"`, next.String()))
+		}
+		_ = json.NewEncoder(w).Encode(page)
+	}))
+	defer server.Close()
+
+	listing, err := New(Config{BaseURL: server.URL}).Elements(context.Background(), "p", "c", 3)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(listing.Elements) != total || listing.Responses != 3 || listing.IgnoredPaging {
+		t.Fatalf("%d elements in %d responses (ignored paging: %v), want %d in 3\n%s",
+			len(listing.Elements), listing.Responses, listing.IgnoredPaging, total, strings.Join(requests, "\n"))
+	}
+	for i, element := range listing.Elements {
+		if element.ID() != fmt.Sprintf("e%d", i) {
+			t.Errorf("element %d is %s", i, element.ID())
+		}
+	}
+}
+
+// TestRedirectsKeepTheTokenOffPlaintext: a redirect is held to the same rule as
+// the first request, so an https server cannot send the token on to http.
+func TestRedirectsKeepTheTokenOffPlaintext(t *testing.T) {
+	t.Setenv(EnvPlainHTTP, "")
+	from, _ := http.NewRequest(http.MethodGet, "https://api.example/projects", nil)
+	request := func(target string) *http.Request {
+		u, err := url.Parse(target)
+		if err != nil {
+			t.Fatal(err)
+		}
+		return &http.Request{URL: u}
+	}
+	withToken := New(Config{BaseURL: "https://api.example", Token: "secret"})
+	if err := withToken.checkRedirect(request("http://api.example/projects/"), []*http.Request{from}); err == nil {
+		t.Error("a downgrade to http carried the token")
+	} else if strings.Contains(err.Error(), "secret") {
+		t.Errorf("the refusal names the token: %v", err)
+	}
+	if err := withToken.checkRedirect(request("https://api.example/v2/projects"), []*http.Request{from}); err != nil {
+		t.Errorf("a redirect within https was refused: %v", err)
+	}
+	for _, elsewhere := range []string{"https://other.example/projects", "https://evil.api.example/projects", "https://api.example:8443/projects"} {
+		if err := withToken.checkRedirect(request(elsewhere), []*http.Request{from}); err == nil {
+			t.Errorf("a redirect to %s carried the token", elsewhere)
+		} else if strings.Contains(err.Error(), "secret") {
+			t.Errorf("the refusal names the token: %v", err)
+		}
+	}
+	for _, canonical := range []string{"https://API.example/projects", "https://api.example:443/projects"} {
+		if err := withToken.checkRedirect(request(canonical), []*http.Request{from}); err != nil {
+			t.Errorf("a redirect to %s, the same server, was refused: %v", canonical, err)
+		}
+	}
+	explicit := New(Config{BaseURL: "https://api.example:443", Token: "secret"})
+	if err := explicit.checkRedirect(request("https://api.example/projects"), []*http.Request{from}); err != nil {
+		t.Errorf("a redirect dropping the default port was refused: %v", err)
+	}
+	loopback := New(Config{BaseURL: "https://localhost:8443", Token: "secret"})
+	if err := loopback.checkRedirect(request("http://localhost:8083/projects"), []*http.Request{from}); err == nil {
+		t.Error("a redirect to another port of loopback carried the token")
+	}
+	if err := loopback.checkRedirect(request("http://localhost:8443/projects"), []*http.Request{from}); err == nil {
+		t.Error("a downgrade to plaintext on loopback carried the token")
+	}
+	t.Setenv(EnvPlainHTTP, "1")
+	plain, _ := http.NewRequest(http.MethodGet, "http://localhost:8083/projects", nil)
+	plainBase := New(Config{BaseURL: "http://localhost:8083", Token: "secret"})
+	if err := plainBase.checkRedirect(request("http://localhost:8083/projects/"), []*http.Request{plain}); err != nil {
+		t.Errorf("a plain redirect of a plain loopback request was refused: %v", err)
+	}
+	if err := plainBase.checkRedirect(request("https://localhost:8083/projects/"), []*http.Request{plain}); err != nil {
+		t.Errorf("an upgrade to https was refused: %v", err)
+	}
+	t.Setenv(EnvPlainHTTP, "")
+	via := make([]*http.Request, maxRedirects)
+	for i := range via {
+		via[i] = from
+	}
+	if err := withToken.checkRedirect(request("https://api.example/projects"), via); err == nil {
+		t.Error("an endless redirect chain was followed")
+	}
+	tokenless := New(Config{BaseURL: "https://api.example"})
+	if err := tokenless.checkRedirect(request("http://other.example/projects/"), []*http.Request{from}); err != nil {
+		t.Errorf("without a token, a redirect elsewhere was refused: %v", err)
+	}
+}
+
+// TestLinkedPagesKeepTheTokenOnTheServer: a next-page link is held to the rule
+// a redirect is, so a server cannot have the token sent on to another host.
+func TestLinkedPagesKeepTheTokenOnTheServer(t *testing.T) {
+	t.Setenv(EnvPlainHTTP, "1")
+	var elsewhere int32
+	other := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		atomic.AddInt32(&elsewhere, 1)
+		_ = json.NewEncoder(w).Encode([]map[string]any{{"@id": "p2", "@type": "Project", "name": "Two"}})
+	}))
+	defer other.Close()
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		w.Header().Set("Link", fmt.Sprintf(`<%s%s>; rel="next"`, other.URL, r.URL.RequestURI()))
+		_ = json.NewEncoder(w).Encode([]map[string]any{{"@id": "p1", "@type": "Project", "name": "One"}})
+	}))
+	defer server.Close()
+	otherHost, serverHost := strings.TrimPrefix(other.URL, "http://"), strings.TrimPrefix(server.URL, "http://")
+
+	c := New(Config{BaseURL: server.URL, Token: "secret"})
+	for name, list := range map[string]func() error{
+		"projects": func() error { _, err := c.Projects(context.Background()); return err },
+		"elements": func() error { _, err := c.Elements(context.Background(), "p", "c", 1); return err },
+	} {
+		err := list()
+		if err == nil {
+			t.Fatalf("%s: a page on another server was read with the token", name)
+		}
+		if !strings.Contains(err.Error(), otherHost) || !strings.Contains(err.Error(), serverHost) {
+			t.Errorf("%s: the refusal names neither %s nor %s: %v", name, otherHost, serverHost, err)
+		}
+		if strings.Contains(err.Error(), "secret") {
+			t.Errorf("%s: the refusal names the token: %v", name, err)
+		}
+	}
+	if n := atomic.LoadInt32(&elsewhere); n != 0 {
+		t.Errorf("the other server was asked %d time(s)", n)
+	}
+
+	tokenless := New(Config{BaseURL: server.URL})
+	if projects, err := tokenless.Projects(context.Background()); err != nil || len(projects) != 2 {
+		t.Errorf("without a token, the linked page was not followed: %d projects, %v", len(projects), err)
+	}
+}
diff --git a/internal/translate/interop/sysmlapi/commit.go b/internal/translate/interop/sysmlapi/commit.go
new file mode 100644
index 0000000000..ad258e6cbc
--- /dev/null
+++ b/internal/translate/interop/sysmlapi/commit.go
@@ -0,0 +1,116 @@
+package sysmlapi
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+// CommitRequest encodes a batch of element changes as the API's CommitRequest:
+// creates and updates send the element whole under its identity, deletes send
+// a null payload.
+func CommitRequest(changes []reposync.ElementChange, message string) ([]byte, error) {
+	versions := make([]map[string]any, 0, len(changes))
+	for _, change := range changes {
+		version := map[string]any{
+			"@type":    "DataVersion",
+			"identity": map[string]string{"@id": change.ID},
+			"payload":  nil,
+		}
+		switch change.Kind {
+		case reposync.KindDelete:
+		case reposync.KindCreate, reposync.KindUpdate:
+			content, err := payload(change)
+			if err != nil {
+				return nil, fmt.Errorf("%s %s: %w", change.Kind, change.ID, err)
+			}
+			version["payload"] = content
+		default:
+			return nil, fmt.Errorf("%s %s: the API has no commit for a %s", change.Kind, change.ID, change.Kind)
+		}
+		versions = append(versions, version)
+	}
+	request := map[string]any{"@type": "Commit", "change": versions}
+	if message != "" {
+		request["description"] = message
+	}
+	return json.Marshal(request)
+}
+
+// ErrUntyped is an element with no single sysml: metaclass, which the API's
+// payload cannot state.
+var ErrUntyped = errors.New("the element has no single SysML metaclass")
+
+// payload renders an element's content as the API's JSON: @id and @type, then
+// each sysml: property as a value or, when multi-valued, an array.
+func payload(change reposync.ElementChange) (map[string]json.RawMessage, error) {
+	out := map[string]json.RawMessage{}
+	values := map[string][]json.RawMessage{}
+	metaclass := ""
+	for _, triple := range change.Content {
+		predicate := triple.Predicate.Value
+		if predicate == rdf.RDFType {
+			name, ok := strings.CutPrefix(triple.Object.Value, rdf.SysML)
+			if !ok || !triple.Object.IsIRI() || metaclass != "" {
+				return nil, ErrUntyped
+			}
+			metaclass = name
+			continue
+		}
+		name, ok := strings.CutPrefix(predicate, rdf.SysML)
+		if !ok {
+			return nil, &UnrepresentableError{Term: triple.Predicate, Reason: "the API stores sysml: properties only"}
+		}
+		value, err := jsonValue(triple.Object)
+		if err != nil {
+			return nil, err
+		}
+		values[name] = append(values[name], value)
+	}
+	if metaclass == "" {
+		return nil, ErrUntyped
+	}
+	for name, list := range values {
+		if len(list) == 1 {
+			out[name] = list[0]
+			continue
+		}
+		array, err := json.Marshal(list)
+		if err != nil {
+			return nil, err
+		}
+		out[name] = array
+	}
+	id, err := json.Marshal(change.ID)
+	if err != nil {
+		return nil, err
+	}
+	out["@id"] = id
+	if out["@type"], err = json.Marshal(metaclass); err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// jsonValue spells one carried term as the API reads it back from JSON.
+func jsonValue(term rdf.Term) (json.RawMessage, error) {
+	carried, err := carryTerm(term)
+	if err != nil {
+		return nil, err
+	}
+	if carried.IsIRI() {
+		if carried.Value == rdfNil {
+			return json.RawMessage("null"), nil
+		}
+		return json.Marshal(map[string]string{"@id": rdf.LocalName(carried.Value)})
+	}
+	switch carried.Datatype {
+	case rdf.XSD + "boolean", rdf.XSD + "integer", rdf.XSD + "decimal":
+		return json.RawMessage(carried.Value), nil
+	}
+	return json.Marshal(carried.Value)
+}
diff --git a/internal/translate/interop/sysmlapi/commit_test.go b/internal/translate/interop/sysmlapi/commit_test.go
new file mode 100644
index 0000000000..f7daa2d56e
--- /dev/null
+++ b/internal/translate/interop/sysmlapi/commit_test.go
@@ -0,0 +1,146 @@
+package sysmlapi
+
+import (
+	"encoding/json"
+	"errors"
+	"reflect"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+func triple(subject, predicate string, object rdf.Term) rdf.Triple {
+	return rdf.Triple{Subject: rdf.IRI(subject), Predicate: rdf.IRI(predicate), Object: object}
+}
+
+func TestCommitRequestSpellsEveryChangeKind(t *testing.T) {
+	x := rdf.Element + "X1"
+	changes := []reposync.ElementChange{
+		{Kind: reposync.KindUpdate, ID: "X1", Content: []rdf.Triple{
+			triple(x, rdf.RDFType, rdf.IRI(rdf.SysML+"PartDefinition")),
+			triple(x, rdf.SysML+"declaredName", rdf.String("renamed")),
+			triple(x, rdf.SysML+"isAbstract", rdf.TypedLiteral("true", rdf.XSD+"boolean")),
+			triple(x, rdf.SysML+"ownedMember", rdf.IRI(rdf.Element+"Y1")),
+			triple(x, rdf.SysML+"ownedMember", rdf.IRI(rdf.Expression+"Y2")),
+			triple(x, rdf.SysML+"count", rdf.TypedLiteral("3", rdf.XSD+"integer")),
+			triple(x, rdf.SysML+"mass", rdf.TypedLiteral("1.5", rdf.XSD+"decimal")),
+			triple(x, rdf.SysML+"owner", rdf.IRI(rdf.RDFNS+"nil")),
+		}},
+		{Kind: reposync.KindCreate, ID: "N1", Content: []rdf.Triple{
+			triple(rdf.Element+"N1", rdf.RDFType, rdf.IRI(rdf.SysML+"Package")),
+		}},
+		{Kind: reposync.KindDelete, ID: "D1"},
+	}
+	body, err := CommitRequest(changes, "sync")
+	if err != nil {
+		t.Fatal(err)
+	}
+	var got map[string]any
+	if err := json.Unmarshal(body, &got); err != nil {
+		t.Fatal(err)
+	}
+	want := map[string]any{
+		"@type":       "Commit",
+		"description": "sync",
+		"change": []any{
+			map[string]any{
+				"@type":    "DataVersion",
+				"identity": map[string]any{"@id": "X1"},
+				"payload": map[string]any{
+					"@id":          "X1",
+					"@type":        "PartDefinition",
+					"declaredName": "renamed",
+					"isAbstract":   true,
+					"ownedMember":  []any{map[string]any{"@id": "Y1"}, map[string]any{"@id": "Y2"}},
+					"count":        float64(3),
+					"mass":         1.5,
+					"owner":        nil,
+				},
+			},
+			map[string]any{
+				"@type":    "DataVersion",
+				"identity": map[string]any{"@id": "N1"},
+				"payload":  map[string]any{"@id": "N1", "@type": "Package"},
+			},
+			map[string]any{
+				"@type":    "DataVersion",
+				"identity": map[string]any{"@id": "D1"},
+				"payload":  nil,
+			},
+		},
+	}
+	if !reflect.DeepEqual(got, want) {
+		t.Errorf("commit request:\n got %s\nwant %+v", body, want)
+	}
+}
+
+func TestCommitRequestRefusesWhatTheServiceCannotHold(t *testing.T) {
+	x := rdf.Element + "X1"
+	typed := triple(x, rdf.RDFType, rdf.IRI(rdf.SysML+"PartDefinition"))
+	cases := []struct {
+		name    string
+		content []rdf.Triple
+		want    error
+	}{
+		{"untyped", []rdf.Triple{triple(x, rdf.SysML+"declaredName", rdf.String("a"))}, ErrUntyped},
+		{"two types", []rdf.Triple{typed, triple(x, rdf.RDFType, rdf.IRI(rdf.SysML+"Package"))}, ErrUntyped},
+		{"foreign property", []rdf.Triple{typed, triple(x, "urn:opensysml:sysml:memberIndex", rdf.String("0"))}, &UnrepresentableError{}},
+		{"language tag", []rdf.Triple{typed, triple(x, rdf.SysML+"declaredName", rdf.Term{Kind: rdf.TermLiteral, Value: "a", Lang: "en"})}, &UnrepresentableError{}},
+		{"foreign IRI", []rdf.Triple{typed, triple(x, rdf.SysML+"owner", rdf.IRI("http://example.org/x"))}, &UnrepresentableError{}},
+		{"odd datatype", []rdf.Triple{typed, triple(x, rdf.SysML+"when", rdf.TypedLiteral("2020-01-01", rdf.XSD+"date"))}, &UnrepresentableError{}},
+		{"non-numeric integer", []rdf.Triple{typed, triple(x, rdf.SysML+"n", rdf.TypedLiteral("+07", rdf.XSD+"integer"))}, &UnrepresentableError{}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := CommitRequest([]reposync.ElementChange{{Kind: reposync.KindCreate, ID: "X1", Content: tc.content}}, "")
+			if err == nil {
+				t.Fatal("accepted")
+			}
+			var unrepresentable *UnrepresentableError
+			switch tc.want.(type) {
+			case *UnrepresentableError:
+				if !errors.As(err, &unrepresentable) {
+					t.Errorf("want an UnrepresentableError, got %v", err)
+				}
+			default:
+				if !errors.Is(err, tc.want) {
+					t.Errorf("want %v, got %v", tc.want, err)
+				}
+			}
+		})
+	}
+}
+
+func TestRepresentationCarriesWhatTheServiceStores(t *testing.T) {
+	x := rdf.Element + "X1"
+	rep := Representation{}
+	dropped, ok, err := rep.Carry(triple(x, "urn:opensysml:sysml:memberIndex", rdf.String("0")))
+	if err != nil || ok {
+		t.Errorf("a foreign property was carried: %+v, %v", dropped, err)
+	}
+	cases := []struct {
+		in, want rdf.Term
+	}{
+		{rdf.TypedLiteral("a", rdf.XSD+"string"), rdf.String("a")},
+		{rdf.TypedLiteral("2", rdf.XSD+"decimal"), rdf.TypedLiteral("2", rdf.XSD+"integer")},
+		{rdf.TypedLiteral("2.5", rdf.XSD+"decimal"), rdf.TypedLiteral("2.5", rdf.XSD+"decimal")},
+		{rdf.TypedLiteral("-4", rdf.XSD+"integer"), rdf.TypedLiteral("-4", rdf.XSD+"integer")},
+		{rdf.TypedLiteral("false", rdf.XSD+"boolean"), rdf.TypedLiteral("false", rdf.XSD+"boolean")},
+		{rdf.IRI(rdf.Expression + "E"), rdf.IRI(rdf.Expression + "E")},
+		{rdf.IRI(rdf.RDFNS + "nil"), rdf.IRI(rdf.RDFNS + "nil")},
+	}
+	for _, tc := range cases {
+		got, ok, err := rep.Carry(triple(x, rdf.SysML+"p", tc.in))
+		if err != nil || !ok {
+			t.Errorf("%s: not carried: %v", tc.in, err)
+			continue
+		}
+		if got.Object != tc.want {
+			t.Errorf("%s: carried as %s, want %s", tc.in, got.Object, tc.want)
+		}
+	}
+	if _, _, err := rep.Carry(triple(x, rdf.SysML+"p", rdf.TypedLiteral("1e3", rdf.XSD+"decimal"))); err == nil {
+		t.Error("a non-JSON number was carried")
+	}
+}
diff --git a/internal/translate/interop/sysmlapi/repository.go b/internal/translate/interop/sysmlapi/repository.go
new file mode 100644
index 0000000000..19112c00f3
--- /dev/null
+++ b/internal/translate/interop/sysmlapi/repository.go
@@ -0,0 +1,140 @@
+package sysmlapi
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/Open-MBEE/OpenSysML/internal/translate/export"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+// elementsPageSize is how many elements one page of a branch read asks for.
+const elementsPageSize = 500
+
+// Repository is one project branch as a sync's repository: read as the graph
+// its elements spell, written through the commit path so every element keeps
+// its id. It remembers the head its last read stood at — empty for a branch
+// read before its first commit — and refuses to commit past a head that has
+// since moved.
+type Repository struct {
+	client  *Client
+	project string
+	branch  string
+	seen    string
+	read    bool // whether seen records a head this repository read or wrote
+}
+
+// Repository addresses one project branch for a sync.
+func (c *Client) Repository(project, branch string) *Repository {
+	return &Repository{client: c, project: project, branch: branch}
+}
+
+// Client is the client the repository reads and writes through.
+func (r *Repository) Client() *Client { return r.client }
+
+// Project is the id of the project the repository is a branch of.
+func (r *Repository) Project() string { return r.project }
+
+// Branch is the id of the branch the repository reads and writes.
+func (r *Repository) Branch() string { return r.branch }
+
+// StaleBranchError is a branch whose head moved between the read a change set
+// was computed against and the commit that would have written it; nothing was
+// written, and the change set has to be recomputed against the new head.
+type StaleBranchError struct {
+	Project, Branch, Seen, Head string
+}
+
+func (e *StaleBranchError) Error() string {
+	return fmt.Sprintf("branch %s of %s moved from commit %s to %s since the change set was computed; nothing was written, so diff again against the new head",
+		e.Branch, e.Project, e.Seen, e.Head)
+}
+
+// Head is the branch's current head commit; empty for a branch no commit has
+// reached yet, as a freshly created project's is on some servers.
+func (r *Repository) Head(ctx context.Context) (string, error) {
+	branch, err := r.client.Branch(ctx, r.project, r.branch)
+	if err != nil {
+		return "", err
+	}
+	return branch.Head.ID, nil
+}
+
+// Seen is the head commit the last Graph read stood at, or the last commit
+// this repository wrote; empty before either.
+func (r *Repository) Seen() string { return r.seen }
+
+// Resume records the last-seen commit a saved sync state carries, so a head
+// that has since moved is refused instead of written past.
+func (r *Repository) Resume(commit string) { r.seen = commit }
+
+// Graph reads the branch as its head commit left it, so the read is of one
+// commit rather than of a branch that may move under it. A branch with no
+// commit yet reads as an empty graph.
+func (r *Repository) Graph(ctx context.Context) (*rdf.Graph, error) {
+	head, err := r.Head(ctx)
+	if err != nil {
+		return nil, err
+	}
+	if head == "" {
+		r.seen, r.read = "", true
+		return rdf.NewGraph(), nil
+	}
+	graph, err := r.GraphAt(ctx, head)
+	if err != nil {
+		return nil, err
+	}
+	r.seen, r.read = head, true
+	return graph, nil
+}
+
+// GraphAt reads the branch as one commit left it: its elements, paged through
+// and read as the graph their JSON spells.
+func (r *Repository) GraphAt(ctx context.Context, commit string) (*rdf.Graph, error) {
+	listing, err := r.client.Elements(ctx, r.project, commit, elementsPageSize)
+	if err != nil {
+		return nil, err
+	}
+	return ElementsGraph(listing.Elements)
+}
+
+// ElementsGraph reads a commit's elements as the RDF graph their API JSON
+// spells, the inverse of what a commit's payloads were written from.
+func ElementsGraph(elements []Element) (*rdf.Graph, error) {
+	if len(elements) == 0 {
+		return rdf.NewGraph(), nil
+	}
+	data, err := json.Marshal(elements)
+	if err != nil {
+		return nil, err
+	}
+	return export.ReadAPIJSON(data)
+}
+
+// Commit writes one batch as one SysML v2 commit. The API takes no
+// precondition, so once a head is known — read by Graph, resumed or written —
+// it is re-read first and a moved one refuses the write as a StaleBranchError;
+// a branch read without a head has to be still without one.
+func (r *Repository) Commit(ctx context.Context, changes []reposync.ElementChange, message string) (string, error) {
+	body, err := CommitRequest(changes, message)
+	if err != nil {
+		return "", err
+	}
+	if r.read || r.seen != "" {
+		head, err := r.Head(ctx)
+		if err != nil {
+			return "", err
+		}
+		if head != r.seen {
+			return "", &StaleBranchError{Project: r.project, Branch: r.branch, Seen: r.seen, Head: head}
+		}
+	}
+	commit, err := r.client.PostChanges(ctx, r.project, r.branch, body)
+	if err != nil {
+		return "", err
+	}
+	r.seen, r.read = commit.ID, true
+	return commit.ID, nil
+}
diff --git a/internal/translate/interop/sysmlapi/repository_test.go b/internal/translate/interop/sysmlapi/repository_test.go
new file mode 100644
index 0000000000..766517bcf8
--- /dev/null
+++ b/internal/translate/interop/sysmlapi/repository_test.go
@@ -0,0 +1,72 @@
+package sysmlapi
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/translate/interop/reposync"
+	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
+)
+
+// TestCommitRefusesAHeadThatAppearedSinceTheRead: a branch read before its
+// first commit is still a head the write is held to, so a first commit another
+// writer made in between refuses the change set computed against nothing.
+func TestCommitRefusesAHeadThatAppearedSinceTheRead(t *testing.T) {
+	head, posts := "", 0
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		switch {
+		case r.Method == http.MethodGet && r.URL.Path == "/projects/p/branches/b":
+			branch := map[string]any{"@id": "b", "@type": "Branch", "name": "main", "head": nil}
+			if head != "" {
+				branch["head"] = map[string]any{"@id": head, "@type": "Commit"}
+			}
+			_ = json.NewEncoder(w).Encode(branch)
+		case r.Method == http.MethodPost && r.URL.Path == "/projects/p/commits":
+			posts++
+			_ = json.NewEncoder(w).Encode(map[string]any{"@id": "c2", "@type": "Commit"})
+		default:
+			http.Error(w, r.Method+" "+r.URL.Path, http.StatusNotFound)
+		}
+	}))
+	defer server.Close()
+
+	repo := New(Config{BaseURL: server.URL}).Repository("p", "b")
+	graph, err := repo.Graph(context.Background())
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(graph.Subjects()) != 0 || repo.Seen() != "" {
+		t.Fatalf("a branch without a head read as %d subjects at commit %q", len(graph.Subjects()), repo.Seen())
+	}
+	changes := []reposync.ElementChange{{Kind: reposync.KindCreate, ID: "X1", Content: []rdf.Triple{
+		triple(rdf.Element+"X1", rdf.RDFType, rdf.IRI(rdf.SysML+"Package")),
+	}}}
+
+	head = "c1"
+	_, err = repo.Commit(context.Background(), changes, "first")
+	var stale *StaleBranchError
+	if !errors.As(err, &stale) {
+		t.Fatalf("committing onto a head that appeared since the read: %v, want a StaleBranchError", err)
+	}
+	if stale.Seen != "" || stale.Head != "c1" {
+		t.Errorf("the refusal says the head moved from %q to %q, want from none to c1", stale.Seen, stale.Head)
+	}
+	if posts != 0 {
+		t.Errorf("%d commit(s) were posted onto the moved branch", posts)
+	}
+
+	head = ""
+	if commit, err := repo.Commit(context.Background(), changes, "first"); err != nil || commit != "c2" {
+		t.Errorf("committing onto a branch still without a head: %q, %v", commit, err)
+	}
+	if posts != 1 {
+		t.Errorf("%d commit(s) posted, want 1", posts)
+	}
+	if repo.Seen() != "c2" {
+		t.Errorf("after the write the repository stands at %q, want c2", repo.Seen())
+	}
+}
diff --git a/internal/translate/interop/flexo/representation.go b/internal/translate/interop/sysmlapi/representation.go
similarity index 89%
rename from internal/translate/interop/flexo/representation.go
rename to internal/translate/interop/sysmlapi/representation.go
index 6596bbe2ac..8096b5840a 100644
--- a/internal/translate/interop/flexo/representation.go
+++ b/internal/translate/interop/sysmlapi/representation.go
@@ -1,4 +1,4 @@
-package flexo
+package sysmlapi
 
 import (
 	"fmt"
@@ -8,7 +8,7 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/translate/rdf"
 )
 
-// rdfNil is what the service stores for a JSON null.
+// rdfNil is what the server stores for a JSON null.
 const rdfNil = rdf.RDFNS + "nil"
 
 var (
@@ -16,11 +16,11 @@ var (
 	decimalLexical = regexp.MustCompile(`^-?(0|[1-9][0-9]*)\.[0-9]+$`)
 )
 
-// Representation is what the service stores of a posted graph: sysml: properties
+// Representation is what the server stores of a posted graph: sysml: properties
 // only, values as JSON spells them. A diff under it converges with an apply.
 type Representation struct{}
 
-// UnrepresentableError is a value the service's JSON commit path has no
+// UnrepresentableError is a value the server's JSON commit path has no
 // spelling for; the diff refuses it rather than approximating.
 type UnrepresentableError struct {
 	Term   rdf.Term
@@ -31,7 +31,7 @@ func (e *UnrepresentableError) Error() string {
 	return fmt.Sprintf("%s cannot be written through the SysML v2 API: %s", e.Term, e.Reason)
 }
 
-// Carry keeps sysml: properties in the form the service stores them and drops
+// Carry keeps sysml: properties in the form the server stores them and drops
 // every other predicate: it has no place for them.
 func (Representation) Carry(triple rdf.Triple) (rdf.Triple, bool, error) {
 	if !strings.HasPrefix(triple.Predicate.Value, rdf.SysML) {
diff --git a/internal/translate/migrate/migrate.go b/internal/translate/migrate/migrate.go
index d7b1351b82..6824338ed3 100644
--- a/internal/translate/migrate/migrate.go
+++ b/internal/translate/migrate/migrate.go
@@ -3031,7 +3031,7 @@ func (m *migration) connector(c *sysmlv1.Element) {
 	m.add(c, Mapped, target, note)
 	m.stereotypeComments(c)
 	for _, f := range m.flows[c] {
-		m.itemFlow(f, c.Owned("end"), paths)
+		m.itemFlow(f, c, segs, paths)
 	}
 }
 
@@ -3137,8 +3137,10 @@ func segmentWord(i, n int) string {
 
 // itemFlow writes an item flow realized by a connector as a flow between the
 // flow properties its ends carry for each conveyed classifier, from the end
-// whose role is the flow's source to the end whose role is its target.
-func (m *migration) itemFlow(f *sysmlv1.Element, ends []*sysmlv1.Element, paths []string) {
+// standing for the flow's source to the end standing for its target: the end
+// whose role is it, or, as a tool writes a flow between parts or blocks, whose
+// path names it or a part typed by it.
+func (m *migration) itemFlow(f, c *sysmlv1.Element, segs [][]*sysmlv1.Element, paths []string) {
 	conveyed := m.model.Refs(f, "conveyed")
 	missing := m.dangling(f, "conveyed")
 	if len(conveyed) == 0 {
@@ -3152,14 +3154,29 @@ func (m *migration) itemFlow(f *sysmlv1.Element, ends []*sysmlv1.Element, paths
 		return
 	}
 	from, to := paths[0], paths[1]
+	owner := c.Parent
+	forward := m.endStandsFor(segs[0], owner, src) && m.endStandsFor(segs[1], owner, dst)
+	reverse := m.endStandsFor(segs[1], owner, src) && m.endStandsFor(segs[0], owner, dst)
+	ambiguous := forward && reverse
+	if ambiguous {
+		// Both ends stand for both; only the ends' own roles can still tell them apart.
+		ends := c.Owned("end")
+		forward = m.model.Ref(ends[0], "role") == src && m.model.Ref(ends[1], "role") == dst
+		reverse = m.model.Ref(ends[1], "role") == src && m.model.Ref(ends[0], "role") == dst
+	}
 	switch {
-	case m.model.Ref(ends[0], "role") == src && m.model.Ref(ends[1], "role") == dst:
-	case m.model.Ref(ends[1], "role") == src && m.model.Ref(ends[0], "role") == dst:
+	case forward && !reverse:
+	case reverse && !forward:
 		from, to = paths[1], paths[0]
+		segs = [][]*sysmlv1.Element{segs[1], segs[0]}
+	case ambiguous:
+		m.flowDone(f, nil, []string{"the item flow's source and target each stand for both ends of realizing connector " + describe(c) + ", so its direction cannot be told"})
+		return
 	default:
-		m.flowDone(f, nil, []string{"the item flow's source and target are not the roles of the ends of realizing connector " + describe(ends[0].Parent)})
+		m.flowDone(f, nil, []string{"the item flow's source and target are not the ends of realizing connector " + describe(c) + ", nor the parts or blocks on its ends' paths"})
 		return
 	}
+	src, dst = segs[0][len(segs[0])-1], segs[1][len(segs[1])-1]
 	var written, notes []string
 	if missing != "" {
 		notes = append(notes, missing)
@@ -3182,6 +3199,22 @@ func (m *migration) itemFlow(f *sysmlv1.Element, ends []*sysmlv1.Element, paths
 	m.flowDone(f, written, notes)
 }
 
+// endStandsFor reports whether a connector end's path stands for el: its role,
+// a part on its path, or the block typing one of them, which is how a tool
+// writes an item flow between parts or between the blocks typing them; an end
+// at a port of the connector's owner stands for the owner itself.
+func (m *migration) endStandsFor(segs []*sysmlv1.Element, owner, el *sysmlv1.Element) bool {
+	if len(segs) == 1 && segs[0].Type == "Port" && owner != nil && owner == el {
+		return true
+	}
+	for _, s := range segs {
+		if s == el || m.model.Ref(s, "type") == el {
+			return true
+		}
+	}
+	return false
+}
+
 // flowDone records one realizing connector's result for f and reports the flow
 // once the last of them is in.
 func (m *migration) flowDone(f *sysmlv1.Element, written, notes []string) {
diff --git a/internal/workspace/model/allviews_test.go b/internal/workspace/model/allviews_test.go
new file mode 100644
index 0000000000..d083fbd2a4
--- /dev/null
+++ b/internal/workspace/model/allviews_test.go
@@ -0,0 +1,182 @@
+package model
+
+import (
+	"strings"
+	"testing"
+
+	"github.com/Open-MBEE/OpenSysML/internal/ir/view"
+	"github.com/Open-MBEE/OpenSysML/internal/semantic/symbols"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/parser"
+	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
+	"github.com/Open-MBEE/OpenSysML/internal/workspace/libs"
+)
+
+const geometryViewModel = `package GeomViews {
+	private import StandardViewDefinitions::*;
+	part def Widget;
+
+	view geometryView : GeometryView {
+		expose Widget;
+	}
+}
+`
+
+// The views of every document are listed together in qualified-name order, each
+// naming the document declaring it and the line it starts on.
+func TestAllViewsListsEveryDocumentsViewsInOrder(t *testing.T) {
+	ws := NewWorkspace()
+	ws.Open("kit.sysml", []byte(twoViewModel), 1)
+	ws.Open("geom.sysml", []byte(geometryViewModel), 1)
+
+	views := ws.AllViews()
+	var names []string
+	for _, info := range views {
+		names = append(names, info.Name)
+	}
+	want := []string{"GeomViews::geometryView", "KitViews::widgetTable", "KitViews::widgetTree"}
+	if strings.Join(names, ",") != strings.Join(want, ",") {
+		t.Fatalf("listed %v, want %v", names, want)
+	}
+	docs := map[string]string{"GeomViews::geometryView": "geom.sysml", "KitViews::widgetTable": "kit.sysml", "KitViews::widgetTree": "kit.sysml"}
+	lines := map[string]int{"GeomViews::geometryView": 5, "KitViews::widgetTable": 16, "KitViews::widgetTree": 12}
+	for _, info := range views {
+		if info.Doc != docs[info.Name] {
+			t.Errorf("%s: Doc = %q, want %q", info.Name, info.Doc, docs[info.Name])
+		}
+		if info.Line != lines[info.Name] {
+			t.Errorf("%s: Line = %d, want %d", info.Name, info.Line, lines[info.Name])
+		}
+		if info.Notation != info.Name {
+			t.Errorf("%s: Notation = %q, want the name unquoted names need no quoting", info.Name, info.Notation)
+		}
+	}
+}
+
+// A view of a kind this build does not produce is listed with its kind and the
+// reason, as Views lists it.
+func TestAllViewsCarriesUnsupportedReasons(t *testing.T) {
+	ws := openDoc(t, "geom.sysml", geometryViewModel)
+	views := ws.AllViews()
+	if len(views) != 1 {
+		t.Fatalf("listed %d views, want 1: %+v", len(views), views)
+	}
+	info := views[0]
+	if info.Supported || info.Kind != view.KindGeometry || !strings.Contains(info.Reason, "not supported") {
+		t.Errorf("geometry view listed as %+v, want unsupported geometry with a reason", info)
+	}
+	one, _ := ws.Views("geom.sysml")
+	if len(one) != 1 || one[0] != info {
+		t.Errorf("Views lists %+v, AllViews %+v; want the same entry", one, info)
+	}
+}
+
+// Views the library declares are not the workspace's own and are not listed.
+func TestAllViewsExcludesLibraryViews(t *testing.T) {
+	const lib = "lib/views.sysml"
+	text := []byte("package LibViews { part def Thing; view libraryView { expose Thing; } }")
+	idx := symbols.NewIndex()
+	idx.AddDocumentWithKind(lib, parser.New(source.New(lib, text)).ParseFile(), source.KindSysML)
+	idx.MarkLibraryDocument(lib, symbols.LibraryDocument{Tier: symbols.TierLibrary, Digest: symbols.TextDigest(text)})
+	idx.ExpandWildcardImports()
+	if len(DeclaredViews(idx.DocumentRoot(lib))) == 0 {
+		t.Fatal("the library declares no view, so the test proves nothing")
+	}
+	ws := NewWorkspaceWithIndex(idx)
+	ws.Open("own.sysml", []byte("package Own { part def P; view ownView { expose P; } }"), 1)
+
+	views := ws.AllViews()
+	if len(views) != 1 || views[0].Name != "Own::ownView" || views[0].Doc != "own.sysml" {
+		t.Errorf("listed %+v, want Own::ownView of own.sysml alone", views)
+	}
+}
+
+// A name needing quotes is written as the notation writes it, each segment
+// quoted on its own, so a segment holding `::` reads back whole.
+func TestAllViewsNotationQuotesSegments(t *testing.T) {
+	ws := openDoc(t, "q.sysml", `package 'My Pkg' {
+	part def W;
+	view 'a::b view' { expose W; }
+	view 'line\nbreak' { expose W; }
+}
+`)
+	got := map[string]bool{}
+	for _, info := range ws.AllViews() {
+		got[info.Notation] = true
+	}
+	for _, want := range []string{`'My Pkg'::'a::b view'`, `'My Pkg'::'line\nbreak'`} {
+		if !got[want] {
+			t.Errorf("no view listed as %s: %v", want, got)
+		}
+	}
+}
+
+// Document definitions carry the notation name and the line they start on.
+func TestDocumentDefinitionsLocateAndQuote(t *testing.T) {
+	ws := openDoc(t, "d.sysml", `package 'My Pkg' {
+	private import DocumentQueries::*;
+
+	part def 'Report "A"' :> Document {
+		attribute redefines title = "A";
+	}
+}
+`)
+	defs := ws.DocumentDefinitions()
+	if len(defs) != 1 {
+		t.Fatalf("listed %+v, want one document", defs)
+	}
+	if defs[0].Notation != `'My Pkg'::'Report "A"'` || defs[0].Line != 4 || defs[0].Doc != "d.sysml" {
+		t.Errorf("document listed as %+v", defs[0])
+	}
+}
+
+const renderedViewModel = `package Rendered {
+	part def W { part p : W; }
+
+	view asText { expose W; render Views::asTextualNotation; }
+	view asWiring { expose W; render Views::asInterconnectionDiagram; }
+	view asTable { expose W; render Views::asElementTable; }
+}
+`
+
+// A document held as its record lists the kinds its views' render members state,
+// as the parsed document does: the listing reads the bodies, so it hydrates.
+func TestAllViewsReadsRecordedDocumentsKinds(t *testing.T) {
+	cache, err := libs.NewCacheIn(t.TempDir())
+	if err != nil {
+		t.Fatal(err)
+	}
+	inputs := []Input{{Name: "rendered.sysml", Content: []byte(renderedViewModel), Version: 1}}
+	cold := NewWorkspace(WithRecordCache(cache))
+	cold.OpenAll(inputs)
+	cold.DiagnosticsAll([]string{"rendered.sysml"})
+	want := cold.AllViews()
+
+	for _, list := range []func(*Workspace) []ViewInfo{
+		(*Workspace).AllViews,
+		func(w *Workspace) []ViewInfo { views, _ := w.Views("rendered.sysml"); return views },
+	} {
+		warm := NewWorkspace(WithRecordCache(cache))
+		warm.OpenAll(inputs)
+		if !warm.Recorded("rendered.sysml") {
+			t.Fatal("rendered.sysml is not recorded on a warm cache: the test proves nothing")
+		}
+		got := list(warm)
+		if len(got) != len(want) {
+			t.Fatalf("warm listing %+v, cold %+v", got, want)
+		}
+		for i := range got {
+			if got[i].Name != want[i].Name || got[i].Kind != want[i].Kind || got[i].Line != want[i].Line {
+				t.Errorf("warm listing %+v, cold %+v", got[i], want[i])
+			}
+		}
+	}
+	kinds := []view.Kind{view.KindTable, view.KindTextual, view.KindInterconnection}
+	if len(want) != len(kinds) {
+		t.Fatalf("cold listing %+v, want %v", want, kinds)
+	}
+	for i, kind := range kinds {
+		if want[i].Kind != kind {
+			t.Errorf("cold listing %+v, want kinds %v", want, kinds)
+		}
+	}
+}
diff --git a/internal/workspace/model/docquery.go b/internal/workspace/model/docquery.go
index 06613da11e..bb41bbcffc 100644
--- a/internal/workspace/model/docquery.go
+++ b/internal/workspace/model/docquery.go
@@ -13,9 +13,13 @@ import (
 
 // DocumentDefinition is one native document definition the workspace holds: a
 // part def specializing DocumentQueries::Document, and the file declaring it.
+// Notation is the qualified name as the notation writes it, and Line the 1-based
+// line the declaration starts on.
 type DocumentDefinition struct {
-	FQN string
-	Doc string
+	FQN      string
+	Notation string
+	Doc      string
+	Line     int
 }
 
 // DocumentDefinitions lists the document definitions declared across the
@@ -24,16 +28,26 @@ func (w *Workspace) DocumentDefinitions() []DocumentDefinition {
 	w.mu.Lock()
 	defer w.mu.Unlock()
 	out := []DocumentDefinition{}
-	for name := range w.docs {
+	for name, d := range w.docs {
 		w.queryLocked(name, func(_ *resolve.Resolver, sem *semantics.Model) {
 			walkScope(w.index.DocumentRoot(name), func(sym *symbols.Symbol) {
 				if docplan.IsDocumentDefinition(w.index, sem, sym) {
-					out = append(out, DocumentDefinition{FQN: notationFQN(w.index, sym), Doc: name})
+					out = append(out, DocumentDefinition{
+						FQN:      notationFQN(w.index, sym),
+						Notation: notationName(sym),
+						Doc:      name,
+						Line:     declarationLine(d, declarationOrigin(d, sym)),
+					})
 				}
 			})
 		})
 	}
-	sort.Slice(out, func(i, j int) bool { return out[i].FQN < out[j].FQN })
+	sort.Slice(out, func(i, j int) bool {
+		if out[i].FQN != out[j].FQN {
+			return out[i].FQN < out[j].FQN
+		}
+		return out[i].Doc < out[j].Doc
+	})
 	return out
 }
 
diff --git a/internal/workspace/model/render.go b/internal/workspace/model/render.go
index 99e2940667..1c88a7398c 100644
--- a/internal/workspace/model/render.go
+++ b/internal/workspace/model/render.go
@@ -25,12 +25,17 @@ var ErrNoView = errors.New("declares no view")
 // kind it states, whether this implementation produces that kind, and why not
 // when it does not. Origin is where the view is declared, so a client can tell
 // which view a cursor is in; the zero Origin for a view without a declaration.
+// Doc is the declaring document, Line the 1-based line the declaration starts
+// on, and Notation the qualified name as the notation writes it.
 type ViewInfo struct {
 	Name      string
+	Notation  string
 	Kind      view.Kind
 	Supported bool
 	Reason    string
 	Origin    view.Origin
+	Doc       string
+	Line      int
 }
 
 // Views lists the views a document declares, in qualified-name order, each with
@@ -45,11 +50,47 @@ func (w *Workspace) Views(doc string) ([]ViewInfo, *Document) {
 	if d == nil {
 		return nil, nil
 	}
+	if d.Recorded() {
+		d = w.hydrateLocked(doc)
+		w.index.ExpandWildcardImports()
+		w.invalidateLocked(doc)
+	}
+	out := w.viewInfosLocked(d)
+	sortViewInfos(out)
+	return out, d
+}
+
+// AllViews lists the views declared across the workspace's own documents, in
+// qualified-name order, as Views lists each document's; a library's views are
+// not among them.
+func (w *Workspace) AllViews() []ViewInfo {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.hydrateAllLocked()
 	out := []ViewInfo{}
-	w.queryLocked(doc, func(*resolve.Resolver, *semantics.Model) {
-		renderer := w.rendererLocked(doc)
-		for _, sym := range w.documentViewsLocked(doc) {
-			info := ViewInfo{Name: notationFQN(w.index, sym), Supported: true, Origin: declarationOrigin(d, sym)}
+	for _, d := range w.docs {
+		out = append(out, w.viewInfosLocked(d)...)
+	}
+	sortViewInfos(out)
+	return out
+}
+
+// viewInfosLocked is the views d declares, each with the kind its renderer
+// reads and, for a kind not produced, the reason.
+func (w *Workspace) viewInfosLocked(d *Document) []ViewInfo {
+	out := []ViewInfo{}
+	w.queryLocked(d.Name, func(*resolve.Resolver, *semantics.Model) {
+		renderer := w.rendererLocked(d.Name)
+		for _, sym := range w.documentViewsLocked(d.Name) {
+			origin := declarationOrigin(d, sym)
+			info := ViewInfo{
+				Name:      notationFQN(w.index, sym),
+				Notation:  notationName(sym),
+				Supported: true,
+				Origin:    origin,
+				Doc:       d.Name,
+				Line:      declarationLine(d, origin),
+			}
 			kind, _, err := renderer.KindOf(sym)
 			switch {
 			case err == nil:
@@ -65,8 +106,32 @@ func (w *Workspace) Views(doc string) ([]ViewInfo, *Document) {
 			out = append(out, info)
 		}
 	})
-	sort.SliceStable(out, func(i, j int) bool { return out[i].Name < out[j].Name })
-	return out, d
+	return out
+}
+
+// sortViewInfos orders views by qualified name, then by declaring document.
+func sortViewInfos(views []ViewInfo) {
+	sort.SliceStable(views, func(i, j int) bool {
+		if views[i].Name != views[j].Name {
+			return views[i].Name < views[j].Name
+		}
+		return views[i].Doc < views[j].Doc
+	})
+}
+
+// notationName is sym's qualified name as the notation writes it, each segment
+// quoted on its own, so a name holding `::`, spaces or escapes reads back whole.
+func notationName(sym *symbols.Symbol) string {
+	return source.QualifiedNameOf(symbols.NameChain(sym))
+}
+
+// declarationLine is the 1-based line origin starts on in doc; 0 for an origin
+// located elsewhere or nowhere.
+func declarationLine(doc *Document, origin view.Origin) int {
+	if !origin.Located() || origin.Doc != doc.Name || origin.Span.Offset > len(doc.Content) {
+		return 0
+	}
+	return doc.Lines().PosAt(origin.Span.Offset).Line
 }
 
 // declarationOrigin locates a symbol's declaration, trimmed of the trailing
diff --git a/internal/workspace/notebook/notebook.go b/internal/workspace/notebook/notebook.go
new file mode 100644
index 0000000000..f5a3dad518
--- /dev/null
+++ b/internal/workspace/notebook/notebook.go
@@ -0,0 +1,185 @@
+// Package notebook reads the code cells of a Jupyter notebook (nbformat 4), so a
+// model written in a notebook can be loaded where a model file can.
+package notebook
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Ext is the file extension a notebook is named with.
+const Ext = ".ipynb"
+
+// SkipTag marks a code cell a load passes over: scratch work, a demonstration,
+// anything the notebook runs that another should not inherit.
+const SkipTag = "skip-load"
+
+// Language is the kernelspec language a notebook must record to be loaded as a
+// SysML model; a notebook recording none is taken to be one.
+const Language = "sysml"
+
+// IsNotebook reports whether path names a notebook, by its extension.
+func IsNotebook(path string) bool {
+	return strings.EqualFold(filepath.Ext(path), Ext)
+}
+
+// Cell is one code cell of a notebook.
+type Cell struct {
+	// Index is the cell's 1-based position among the notebook's code cells,
+	// which is how a selection names it and how a diagnostic locates it.
+	Index  int
+	Source string
+	Tags   []string
+}
+
+// Tagged reports whether the cell carries tag in its metadata.
+func (c Cell) Tagged(tag string) bool {
+	for _, t := range c.Tags {
+		if t == tag {
+			return true
+		}
+	}
+	return false
+}
+
+// Notebook is what a load reads of a notebook: its code cells in notebook
+// order, markdown and raw cells left out, and the language its kernel records.
+type Notebook struct {
+	Name     string
+	Language string // kernelspec.language, else language_info.name; "" when neither is recorded
+	Cells    []Cell
+}
+
+// Read reads the notebook at path. The error is a *FormatError for a file that
+// is not an nbformat 4 notebook, or the read error.
+func Read(path string) (*Notebook, error) {
+	// #nosec G304 -- the file is one the user named, or one found under a
+	// directory or pattern they named.
+	data, err := os.ReadFile(path)
+	if err != nil {
+		return nil, err
+	}
+	return Parse(path, data)
+}
+
+// FormatError is a file that is not a notebook a load can read, and why.
+type FormatError struct {
+	Name   string
+	Reason string
+}
+
+func (e *FormatError) Error() string {
+	return fmt.Sprintf("cannot load %s: %s", e.Name, e.Reason)
+}
+
+// LanguageError is a notebook written for another kernel's language, which a
+// load refuses rather than reading its cells as SysML.
+type LanguageError struct {
+	Name     string
+	Language string
+}
+
+func (e *LanguageError) Error() string {
+	return fmt.Sprintf("cannot load %s: a %s notebook; only a notebook whose kernel language is %s (or that records none) loads as a model",
+		e.Name, e.Language, Language)
+}
+
+// rawNotebook is the nbformat JSON a load reads: the format version, the kernel
+// language and the cells, each with its type, source and tags.
+type rawNotebook struct {
+	NBFormat *int `json:"nbformat"`
+	Metadata struct {
+		Kernelspec struct {
+			Language string `json:"language"`
+		} `json:"kernelspec"`
+		LanguageInfo struct {
+			Name string `json:"name"`
+		} `json:"language_info"`
+	} `json:"metadata"`
+	Cells *[]struct {
+		Type     string     `json:"cell_type"`
+		Source   cellSource `json:"source"`
+		Metadata struct {
+			Tags []string `json:"tags"`
+		} `json:"metadata"`
+	} `json:"cells"`
+}
+
+// cellSource is a cell's text, which nbformat writes as one string or as a
+// list of lines that keep their newlines.
+type cellSource string
+
+func (s *cellSource) UnmarshalJSON(data []byte) error {
+	var whole string
+	if err := json.Unmarshal(data, &whole); err == nil {
+		*s = cellSource(whole)
+		return nil
+	}
+	var lines []string
+	if err := json.Unmarshal(data, &lines); err != nil {
+		return errors.New("a cell's source must be a string or a list of strings")
+	}
+	*s = cellSource(strings.Join(lines, ""))
+	return nil
+}
+
+// Parse reads data as the nbformat 4 notebook called name. A notebook of
+// another format version, or a file that is not a notebook at all, is a
+// *FormatError; one written for another language is a *LanguageError.
+func Parse(name string, data []byte) (*Notebook, error) {
+	var raw rawNotebook
+	dec := json.NewDecoder(bytes.NewReader(data))
+	if err := dec.Decode(&raw); err != nil {
+		return nil, &FormatError{Name: name, Reason: "not a notebook: " + jsonReason(err)}
+	}
+	if err := dec.Decode(new(json.RawMessage)); err != io.EOF {
+		return nil, &FormatError{Name: name, Reason: "not a notebook: text follows the notebook object"}
+	}
+	if raw.NBFormat == nil {
+		return nil, &FormatError{Name: name, Reason: "not a notebook: no nbformat version"}
+	}
+	if *raw.NBFormat != 4 {
+		return nil, &FormatError{Name: name, Reason: fmt.Sprintf("nbformat %d is not read; save the notebook as nbformat 4", *raw.NBFormat)}
+	}
+	if raw.Cells == nil {
+		return nil, &FormatError{Name: name, Reason: "not a notebook: no cells"}
+	}
+	nb := &Notebook{Name: name, Language: raw.Metadata.Kernelspec.Language}
+	if nb.Language == "" {
+		nb.Language = raw.Metadata.LanguageInfo.Name
+	}
+	if nb.Language != "" && !strings.EqualFold(nb.Language, Language) {
+		return nil, &LanguageError{Name: name, Language: nb.Language}
+	}
+	for _, cell := range *raw.Cells {
+		if cell.Type != "code" {
+			continue
+		}
+		nb.Cells = append(nb.Cells, Cell{
+			Index:  len(nb.Cells) + 1,
+			Source: string(cell.Source),
+			Tags:   cell.Metadata.Tags,
+		})
+	}
+	return nb, nil
+}
+
+// jsonReason is a JSON error as a reader of the notebook needs it, without the
+// Go type names the decoder puts in it.
+func jsonReason(err error) string {
+	var syntax *json.SyntaxError
+	if errors.As(err, &syntax) {
+		return fmt.Sprintf("invalid JSON at byte %d: %s", syntax.Offset, syntax.Error())
+	}
+	var kind *json.UnmarshalTypeError
+	if errors.As(err, &kind) {
+		return fmt.Sprintf("%s is not %s", kind.Field, kind.Value)
+	}
+	return err.Error()
+}
diff --git a/internal/workspace/notebook/notebook_test.go b/internal/workspace/notebook/notebook_test.go
new file mode 100644
index 0000000000..fd3e860b8e
--- /dev/null
+++ b/internal/workspace/notebook/notebook_test.go
@@ -0,0 +1,221 @@
+package notebook
+
+import (
+	"errors"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func fixture(name string) string {
+	return filepath.Join("..", "..", "..", "tests", "testdata", "notebooks", name)
+}
+
+func mustRead(t *testing.T, name string) *Notebook {
+	t.Helper()
+	nb, err := Read(fixture(name))
+	if err != nil {
+		t.Fatalf("Read(%s): %v", name, err)
+	}
+	return nb
+}
+
+func TestReadKeepsCodeCellsInOrderAndDropsTheRest(t *testing.T) {
+	nb := mustRead(t, "plain.ipynb")
+	if nb.Language != "sysml" {
+		t.Errorf("Language = %q, want sysml", nb.Language)
+	}
+	if len(nb.Cells) != 2 {
+		t.Fatalf("got %d cells, want the 2 code cells: %+v", len(nb.Cells), nb.Cells)
+	}
+	if nb.Cells[0].Index != 1 || nb.Cells[1].Index != 2 {
+		t.Errorf("cells are numbered %d, %d; want 1, 2", nb.Cells[0].Index, nb.Cells[1].Index)
+	}
+	// A source written as a list of lines reads as the one text they join to.
+	if want := "package Wheels {\n  private import ScalarValues::*;\n  part def Wheel { attribute diameter : Real = 16.0; }\n}\n"; nb.Cells[0].Source != want {
+		t.Errorf("cell 1 source = %q, want %q", nb.Cells[0].Source, want)
+	}
+	if !strings.HasPrefix(nb.Cells[1].Source, "package Cars {") {
+		t.Errorf("cell 2 source = %q, want the Cars package", nb.Cells[1].Source)
+	}
+}
+
+func TestReadKeepsTheCellTags(t *testing.T) {
+	nb := mustRead(t, "tagged.ipynb")
+	if len(nb.Cells) != 4 {
+		t.Fatalf("got %d cells, want 4", len(nb.Cells))
+	}
+	if !nb.Cells[0].Tagged("model") || nb.Cells[0].Tagged(SkipTag) {
+		t.Errorf("cell 1 tags = %v, want model only", nb.Cells[0].Tags)
+	}
+	if !nb.Cells[1].Tagged(SkipTag) {
+		t.Errorf("cell 2 tags = %v, want %s", nb.Cells[1].Tags, SkipTag)
+	}
+	if !nb.Cells[2].Tagged("model") || !nb.Cells[2].Tagged("extra") {
+		t.Errorf("cell 3 tags = %v, want model and extra", nb.Cells[2].Tags)
+	}
+	if len(nb.Cells[3].Tags) != 0 {
+		t.Errorf("cell 4 tags = %v, want none", nb.Cells[3].Tags)
+	}
+}
+
+func TestANotebookRecordingNoLanguageLoads(t *testing.T) {
+	nb := mustRead(t, "nolanguage.ipynb")
+	if nb.Language != "" || len(nb.Cells) != 1 {
+		t.Errorf("notebook = %+v, want no language and one cell", nb)
+	}
+}
+
+func TestAPythonNotebookIsRefused(t *testing.T) {
+	_, err := Read(fixture("python.ipynb"))
+	var lang *LanguageError
+	if !errors.As(err, &lang) {
+		t.Fatalf("err = %v, want a *LanguageError", err)
+	}
+	if lang.Language != "python" || !strings.Contains(err.Error(), "a python notebook") {
+		t.Errorf("err = %v, want it to name the python language", err)
+	}
+}
+
+func TestAnNBFormat3NotebookIsRefused(t *testing.T) {
+	_, err := Read(fixture("nbformat3.ipynb"))
+	var format *FormatError
+	if !errors.As(err, &format) {
+		t.Fatalf("err = %v, want a *FormatError", err)
+	}
+	if !strings.Contains(err.Error(), "nbformat 3") || !strings.Contains(err.Error(), "nbformat 4") {
+		t.Errorf("err = %v, want it to name both format versions", err)
+	}
+}
+
+func TestAMalformedNotebookIsRefused(t *testing.T) {
+	_, err := Read(fixture("malformed.ipynb"))
+	var format *FormatError
+	if !errors.As(err, &format) {
+		t.Fatalf("err = %v, want a *FormatError", err)
+	}
+	if !strings.Contains(err.Error(), "malformed.ipynb") || !strings.Contains(err.Error(), "not a notebook") {
+		t.Errorf("err = %v, want it to name the file and say it is not a notebook", err)
+	}
+}
+
+func TestParseRefusesJSONThatIsNoNotebook(t *testing.T) {
+	for _, tt := range []struct{ name, json, want string }{
+		{"no nbformat", `{"cells": []}`, "no nbformat version"},
+		{"no cells", `{"nbformat": 4}`, "no cells"},
+		{"cells not a list", `{"nbformat": 4, "cells": 3}`, "not a notebook"},
+		{"source of the wrong type", `{"nbformat": 4, "cells": [{"cell_type": "code", "source": 3}]}`, "a cell's source must be a string or a list of strings"},
+		{"text after the notebook", `{"nbformat": 4, "cells": [{"cell_type": "code", "source": "package P {}"}]} trailing`, "text follows the notebook object"},
+		{"a second notebook after the first", `{"nbformat": 4, "cells": []} {"nbformat": 4, "cells": []}`, "text follows the notebook object"},
+	} {
+		t.Run(tt.name, func(t *testing.T) {
+			_, err := Parse("x.ipynb", []byte(tt.json))
+			if err == nil || !strings.Contains(err.Error(), tt.want) {
+				t.Errorf("Parse(%s) = %v, want an error mentioning %q", tt.json, err, tt.want)
+			}
+		})
+	}
+}
+
+func TestAMissingNotebookIsAReadError(t *testing.T) {
+	_, err := Read(fixture("nowhere.ipynb"))
+	var format *FormatError
+	if err == nil || errors.As(err, &format) {
+		t.Fatalf("err = %v, want the read error itself", err)
+	}
+}
+
+func TestIsNotebook(t *testing.T) {
+	for path, want := range map[string]bool{"a.ipynb": true, "dir/B.IPYNB": true, "a.sysml": false, "a.ipynb.bak": false, "ipynb": false} {
+		if got := IsNotebook(path); got != want {
+			t.Errorf("IsNotebook(%q) = %v, want %v", path, got, want)
+		}
+	}
+}
+
+func TestSelectionByPosition(t *testing.T) {
+	nb := mustRead(t, "tagged.ipynb")
+	sel, err := ParseSelection("1,3-4")
+	if err != nil {
+		t.Fatal(err)
+	}
+	if sel.String() != "1,3-4" {
+		t.Errorf("String() = %q", sel.String())
+	}
+	cells, err := sel.Apply(nb)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(cells) != 3 || cells[0].Index != 1 || cells[1].Index != 3 || cells[2].Index != 4 {
+		t.Errorf("selected %+v, want cells 1, 3 and 4", cells)
+	}
+}
+
+func TestSelectionByPositionIsInNotebookOrderWithoutRepeats(t *testing.T) {
+	nb := mustRead(t, "tagged.ipynb")
+	sel, err := ParseSelection("3,1-2,2")
+	if err != nil {
+		t.Fatal(err)
+	}
+	cells, err := sel.Apply(nb)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(cells) != 3 || cells[0].Index != 1 || cells[1].Index != 2 || cells[2].Index != 3 {
+		t.Errorf("selected %+v, want cells 1, 2 and 3 once each", cells)
+	}
+}
+
+func TestSelectionOutOfRangeNamesTheCellCount(t *testing.T) {
+	nb := mustRead(t, "tagged.ipynb")
+	sel, err := ParseSelection("2,6")
+	if err != nil {
+		t.Fatal(err)
+	}
+	_, err = sel.Apply(nb)
+	if err == nil || !strings.Contains(err.Error(), "4 code cells") || !strings.Contains(err.Error(), "tagged.ipynb") {
+		t.Errorf("err = %v, want the notebook and its 4 code cells named", err)
+	}
+	one := &Notebook{Name: "one.ipynb", Cells: []Cell{{Index: 1}}}
+	if _, err := sel.Apply(one); err == nil || !strings.Contains(err.Error(), "has 1 code cell") {
+		t.Errorf("err = %v, want the single cell counted", err)
+	}
+}
+
+func TestSelectionByTag(t *testing.T) {
+	nb := mustRead(t, "tagged.ipynb")
+	sel, err := ParseSelection("tag:model")
+	if err != nil {
+		t.Fatal(err)
+	}
+	cells, err := sel.Apply(nb)
+	if err != nil {
+		t.Fatal(err)
+	}
+	if len(cells) != 2 || cells[0].Index != 1 || cells[1].Index != 3 {
+		t.Errorf("selected %+v, want cells 1 and 3", cells)
+	}
+	missing, _ := ParseSelection("tag:nowhere")
+	if _, err := missing.Apply(nb); err == nil || !strings.Contains(err.Error(), "no code cell is tagged nowhere") {
+		t.Errorf("err = %v, want the missing tag named", err)
+	}
+}
+
+func TestTheZeroSelectionPicksEveryCell(t *testing.T) {
+	nb := mustRead(t, "tagged.ipynb")
+	cells, err := Selection{}.Apply(nb)
+	if err != nil || len(cells) != 4 {
+		t.Errorf("Apply = %v, %v; want all 4 cells", cells, err)
+	}
+	if !(Selection{}).IsZero() {
+		t.Error("the zero Selection is not IsZero")
+	}
+}
+
+func TestParseSelectionRefusesWhatIsNotOne(t *testing.T) {
+	for _, text := range []string{"", "0", "a", "3-1", "1,,2", "tag:", "1-", "-2"} {
+		if _, err := ParseSelection(text); err == nil {
+			t.Errorf("ParseSelection(%q) accepted", text)
+		}
+	}
+}
diff --git a/internal/workspace/notebook/selection.go b/internal/workspace/notebook/selection.go
new file mode 100644
index 0000000000..7912e19681
--- /dev/null
+++ b/internal/workspace/notebook/selection.go
@@ -0,0 +1,133 @@
+package notebook
+
+import (
+	"errors"
+	"fmt"
+	"strconv"
+	"strings"
+)
+
+// Selection picks the code cells of a notebook a load reads: by position among
+// the code cells, 1-based, as `1,3-5`, or by a tag they carry, as `tag:model`.
+// The zero Selection picks every cell.
+type Selection struct {
+	ranges []cellRange
+	tag    string
+}
+
+type cellRange struct{ from, to int }
+
+// ParseSelection reads a selection as it is written after `--cells`.
+func ParseSelection(text string) (Selection, error) {
+	text = strings.TrimSpace(text)
+	if text == "" {
+		return Selection{}, errors.New("a selection names cells by position (1,3-5) or by tag (tag:<tag>)")
+	}
+	if tag, ok := strings.CutPrefix(text, "tag:"); ok {
+		if tag == "" {
+			return Selection{}, errors.New("tag: names the tag the cells carry")
+		}
+		return Selection{tag: tag}, nil
+	}
+	var sel Selection
+	for _, part := range strings.Split(text, ",") {
+		r, err := parseRange(strings.TrimSpace(part))
+		if err != nil {
+			return Selection{}, err
+		}
+		sel.ranges = append(sel.ranges, r)
+	}
+	return sel, nil
+}
+
+// parseRange reads one position or one from-to span of positions.
+func parseRange(part string) (cellRange, error) {
+	from, to, spanned := strings.Cut(part, "-")
+	lo, err := parsePosition(from)
+	if err != nil {
+		return cellRange{}, err
+	}
+	if !spanned {
+		return cellRange{from: lo, to: lo}, nil
+	}
+	hi, err := parsePosition(to)
+	if err != nil {
+		return cellRange{}, err
+	}
+	if hi < lo {
+		return cellRange{}, fmt.Errorf("cells %d-%d: the range runs backwards", lo, hi)
+	}
+	return cellRange{from: lo, to: hi}, nil
+}
+
+func parsePosition(text string) (int, error) {
+	n, err := strconv.Atoi(strings.TrimSpace(text))
+	if err != nil || n < 1 {
+		return 0, fmt.Errorf("%q is not a cell position; cells are counted from 1 among the notebook's code cells", text)
+	}
+	return n, nil
+}
+
+// IsZero reports whether the selection picks every cell.
+func (s Selection) IsZero() bool { return len(s.ranges) == 0 && s.tag == "" }
+
+// String is the selection as it was written.
+func (s Selection) String() string {
+	if s.tag != "" {
+		return "tag:" + s.tag
+	}
+	parts := make([]string, 0, len(s.ranges))
+	for _, r := range s.ranges {
+		if r.from == r.to {
+			parts = append(parts, strconv.Itoa(r.from))
+		} else {
+			parts = append(parts, fmt.Sprintf("%d-%d", r.from, r.to))
+		}
+	}
+	return strings.Join(parts, ",")
+}
+
+// Apply picks the notebook's cells the selection names, in notebook order. A
+// position past the notebook's code cells is an error naming how many there
+// are; a tag no cell carries is an error naming the tag.
+func (s Selection) Apply(nb *Notebook) ([]Cell, error) {
+	if s.IsZero() {
+		return nb.Cells, nil
+	}
+	if s.tag != "" {
+		var out []Cell
+		for _, c := range nb.Cells {
+			if c.Tagged(s.tag) {
+				out = append(out, c)
+			}
+		}
+		if len(out) == 0 {
+			return nil, fmt.Errorf("%s: no code cell is tagged %s", nb.Name, s.tag)
+		}
+		return out, nil
+	}
+	picked := make([]bool, len(nb.Cells)+1)
+	for _, r := range s.ranges {
+		if r.to > len(nb.Cells) {
+			return nil, fmt.Errorf("%s: cells %s selected, but the notebook has %s", nb.Name, s, countCells(len(nb.Cells)))
+		}
+		for i := r.from; i <= r.to; i++ {
+			picked[i] = true
+		}
+	}
+	var out []Cell
+	for _, c := range nb.Cells {
+		if picked[c.Index] {
+			out = append(out, c)
+		}
+	}
+	return out, nil
+}
+
+// countCells spells a code-cell count.
+func countCells(n int) string {
+	if n == 1 {
+		return "1 code cell"
+	}
+	return fmt.Sprintf("%d code cells", n)
+}
diff --git a/internal/workspace/project/deps.go b/internal/workspace/project/deps.go
index c2a7c88296..59ce8372c1 100644
--- a/internal/workspace/project/deps.go
+++ b/internal/workspace/project/deps.go
@@ -11,6 +11,14 @@ import (
 	"github.com/Open-MBEE/OpenSysML/internal/syntax/source"
 )
 
+// Source is a loaded source as the dependency search sees it: the path it was
+// read from, which locates the directories searched, and its model text. The
+// cells of a notebook are Sources sharing the notebook's path.
+type Source struct {
+	Path    string
+	Content []byte
+}
+
 // Dependencies returns the model files, beside or below the named ones, that
 // declare a root namespace an import of the named files begins with and none of
 // them declares, then the files those imports lead to in turn. known reports
@@ -19,24 +27,41 @@ import (
 // is standard input contributes nothing; the loader reports the former. The
 // result is ordered as it was found and holds no file already named.
 func Dependencies(files []string, known func(name string) bool) []string {
+	sources := make([]Source, 0, len(files))
+	for _, file := range files {
+		if IsStdin(file) {
+			continue
+		}
+		// #nosec G304 -- the file is one the user named, or one found under its directory.
+		content, err := os.ReadFile(file)
+		if err != nil {
+			continue
+		}
+		sources = append(sources, Source{Path: file, Content: content})
+	}
+	return DependenciesOf(sources, known)
+}
+
+// DependenciesOf is Dependencies over sources already read, so a notebook's
+// cells, or a file converted from another notation, are searched from as the
+// model text they load as. Standard input contributes nothing.
+func DependenciesOf(sources []Source, known func(name string) bool) []string {
 	loaded := map[string]bool{}
 	declared := map[string]bool{}
 	wanted := map[string]bool{}
 	var dirs []string
 	seenDir := map[string]bool{}
-	for _, file := range files {
-		if IsStdin(file) {
+	for _, src := range sources {
+		if IsStdin(src.Path) {
 			continue
 		}
-		loaded[absKey(file)] = true
-		dir := filepath.Dir(file)
+		loaded[absKey(src.Path)] = true
+		dir := filepath.Dir(src.Path)
 		if key := absKey(dir); !seenDir[key] {
 			seenDir[key] = true
 			dirs = append(dirs, dir)
 		}
-		if summary, ok := summarize(file); ok {
-			summary.contribute(declared, wanted)
-		}
+		summarizeContent(src.Path, src.Content).contribute(declared, wanted)
 	}
 	prune(wanted, declared, known)
 	if len(wanted) == 0 {
@@ -103,11 +128,16 @@ func summarize(path string) (*fileSummary, bool) {
 	if err != nil {
 		return nil, false
 	}
+	return summarizeContent(path, content), true
+}
+
+// summarizeContent parses model text read from path into its summary.
+func summarizeContent(path string, content []byte) *fileSummary {
 	root := parser.New(source.New(path, content)).ParseFile()
 	f := &fileSummary{path: path}
 	f.roots = declaredNames(root.Members)
 	f.collect(root.Members, nil)
-	return f, true
+	return f
 }
 
 // declaredNames lists the names the members of one namespace declare.
diff --git a/internal/workspace/project/project.go b/internal/workspace/project/project.go
index 10828d67d7..9d3020a5b1 100644
--- a/internal/workspace/project/project.go
+++ b/internal/workspace/project/project.go
@@ -10,6 +10,8 @@ import (
 	"path/filepath"
 	"sort"
 	"strings"
+
+	"github.com/Open-MBEE/OpenSysML/internal/workspace/notebook"
 )
 
 // Stdin is the path that names standard input, by the convention that a lone
@@ -37,10 +39,16 @@ func IsModelFile(path string) bool {
 	return false
 }
 
+// IsLoadable reports whether path names a source a load reads: a model file or
+// a notebook, whose code cells are the model.
+func IsLoadable(path string) bool {
+	return IsModelFile(path) || notebook.IsNotebook(path)
+}
+
 // Expand turns the paths named on a command line (or at a %load prompt) into
-// the model files to load: a directory contributes every model file under it,
-// a pattern contributes the model files among its matches, and any other path
-// is taken as named.
+// the sources to load: a directory contributes every model file and notebook
+// under it, a pattern contributes the model files and notebooks among its
+// matches, and any other path is taken as named.
 // Files come back in a deterministic order — the inputs in the order given,
 // each directory walk and each pattern match sorted by path — and duplicates
 // are dropped, so naming a file twice loads it once.
@@ -114,7 +122,7 @@ func expandPattern(pattern string) ([]string, error) {
 			out = append(out, files...)
 			continue
 		}
-		if IsModelFile(m) {
+		if IsLoadable(m) {
 			out = append(out, m)
 		}
 	}
@@ -124,8 +132,8 @@ func expandPattern(pattern string) ([]string, error) {
 	return out, nil
 }
 
-// ModelFiles walks dir and returns every .sysml/.kerml file under it, sorted by
-// path. Hidden directories are skipped, so a repository's .git or a build cache
+// ModelFiles walks dir and returns every .sysml/.kerml file and .ipynb notebook
+// under it, sorted by path. Hidden directories are skipped, so a repository's .git or a build cache
 // under a dot-directory contributes nothing. Symlinked directories are walked —
 // a project may keep a shared library as a link — each at most once, so a cycle
 // terminates.
@@ -135,13 +143,13 @@ func ModelFiles(dir string) ([]string, error) {
 		return nil, err
 	}
 	if len(out) == 0 {
-		return nil, fmt.Errorf("no .sysml or .kerml files in %s", dir)
+		return nil, fmt.Errorf("no .sysml or .kerml files or .ipynb notebooks in %s", dir)
 	}
 	sort.Strings(out)
 	return out, nil
 }
 
-// walk appends the model files under dir to out, descending into
+// walk appends the model files and notebooks under dir to out, descending into
 // subdirectories, symlinked ones included. visited holds the resolved
 // directories already walked, which is what keeps a link cycle finite.
 func walk(dir string, visited map[string]bool, out *[]string) error {
@@ -175,7 +183,7 @@ func walk(dir string, visited map[string]bool, out *[]string) error {
 			if err := walk(path, visited, out); err != nil {
 				return err
 			}
-		case IsModelFile(path):
+		case IsLoadable(path):
 			*out = append(*out, path)
 		}
 	}
diff --git a/packaging/agent-skills/skills/opensysml-java/SKILL.md b/packaging/agent-skills/skills/opensysml-java/SKILL.md
index e14d2dbb04..0adba4cc4e 100644
--- a/packaging/agent-skills/skills/opensysml-java/SKILL.md
+++ b/packaging/agent-skills/skills/opensysml-java/SKILL.md
@@ -24,7 +24,7 @@ mvn -f client/java/pom.xml install
 <dependency>
   <groupId>org.openmbee</groupId>
   <artifactId>opensysml</artifactId>
-  <version>0.9.2</version>  <!-- the version in client/java/pom.xml -->
+  <version>0.10.0</version>  <!-- the version in client/java/pom.xml -->
 </dependency>
 ```
 
diff --git a/packaging/man/man1/sysml.1 b/packaging/man/man1/sysml.1
index 798d63646d..53fb8c3625 100644
--- a/packaging/man/man1/sysml.1
+++ b/packaging/man/man1/sysml.1
@@ -352,6 +352,19 @@ beside it, or full, every port, labelled name : Type
 What \-render or \-render\-all draws over a requirement rendering's structure:
 verdicts runs the verification cases verifying each requirement and colours
 and labels it by their verdicts; default none, a purely structural drawing
+.SS Listing documents and views
+.TP
+.BR \-list " \fIwhat\fP"
+List the model's documents, views, diagrams (the graph\-shaped views),
+pseudo\-views or all of them, by the qualified names \-render\-document and
+\-render read: documents, views, diagrams, pseudo\-views or all
+.TP
+.BR \-list\-kind " \fIkinds\fP"
+Comma\-separated view kinds \-list views, diagrams or all keeps, as
+state,action
+.TP
+.BR \-list\-form " \fIform\fP"
+Form \-list writes: text (default), one aligned line per item, tsv or json
 .SS Rendering documents
 .TP
 .BR \-render\-document " \fIname\fP"
@@ -984,6 +997,35 @@ Mermaid, PlantUML and D2 lay the same members out themselves.
 \-render\-unplaced strip draws the unplaced members too, in rows in a strip
 below a DOT drawing. The same setting shapes the diagrams of
 \-render\-document and \-render\-documents.
+.SH LISTING DOCUMENTS AND VIEWS
+.RS 2
+.nf
+# the names \-render\-document reads
+sysml model.sysml \-list documents
+# the names \-render reads, with their kinds
+sysml model.sysml \-list views
+sysml model.sysml \-list diagrams \-list\-kind state,action
+sysml model.sysml \-list all \-list\-form json
+.fi
+.RE
+.PP
+\-list documents lists the document definitions the loaded model declares,
+\-list views its views with the rendering kind each states, a view whose kind
+this build does not produce marked unsupported with the reason, \-list
+diagrams the graph\-shaped views \(em tree, interconnection, state, action,
+case, mixed, sequence, requirement, definition and package, the kinds a
+document draws as a diagram \(em \-list pseudo\-views the pseudo\-views a
+document declaring no view is rendered through, and \-list all the documents
+followed by the views. Each name is the qualified name as the notation writes
+it, every segment quoted that needs it and a line break escaped as \en, so it
+is passed back unchanged to \-render\-document or \-render.
+.PP
+\-list\-kind keeps the views of the comma\-separated kinds it names.
+\-list\-form text (default) writes one aligned line per item; tsv writes a
+header record category, kind, supported, file, line, name and reason, then a
+record per item; json writes an array of objects with those fields, each
+omitted when empty. file is the path the declaration was loaded from and line
+its 1\-based line. A model declaring nothing to list writes nothing.
 .SH RENDERING A DOCUMENT
 .RS 2
 .nf
diff --git a/scripts/build-jupyter-kernel-dist.sh b/scripts/build-jupyter-kernel-dist.sh
index 41a3b7dc4f..966bdd5183 100755
--- a/scripts/build-jupyter-kernel-dist.sh
+++ b/scripts/build-jupyter-kernel-dist.sh
@@ -16,9 +16,12 @@
 #   jupyter_opensysml_kernel-<version>.tar.gz                 the sdist, kernel-less
 #   jupyter_opensysml_kernel-<version>-py3-none-<platform>.whl  one per platform
 #
-# Every wheel is then opened and checked to carry its kernel and the kernelspec
-# that registers it, and the sdist to carry neither. PYTHON names the
-# interpreter that runs `python -m build` (default `python`).
+# The JupyterLab extension is built first (`make jupyterlab-build`, so Node and
+# the jupyterlab package are needed); every distribution ships the same bundle.
+# Every wheel is then opened and checked to carry its kernel, the kernelspec
+# that registers it and the extension, and the sdist to carry the extension and
+# no kernel. PYTHON names the interpreter that runs `python -m build` (default
+# `python`).
 set -euo pipefail
 
 KERNELS="${1:?usage: $0 <kernels-dir> <out-dir>}"
@@ -36,6 +39,10 @@ cleanup
 rm -rf "$OUT"
 mkdir -p "$OUT"
 
+# The extension once, before any distribution: setup.py refuses to build one
+# without it.
+make jupyterlab-build
+
 # The sdist first, while no kernel is staged: setup.py refuses to pack one.
 "$PYTHON" -m build --sdist --outdir "$OUT" "$PACKAGE"
 
@@ -64,8 +71,10 @@ done
 ls -l "$OUT"
 
 # Each distribution is what its name claims: the wheels bundle the kernel built
-# for their platform and the kernelspec that starts it, the sdist carries neither.
+# for their platform and the kernelspec that starts it, the sdist carries
+# neither, and all of them carry the one JupyterLab extension build.
 "$PYTHON" - "$OUT" <<'PY'
+import json
 import os
 import sys
 import tarfile
@@ -73,9 +82,27 @@ import zipfile
 
 sys.path.insert(0, os.path.join("client", "jupyter-kernel"))
 from jupyter_opensysml_kernel.binary import WHEEL_PLATFORM_TAGS, binary_name  # noqa: E402
+from jupyter_opensysml_kernel.labextension import SHARED_DATA  # noqa: E402
 
 out = sys.argv[1]
 spec = "share/jupyter/kernels/sysml/"
+labextension = SHARED_DATA + "/"
+
+
+def labextension_files(what, members, prefix):
+    """The extension's files under `prefix` in a distribution, checked to be a
+    loadable federated extension: name -> bytes."""
+    files = {name[len(prefix):]: read for name, read in members.items() if name.startswith(prefix)}
+    for required in ("package.json", "install.json"):
+        if required not in files:
+            raise SystemExit(f"Error: {what} lacks {prefix}{required}")
+    load = json.loads(files["package.json"]()).get("jupyterlab", {}).get("_build", {}).get("load", "")
+    if not load.startswith("static/remoteEntry.") or load not in files:
+        raise SystemExit(f"Error: {what} ships a labextension whose package.json loads {load!r}, which it lacks")
+    return {name: read() for name, read in files.items()}
+
+
+bundles = {}
 wheels = sorted(f for f in os.listdir(out) if f.endswith(".whl"))
 sdists = sorted(f for f in os.listdir(out) if f.endswith(".tar.gz"))
 if len(sdists) != 1:
@@ -107,11 +134,25 @@ for (goos, goarch), tag in WHEEL_PLATFORM_TAGS.items():
         meta = next(n for n in names if n.endswith(".dist-info/WHEEL"))
         if b"Root-Is-Purelib: false" not in wheel.read(meta):
             raise SystemExit(f"Error: {matching[0]} is not marked platform-specific in its WHEEL metadata")
-    print(f"ok: {matching[0]} bundles {kernel} and the kernelspec")
+        data_dir = data[: -len(spec + "kernel.json")]
+        members = {n: (lambda n=n: wheel.read(n)) for n in names}
+        bundles[matching[0]] = labextension_files(matching[0], members, data_dir + labextension)
+    print(f"ok: {matching[0]} bundles {kernel}, the kernelspec and the labextension")
 
 with tarfile.open(os.path.join(out, sdists[0]), "r:gz") as sdist:
-    bundled = [n for n in sdist.getnames() if "/jupyter_opensysml_kernel/bin/" in n]
+    names = sdist.getnames()
+    bundled = [n for n in names if "/jupyter_opensysml_kernel/bin/" in n]
     if bundled:
         raise SystemExit(f"Error: the sdist {sdists[0]} bundles a kernel: {bundled}")
-print(f"ok: {sdists[0]} bundles no kernel")
+    root = names[0].split("/")[0] + "/labextension/"
+    members = {n: (lambda n=n: sdist.extractfile(n).read()) for n in names if sdist.getmember(n).isfile()}
+    bundles[sdists[0]] = labextension_files(sdists[0], members, root)
+print(f"ok: {sdists[0]} bundles no kernel and the labextension")
+
+# The bundle is pure JavaScript: one build, byte for byte, in all six.
+reference = bundles[sdists[0]]
+for name, files in bundles.items():
+    if files != reference:
+        raise SystemExit(f"Error: {name} ships a labextension other than the sdist's: {sorted(set(files) ^ set(reference)) or 'same files, different bytes'}")
+print(f"ok: all {len(bundles)} distributions ship the same labextension ({', '.join(sorted(reference))})")
 PY
diff --git a/scripts/ci-changed-areas-test.sh b/scripts/ci-changed-areas-test.sh
index 3b34d07e20..fec1af74ec 100755
--- a/scripts/ci-changed-areas-test.sh
+++ b/scripts/ci-changed-areas-test.sh
@@ -58,6 +58,10 @@ case_ julia-only julia client/julia/OpenSysML/src/connection.jl
 case_ matlab-only matlab client/matlab/+opensysml/call.m
 case_ vscode-manifest python,vscode editors/vscode/package.json
 case_ vscode-lock python,vscode editors/vscode/package-lock.json
+case_ jupyterlab-only jupyterlab editors/jupyterlab/src/sysml.ts
+case_ jupyterlab-test jupyterlab editors/jupyterlab/test/sysml.test.ts
+case_ jupyterlab-manifest jupyterlab,python editors/jupyterlab/package.json
+case_ jupyterlab-lock jupyterlab,python editors/jupyterlab/package-lock.json
 case_ syson-frontend-manifest python,syson editors/syson/frontend/package.json
 case_ syson-frontend-lock python,syson editors/syson/frontend/package-lock.json
 case_ syson-manifest python,syson editors/syson/pom.xml
@@ -67,22 +71,23 @@ case_ syson-api-stubs-manifest python,syson editors/syson/syson-api-stubs/pom.xm
 case_ syson-backend-manifest python,syson editors/syson/backend/pom.xml
 case_ syson-readme docs,syson editors/syson/README.md
 # The grammar generator and its committed output are held together by a Go test.
-case_ vscode-grammar docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode editors/vscode/tools/gengrammar/grammar.go
-case_ vscode-syntaxes docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode editors/vscode/syntaxes/sysml.tmLanguage.json
+case_ vscode-grammar docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode editors/vscode/tools/gengrammar/grammar.go
+case_ vscode-syntaxes docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode editors/vscode/syntaxes/sysml.tmLanguage.json
+case_ jupyterlab-syntax docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode editors/jupyterlab/src/syntax.json
 # Any markdown counts as documentation: the site links out to repository files.
 case_ man-page docs packaging/man/man1/sysml.1
 case_ two-client-readmes docs,java,mdk,node client/java/README.md client/node/README.md
 case_ two-clients java,mdk,node,python client/java/pom.xml client/node/tsconfig.json
-case_ go-source docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode internal/syntax/parser/parser.go
-case_ go-client docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode client/opensysml/client.go
-case_ release-digests docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode client/release-digests.json
-case_ go-tools docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode tools/gen/snapshot/main.go
-case_ proto docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode api/proto/sysml.proto
-case_ install-script docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode install.sh
-case_ install-script-windows docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode install.ps1
-case_ conformance docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode conformance/scenarios/01-server-info.json
-case_ workflow docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode .github/workflows/pr.yml
-case_ unclaimed docs,go,java,julia,matlab,mdk,node,python,rust,syson,vscode some-new-top-level/thing.txt
+case_ go-source docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode internal/syntax/parser/parser.go
+case_ go-client docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode client/opensysml/client.go
+case_ release-digests docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode client/release-digests.json
+case_ go-tools docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode tools/gen/snapshot/main.go
+case_ proto docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode api/proto/sysml.proto
+case_ install-script docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode install.sh
+case_ install-script-windows docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode install.ps1
+case_ conformance docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode conformance/scenarios/01-server-info.json
+case_ workflow docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode .github/workflows/pr.yml
+case_ unclaimed docs,go,java,julia,jupyterlab,matlab,mdk,node,python,rust,syson,vscode some-new-top-level/thing.txt
 
 if [[ "$failures" -ne 0 ]]; then
   echo "$failures case(s) failed" >&2
diff --git a/scripts/ci-changed-areas.sh b/scripts/ci-changed-areas.sh
index 81b6678276..7e43e2dc4b 100755
--- a/scripts/ci-changed-areas.sh
+++ b/scripts/ci-changed-areas.sh
@@ -15,9 +15,10 @@ changed=$(git diff --name-only "$(git merge-base "$base" "$head")" "$head")
 
 # The service and the schema the clients speak to, plus the shared conformance
 # scenarios: a change here can change every client's answers, so all of them run.
-# The extension's grammar generator and its committed output are here too: the
-# test that holds them together is a Go test, run by the Go suite.
-service_pattern='^(api/proto/|cmd/|internal/|tools/|client/opensysml/|client/release-digests\.json$|conformance/|tests/|scripts/|examples/|editors/vscode/tools/|editors/vscode/syntaxes/|Makefile$|go\.mod$|go\.sum$|install\.sh$|install\.ps1$|\.github/workflows/|\.circleci/)'
+# The editors' grammar generator and its committed outputs (the VS Code
+# grammars and the JupyterLab syntax table) are here too: the test that holds
+# them together is a Go test, run by the Go suite.
+service_pattern='^(api/proto/|cmd/|internal/|tools/|client/opensysml/|client/release-digests\.json$|conformance/|tests/|scripts/|examples/|editors/vscode/tools/|editors/vscode/syntaxes/|editors/jupyterlab/src/syntax\.json$|Makefile$|go\.mod$|go\.sum$|install\.sh$|install\.ps1$|\.github/workflows/|\.circleci/)'
 docs_pattern='^(docs/|overrides/|packaging/man/|mkdocs\.yml$|README\.md$|CHANGELOG\.md$|CONTRIBUTING\.md$|AGENTS\.md$|.*\.md$)'
 node_pattern='^client/node/'
 python_pattern='^client/python/'
@@ -26,10 +27,11 @@ rust_pattern='^client/rust/'
 julia_pattern='^client/julia/'
 matlab_pattern='^client/matlab/'
 vscode_pattern='^editors/vscode/'
+jupyterlab_pattern='^editors/jupyterlab/'
 mdk_pattern='^editors/mdk/'
 syson_pattern='^editors/syson/'
 
-known_pattern="$service_pattern|$docs_pattern|$node_pattern|$python_pattern|$java_pattern|$rust_pattern|$julia_pattern|$matlab_pattern|$vscode_pattern|$mdk_pattern|$syson_pattern|^\.agents/|^\.gitignore$|^\.gitattributes$|^LICENSE|^packaging/"
+known_pattern="$service_pattern|$docs_pattern|$node_pattern|$python_pattern|$java_pattern|$rust_pattern|$julia_pattern|$matlab_pattern|$vscode_pattern|$jupyterlab_pattern|$mdk_pattern|$syson_pattern|^\.agents/|^\.gitignore$|^\.gitattributes$|^LICENSE|^packaging/"
 
 matches() {
   local pattern=$1
@@ -56,12 +58,13 @@ emit node "$( { [[ "$service" = true ]] || matches "$node_pattern"; } && echo tr
 # so the Node, Java and Rust manifests, every editor manifest
 # check_version.py --editors reads, and the editors' client references have
 # to run it too.
-emit python "$( { [[ "$service" = true ]] || matches "$python_pattern" || matches '^client/node/package\.json$' || matches '^client/java/pom\.xml$' || matches '^client/rust/opensysml/Cargo\.toml$' || matches '^client/rust/Cargo\.lock$' || matches '^editors/(mdk|syson(/backend)?)/pom\.xml$' || matches '^editors/(mdk/(plugin|tools|openapi-stubs|mdk-api-stubs|mdk-bridge|dist)|syson/syson-api-stubs)/pom\.xml$' || matches '^editors/(vscode|syson/frontend)/package(-lock)?\.json$'; } && echo true || echo false)"
+emit python "$( { [[ "$service" = true ]] || matches "$python_pattern" || matches '^client/node/package\.json$' || matches '^client/java/pom\.xml$' || matches '^client/rust/opensysml/Cargo\.toml$' || matches '^client/rust/Cargo\.lock$' || matches '^editors/(mdk|syson(/backend)?)/pom\.xml$' || matches '^editors/(mdk/(plugin|tools|openapi-stubs|mdk-api-stubs|mdk-bridge|dist)|syson/syson-api-stubs)/pom\.xml$' || matches '^editors/(vscode|jupyterlab|syson/frontend)/package(-lock)?\.json$'; } && echo true || echo false)"
 emit java "$( { [[ "$service" = true ]] || matches "$java_pattern"; } && echo true || echo false)"
 emit rust "$( { [[ "$service" = true ]] || matches "$rust_pattern"; } && echo true || echo false)"
 emit julia "$( { [[ "$service" = true ]] || matches "$julia_pattern"; } && echo true || echo false)"
 emit matlab "$( { [[ "$service" = true ]] || matches "$matlab_pattern"; } && echo true || echo false)"
 emit vscode "$( { [[ "$service" = true ]] || matches "$vscode_pattern"; } && echo true || echo false)"
+emit jupyterlab "$( { [[ "$service" = true ]] || matches "$jupyterlab_pattern"; } && echo true || echo false)"
 # The MDK plugin builds on the Java client, so a client change re-runs it too.
 emit mdk "$( { [[ "$service" = true ]] || matches "$mdk_pattern" || matches "$java_pattern"; } && echo true || echo false)"
 emit syson "$( { [[ "$service" = true ]] || matches "$syson_pattern"; } && echo true || echo false)"
diff --git a/scripts/race-shard.sh b/scripts/race-shard.sh
index d37e4c35af..390424faf8 100755
--- a/scripts/race-shard.sh
+++ b/scripts/race-shard.sh
@@ -1,12 +1,13 @@
 #!/usr/bin/env bash
 # Prints the root-module package paths assigned to one race-test shard.
-# Usage: scripts/race-shard.sh runtime|model|export|rest
+# Usage: scripts/race-shard.sh runtime|runtime-corpus|model|export|rest
+# runtime and runtime-corpus are one package, split by test name in make test-shard.
 set -euo pipefail
 
 cd "$(dirname "$0")/.."
 
 if [[ $# -ne 1 ]]; then
-  echo "usage: scripts/race-shard.sh runtime|model|export|rest" >&2
+  echo "usage: scripts/race-shard.sh runtime|runtime-corpus|model|export|rest" >&2
   exit 2
 fi
 
@@ -24,9 +25,9 @@ wasm="$module/tests/wasm"
 named_packages=("$runtime" "$workspace_model" "$corpus" "$smt" "$export" "$model" "$passes" "$wasm")
 
 case "$shard" in
-  runtime|model|export|rest) ;;
+  runtime|runtime-corpus|model|export|rest) ;;
   *)
-    echo "usage: scripts/race-shard.sh runtime|model|export|rest" >&2
+    echo "usage: scripts/race-shard.sh runtime|runtime-corpus|model|export|rest" >&2
     exit 2
     ;;
 esac
@@ -40,7 +41,7 @@ for package in "${named_packages[@]}"; do
 done
 
 case "$shard" in
-  runtime)
+  runtime|runtime-corpus)
     printf '%s\n' "$runtime"
     ;;
   model)
diff --git a/tests/export/decision_branch_test.go b/tests/export/decision_branch_test.go
index 554adf5248..73783cd7f1 100644
--- a/tests/export/decision_branch_test.go
+++ b/tests/export/decision_branch_test.go
@@ -54,9 +54,24 @@ func TestDecisionBranchesTheNotationCannotStateAreRefused(t *testing.T) {
 		"another source": func(g string) string {
 			return strings.Replace(g, "sysml:source elmt:P__A__pick ;", "sysml:source elmt:P__A__check ;", 1)
 		},
+		"another source stated as sourceFeature alone": func(g string) string {
+			return strings.Replace(g, "sysml:source elmt:P__A__pick ;", "sysml:sourceFeature elmt:P__A__check ;", 1)
+		},
+		"two sources, the member before it first": func(g string) string {
+			return strings.Replace(g, "sysml:source elmt:P__A__pick ;", "sysml:source elmt:P__A__pick, elmt:P__A__check ;", 1)
+		},
+		"two sourceFeature sources, the member before it first": func(g string) string {
+			return strings.Replace(g, "sysml:source elmt:P__A__pick ;", "sysml:sourceFeature elmt:P__A__pick, elmt:P__A__check ;", 1)
+		},
+		"a sourceFeature spelled as a literal": func(g string) string {
+			return strings.Replace(g, "sysml:source elmt:P__A__pick ;", "sysml:source elmt:P__A__pick ;\n    sysml:sourceFeature \"urn:sysmlv2:element:P__A__pick\" ;", 1)
+		},
 		"an else with a body": func(g string) string {
 			return strings.Replace(g, `sysx:isElse "true"^^xsd:boolean ;`, `sysx:isElse "true"^^xsd:boolean ;`+"\n    sysx:hasBody \"true\"^^xsd:boolean ;", 1)
 		},
+		"a trigger": func(g string) string {
+			return strings.Replace(g, `sysx:transitionSyntax "target" ;`, `sysx:transitionSyntax "target" ;`+"\n    sysx:trigger \"accept Go\" ;", 1)
+		},
 		"neither guard nor else": func(g string) string {
 			return strings.Replace(g, `sysx:isElse "true"^^xsd:boolean ;`, "", 1)
 		},
diff --git a/tests/hygiene/layering_test.go b/tests/hygiene/layering_test.go
index 52b5d80df7..f65d39f143 100644
--- a/tests/hygiene/layering_test.go
+++ b/tests/hygiene/layering_test.go
@@ -87,20 +87,22 @@ var packageLayer = map[string]string{
 	"internal/exec/hostcap":             "exec",
 	"internal/exec/objref":              "exec",
 
-	"internal/translate/rdf":              "translate",
-	"internal/translate/rdf/ontology":     "translate",
-	"internal/translate/convert":          "translate",
-	"internal/translate/export":           "translate",
-	"internal/translate/filename":         "translate",
-	"internal/translate/fmi":              "translate",
-	"internal/translate/migrate":          "translate",
-	"internal/translate/deferred":         "translate",
-	"internal/translate/mtip":             "translate",
-	"internal/translate/xmi":              "translate",
-	"internal/translate/xmi/sysmlv1":      "translate",
-	"internal/translate/codegen":          "translate",
-	"internal/translate/interop/flexo":    "translate",
-	"internal/translate/interop/reposync": "translate",
+	"internal/translate/rdf":               "translate",
+	"internal/translate/rdf/ontology":      "translate",
+	"internal/translate/convert":           "translate",
+	"internal/translate/export":            "translate",
+	"internal/translate/filename":          "translate",
+	"internal/translate/fmi":               "translate",
+	"internal/translate/migrate":           "translate",
+	"internal/translate/deferred":          "translate",
+	"internal/translate/mtip":              "translate",
+	"internal/translate/xmi":               "translate",
+	"internal/translate/xmi/sysmlv1":       "translate",
+	"internal/translate/codegen":           "translate",
+	"internal/translate/interop/sysmlapi":  "translate",
+	"internal/translate/interop/modelsync": "translate",
+	"internal/translate/interop/flexo":     "translate",
+	"internal/translate/interop/reposync":  "translate",
 
 	"internal/semantic/query": "semantic",
 	"internal/doc/queryexec":  "doc",
@@ -115,6 +117,7 @@ var packageLayer = map[string]string{
 	"internal/workspace/libs":        "workspace",
 	"internal/workspace/libs/errata": "workspace",
 	"internal/workspace/project":     "workspace",
+	"internal/workspace/notebook":    "workspace",
 	"internal/workspace/envvar":      "workspace",
 
 	"api/proto":                     "frontend",
@@ -149,6 +152,7 @@ var packageLayer = map[string]string{
 	"internal/frontend/repl/replext/instancegraph": "frontend",
 	"internal/frontend/repl/replext/notation":      "frontend",
 	"internal/frontend/repl/replext/positional":    "frontend",
+	"internal/frontend/repl/replext/repository":    "frontend",
 }
 
 // tolerated is the imports the layer table does not permit and that still
diff --git a/tests/hygiene/nightly_workflow_test.go b/tests/hygiene/nightly_workflow_test.go
index 0183eca05c..a126be1d36 100644
--- a/tests/hygiene/nightly_workflow_test.go
+++ b/tests/hygiene/nightly_workflow_test.go
@@ -233,6 +233,11 @@ func TestNightlyJupyterKernelSnapshotIsStampedBeforeItIsBuiltAndCheckedAfter(t *
 		"--table client/jupyter-kernel/jupyter_opensysml_kernel/release-digests.json",
 	)
 	build := stepIndex(steps, `"$KERNEL_DIST_SCRIPT" dist/jupyter client/jupyter-kernel/dist`, "-py3-none-*.whl")
+	labextension := stepIndex(steps, `pip install --only-binary ":all:" jupyterlab==`,
+		`(cd editors/jupyterlab && npm version --no-git-tag-version "$NPM_VERSION")`,
+		`"$KERNEL_DIST_SCRIPT" dist/jupyter client/jupyter-kernel/dist`,
+		`labextensions/jupyterlab-opensysml/package.json`, `[ "$stamped" != "$NPM_VERSION" ]`,
+	)
 	verify := stepIndex(steps, "jupyter_opensysml_kernel/release-digests.json", "zipfile", "tarfile", "pinned_digest", "built_against_releases", "bundled_binary", "jupyter_client.kernelspecapp", `"jupyter_opensysml_kernel", "-version"`)
 	manifest := stepIndex(steps, "sha256sum jupyter_opensysml_kernel-*.whl")
 	sign := stepIndex(steps, "cosign sign-blob SHA256SUMS.txt")
@@ -240,6 +245,7 @@ func TestNightlyJupyterKernelSnapshotIsStampedBeforeItIsBuiltAndCheckedAfter(t *
 	for name, index := range map[string]int{
 		"version stamp": version, "binary build": binaries, "digest stamp": stamp,
 		"distribution build": build, "distribution check": verify, "manifest entry": manifest,
+		"jupyterlab install and labextension manifest stamp before the distribution build, manifest version check after": labextension,
 		"manifest signing": sign, "kernel assets in the release": release,
 	} {
 		if index < 0 {
diff --git a/tests/hygiene/release_config_test.go b/tests/hygiene/release_config_test.go
index c10287cf1f..78d850bd3f 100644
--- a/tests/hygiene/release_config_test.go
+++ b/tests/hygiene/release_config_test.go
@@ -30,7 +30,13 @@ var kernelAssets = []string{
 }
 
 type circleConfig struct {
-	Jobs map[string]struct{ Steps []yaml.Node } `yaml:"jobs"`
+	Executors map[string]struct {
+		Docker []struct{ Image string } `yaml:"docker"`
+	} `yaml:"executors"`
+	Jobs map[string]struct {
+		Executor string      `yaml:"executor"`
+		Steps    []yaml.Node `yaml:"steps"`
+	} `yaml:"jobs"`
 	// A workflows entry is a workflow, apart from the `version` key.
 	Workflows map[string]yaml.Node `yaml:"workflows"`
 }
@@ -55,6 +61,22 @@ type runStep struct {
 	Command string
 }
 
+// jobRunsOnImage reports whether the named job's executor is backed by the
+// Docker image.
+func (c circleConfig) jobRunsOnImage(t *testing.T, job, image string) bool {
+	t.Helper()
+	executor, ok := c.Executors[c.Jobs[job].Executor]
+	if !ok {
+		t.Fatalf("%s names no executor of the config's", job)
+	}
+	for _, docker := range executor.Docker {
+		if docker.Image == image {
+			return true
+		}
+	}
+	return false
+}
+
 func loadCircleConfig(t *testing.T) circleConfig {
 	t.Helper()
 	raw, err := os.ReadFile("../../.circleci/config.yml")
@@ -274,6 +296,21 @@ func TestJupyterKernelDistributionIsStampedWithItsReleaseDigests(t *testing.T) {
 			t.Errorf("build-jupyter-kernel-dist.sh does not use %q", want)
 		}
 	}
+	// The JupyterLab extension is built once, before the sdist and the wheels,
+	// and every distribution is opened and held to carry that one build.
+	extension := strings.Index(string(script), "make jupyterlab-build")
+	sdist := strings.Index(string(script), "-m build --sdist")
+	switch {
+	case extension < 0:
+		t.Error("build-jupyter-kernel-dist.sh does not build the JupyterLab extension with make jupyterlab-build")
+	case extension > sdist:
+		t.Error("build-jupyter-kernel-dist.sh builds the JupyterLab extension after the sdist, which ships without it")
+	}
+	for _, want := range []string{"jupyter_opensysml_kernel.labextension import SHARED_DATA", `"package.json"`, `"install.json"`, "static/remoteEntry.", "ship the same labextension"} {
+		if !strings.Contains(string(script), want) {
+			t.Errorf("build-jupyter-kernel-dist.sh does not check every distribution carries the labextension (%q)", want)
+		}
+	}
 
 	binaries, ok := config.Jobs["build-release-binaries"]
 	if !ok {
@@ -352,6 +389,23 @@ func TestJupyterKernelDistributionIsStampedWithItsReleaseDigests(t *testing.T) {
 	if stepIndex(kernelSteps, "-py3-none-manylinux*_x86_64*.whl", "jupyter_client.kernelspecapp", `"share", "jupyter", "kernels", "sysml"`, `"jupyter_opensysml_kernel", "-version"`) < 0 {
 		t.Error("build-jupyter-kernel-package does not install this platform's wheel alone and check it registers the sysml kernelspec and starts the bundled kernel")
 	}
+	// The extension is built with Node and `jupyter labextension build`, so
+	// the job needs both before the distributions are built, and the
+	// installed wheel is checked to have put the extension where JupyterLab
+	// loads federated extensions from.
+	if !config.jobRunsOnImage(t, "build-jupyter-kernel-package", "cimg/python:3.11-node") {
+		t.Error("build-jupyter-kernel-package does not run on an image with Node, which make jupyterlab-build needs")
+	}
+	tooling := stepIndex(kernelSteps, "pip install", "jupyterlab==")
+	switch {
+	case tooling < 0:
+		t.Error("build-jupyter-kernel-package does not install jupyterlab, which provides `jupyter labextension build`")
+	case tooling > wheel:
+		t.Error("build-jupyter-kernel-package installs jupyterlab after the distributions are built")
+	}
+	if stepIndex(kernelSteps, `"share", "jupyter", "labextensions", "jupyterlab-opensysml"`, `["jupyterlab"]["_build"]["load"]`, `"install.json"`) < 0 {
+		t.Error("build-jupyter-kernel-package does not check the installed wheel registered a loadable jupyterlab-opensysml labextension")
+	}
 
 	releaseJob, ok := config.Jobs["build-release"]
 	if !ok {
diff --git a/tests/migrate/relations_test.go b/tests/migrate/relations_test.go
index dc020f20f0..80507585e3 100644
--- a/tests/migrate/relations_test.go
+++ b/tests/migrate/relations_test.go
@@ -1557,3 +1557,122 @@ func TestOpaqueExpressionsMayNameImportedMembers(t *testing.T) {
 	wantNote(t, r, "_gear", migrate.Approximated, "private visibility is not written: v2 lets nothing outside the package reach a private member")
 	wantClean(t, "imports.sysml", r)
 }
+
+// partFlowModel is a system whose item flow names the blocks typing the parts on
+// the realizing connector's ends, as Cameo writes a flow drawn between parts, and
+// a second connector from the system's own port whose flow names the system.
+const partFlowModel = `
+    <packagedElement xmi:type="uml:Class" xmi:id="_fuel" name="Fuel"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_out_if" name="Outlet">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_out_fuel" name="fuelOut" type="_fuel"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_in_if" name="Inlet">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_in_fuel" name="fuelIn" type="_fuel"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_pump" name="Pump">
+      <ownedAttribute xmi:type="uml:Port" xmi:id="_pump_out" name="outlet" type="_out_if" aggregation="composite"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_engine" name="Engine">
+      <ownedAttribute xmi:type="uml:Port" xmi:id="_engine_in" name="inlet" type="_in_if" aggregation="composite"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_sys" name="System">
+      <ownedAttribute xmi:type="uml:Port" xmi:id="_sys_in" name="supply" type="_in_if" aggregation="composite"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_p" name="pump" type="_pump" aggregation="composite"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_e" name="engine" type="_engine" aggregation="composite"/>
+      <ownedConnector xmi:type="uml:Connector" xmi:id="_conn">
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e1" partWithPort="_e" role="_engine_in"/>
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e2" partWithPort="_p" role="_pump_out"/>
+      </ownedConnector>
+      <ownedConnector xmi:type="uml:Connector" xmi:id="_conn2">
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e3" partWithPort="_p" role="_pump_out"/>
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e4" role="_sys_in"/>
+      </ownedConnector>
+    </packagedElement>
+    <packagedElement xmi:type="uml:InformationFlow" xmi:id="_if" informationSource="_pump" informationTarget="_engine" conveyed="_fuel" realizingConnector="_conn"/>
+    <packagedElement xmi:type="uml:InformationFlow" xmi:id="_if2" informationSource="_p" informationTarget="_sys" conveyed="_fuel" realizingConnector="_conn2"/>
+    <packagedElement xmi:type="uml:InformationFlow" xmi:id="_if3" informationSource="_engine" informationTarget="_sys" conveyed="_fuel" realizingConnector="_conn2"/>`
+
+const partFlowApplications = `
+  <sysml:Block xmi:id="_s1" base_Class="_sys"/>
+  <sysml:Block xmi:id="_s2" base_Class="_fuel"/>
+  <sysml:Block xmi:id="_s3" base_Class="_pump"/>
+  <sysml:Block xmi:id="_s4" base_Class="_engine"/>
+  <sysml:InterfaceBlock xmi:id="_s5" base_Class="_out_if"/>
+  <sysml:InterfaceBlock xmi:id="_s6" base_Class="_in_if"/>
+  <sysml:FlowProperty xmi:id="_s7" base_Property="_out_fuel" direction="out"/>
+  <sysml:FlowProperty xmi:id="_s8" base_Property="_in_fuel" direction="in"/>
+  <sysml:ProxyPort xmi:id="_s9" base_Port="_pump_out"/>
+  <sysml:ProxyPort xmi:id="_s10" base_Port="_engine_in"/>
+  <sysml:ProxyPort xmi:id="_s11" base_Port="_sys_in"/>
+  <sysml:ItemFlow xmi:id="_s12" base_InformationFlow="_if"/>
+  <sysml:ItemFlow xmi:id="_s13" base_InformationFlow="_if2"/>
+  <sysml:ItemFlow xmi:id="_s14" base_InformationFlow="_if3"/>`
+
+// An item flow whose source and target are the parts on the realizing
+// connector's ends, the blocks typing them, or the connector's owner at its
+// own port, flows between the ports those ends name; one naming an element on
+// neither end is left as a comment.
+func TestItemFlowEndsMayBeThePartsOrBlocksOnTheConnector(t *testing.T) {
+	r := migrateDocument(t, partFlowModel, partFlowApplications)
+	wantLine(t, r.Notation, "flow of Fuel from pump.outlet.fuelOut to engine.inlet.fuelIn;")
+	wantLine(t, r.Notation, "flow of Fuel from pump.outlet.fuelOut to supply.fuelIn;")
+	for _, id := range []string{"_if", "_if2"} {
+		if es := entriesFor(r, id); len(es) != 1 || es[0].Verdict != migrate.Mapped {
+			t.Errorf("entries for %s = %+v, want one mapped", id, es)
+		}
+	}
+	wantNote(t, r, "_if3", migrate.Unmapped, "the item flow's source and target are not the ends of realizing connector")
+	wantNote(t, r, "_if3", migrate.Unmapped, "nor the parts or blocks on its ends' paths")
+	if diags := errors(t, "t.sysml", r.Notation); len(diags) > 0 {
+		t.Errorf("migrated notation has errors: %v", diags)
+	}
+}
+
+// twinFlowModel joins two parts of one block at ports of one type, so a flow
+// from the block to the port type stands for either end; one from one port to
+// the other is told apart by the ends' roles.
+const twinFlowModel = `
+    <packagedElement xmi:type="uml:Class" xmi:id="_fuel" name="Fuel"/>
+    <packagedElement xmi:type="uml:Class" xmi:id="_out_if" name="Outlet">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_out_fuel" name="fuel" type="_fuel"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_pump" name="Pump">
+      <ownedAttribute xmi:type="uml:Port" xmi:id="_pump_out" name="outlet" type="_out_if" aggregation="composite"/>
+    </packagedElement>
+    <packagedElement xmi:type="uml:Class" xmi:id="_sys" name="System">
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_l" name="left" type="_pump" aggregation="composite"/>
+      <ownedAttribute xmi:type="uml:Property" xmi:id="_r" name="right" type="_pump" aggregation="composite"/>
+      <ownedConnector xmi:type="uml:Connector" xmi:id="_conn">
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e1" partWithPort="_l" role="_pump_out"/>
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e2" partWithPort="_r" role="_pump_out"/>
+      </ownedConnector>
+      <ownedConnector xmi:type="uml:Connector" xmi:id="_conn2">
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e3" partWithPort="_r" role="_pump_out"/>
+        <end xmi:type="uml:ConnectorEnd" xmi:id="_e4" partWithPort="_l" role="_pump_out"/>
+      </ownedConnector>
+    </packagedElement>
+    <packagedElement xmi:type="uml:InformationFlow" xmi:id="_if" informationSource="_pump" informationTarget="_out_if" conveyed="_fuel" realizingConnector="_conn"/>
+    <packagedElement xmi:type="uml:InformationFlow" xmi:id="_if2" informationSource="_l" informationTarget="_r" conveyed="_fuel" realizingConnector="_conn2"/>`
+
+const twinFlowApplications = `
+  <sysml:Block xmi:id="_s1" base_Class="_sys"/>
+  <sysml:Block xmi:id="_s2" base_Class="_fuel"/>
+  <sysml:Block xmi:id="_s3" base_Class="_pump"/>
+  <sysml:InterfaceBlock xmi:id="_s5" base_Class="_out_if"/>
+  <sysml:FlowProperty xmi:id="_s7" base_Property="_out_fuel" direction="inout"/>
+  <sysml:ProxyPort xmi:id="_s9" base_Port="_pump_out"/>
+  <sysml:ItemFlow xmi:id="_s12" base_InformationFlow="_if"/>
+  <sysml:ItemFlow xmi:id="_s13" base_InformationFlow="_if2"/>`
+
+// An item flow whose source and target each stand for both ends of the
+// connector is not given the connector's end order as its direction: it is
+// left as a comment, while one the parts tell apart still follows them.
+func TestItemFlowWithEndsStandingForBothIsNotMigrated(t *testing.T) {
+	r := migrateDocument(t, twinFlowModel, twinFlowApplications)
+	wantNote(t, r, "_if", migrate.Unmapped, "each stand for both ends of realizing connector")
+	wantLine(t, r.Notation, "flow of Fuel from left.outlet.fuel to right.outlet.fuel;")
+	if es := entriesFor(r, "_if2"); len(es) != 1 || es[0].Verdict != migrate.Mapped {
+		t.Errorf("entries for _if2 = %+v, want one mapped", es)
+	}
+	wantClean(t, "t.sysml", r)
+}
diff --git a/tests/testdata/notebooks/broken.ipynb b/tests/testdata/notebooks/broken.ipynb
new file mode 100644
index 0000000000..4a38dc0406
--- /dev/null
+++ b/tests/testdata/notebooks/broken.ipynb
@@ -0,0 +1,33 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a",
+   "metadata": {},
+   "outputs": [],
+   "source": "package Good { part def A; }\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b",
+   "metadata": {},
+   "outputs": [],
+   "source": "package Bad {\n  import Missing::X;\n}\n"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SysML v2 (OpenSysML)",
+   "language": "sysml",
+   "name": "sysml"
+  },
+  "language_info": {
+   "name": "sysml",
+   "file_extension": ".sysml"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/testdata/notebooks/magics.ipynb b/tests/testdata/notebooks/magics.ipynb
new file mode 100644
index 0000000000..7250a95e36
--- /dev/null
+++ b/tests/testdata/notebooks/magics.ipynb
@@ -0,0 +1,56 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "%verbosity quiet\n",
+    "package Demo {\n",
+    "  private import ScalarValues::*;\n",
+    "  part def Wheel { attribute diameter : Real = 16.0; }\n",
+    "}\n",
+    "Demo::Wheel::diameter + 1\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b",
+   "metadata": {},
+   "outputs": [],
+   "source": "%instantiate Demo::Wheel\n%features Demo::Wheel\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c",
+   "metadata": {},
+   "outputs": [],
+   "source": "1 + 2\n(3\n + 4)\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d",
+   "metadata": {},
+   "outputs": [],
+   "source": "package Extra {\n  private import Demo::*;\n  part spare : Wheel;\n}\n"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SysML v2 (OpenSysML)",
+   "language": "sysml",
+   "name": "sysml"
+  },
+  "language_info": {
+   "name": "sysml",
+   "file_extension": ".sysml"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/testdata/notebooks/malformed.ipynb b/tests/testdata/notebooks/malformed.ipynb
new file mode 100644
index 0000000000..8bd32bcd51
--- /dev/null
+++ b/tests/testdata/notebooks/malformed.ipynb
@@ -0,0 +1 @@
+{"cells": [{"cell_type": "code", "source": "package P { }"
diff --git a/tests/testdata/notebooks/nbformat3.ipynb b/tests/testdata/notebooks/nbformat3.ipynb
new file mode 100644
index 0000000000..399998bf3b
--- /dev/null
+++ b/tests/testdata/notebooks/nbformat3.ipynb
@@ -0,0 +1,21 @@
+{
+ "metadata": {
+  "name": "old"
+ },
+ "nbformat": 3,
+ "nbformat_minor": 0,
+ "worksheets": [
+  {
+   "cells": [
+    {
+     "cell_type": "code",
+     "input": [
+      "package Old { }\n"
+     ],
+     "language": "sysml",
+     "outputs": []
+    }
+   ]
+  }
+ ]
+}
diff --git a/tests/testdata/notebooks/nolanguage.ipynb b/tests/testdata/notebooks/nolanguage.ipynb
new file mode 100644
index 0000000000..2c700fce1f
--- /dev/null
+++ b/tests/testdata/notebooks/nolanguage.ipynb
@@ -0,0 +1,15 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c",
+   "metadata": {},
+   "outputs": [],
+   "source": "package Quiet { part def Q; }\n"
+  }
+ ],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/testdata/notebooks/plain.ipynb b/tests/testdata/notebooks/plain.ipynb
new file mode 100644
index 0000000000..5f61fa98b4
--- /dev/null
+++ b/tests/testdata/notebooks/plain.ipynb
@@ -0,0 +1,56 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "m",
+   "metadata": {},
+   "source": "# A wheel"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "package Wheels {\n",
+    "  private import ScalarValues::*;\n",
+    "  part def Wheel { attribute diameter : Real = 16.0; }\n",
+    "}\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "m",
+   "metadata": {},
+   "source": "The car uses it."
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b",
+   "metadata": {},
+   "outputs": [],
+   "source": "package Cars {\n  private import Wheels::*;\n  part def Car { part wheels : Wheel[4]; }\n}\n"
+  },
+  {
+   "cell_type": "raw",
+   "id": "r",
+   "metadata": {},
+   "source": "not a cell the kernel runs"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SysML v2 (OpenSysML)",
+   "language": "sysml",
+   "name": "sysml"
+  },
+  "language_info": {
+   "name": "sysml",
+   "file_extension": ".sysml"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/testdata/notebooks/python.ipynb b/tests/testdata/notebooks/python.ipynb
new file mode 100644
index 0000000000..5876acc717
--- /dev/null
+++ b/tests/testdata/notebooks/python.ipynb
@@ -0,0 +1,25 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c",
+   "metadata": {},
+   "outputs": [],
+   "source": "print('hello')\n"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SysML v2 (OpenSysML)",
+   "language": "python",
+   "name": "sysml"
+  },
+  "language_info": {
+   "name": "python",
+   "file_extension": ".sysml"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/tests/testdata/notebooks/tagged.ipynb b/tests/testdata/notebooks/tagged.ipynb
new file mode 100644
index 0000000000..198a8b9a0b
--- /dev/null
+++ b/tests/testdata/notebooks/tagged.ipynb
@@ -0,0 +1,62 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "a",
+   "metadata": {
+    "tags": [
+     "model"
+    ]
+   },
+   "outputs": [],
+   "source": "package Model { part def A; }\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b",
+   "metadata": {
+    "tags": [
+     "skip-load"
+    ]
+   },
+   "outputs": [],
+   "source": "package Scratch { part def Junk; }\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c",
+   "metadata": {
+    "tags": [
+     "model",
+     "extra"
+    ]
+   },
+   "outputs": [],
+   "source": "package More { part def B; }\n"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "d",
+   "metadata": {},
+   "outputs": [],
+   "source": "package Untagged { part def C; }\n"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "SysML v2 (OpenSysML)",
+   "language": "sysml",
+   "name": "sysml"
+  },
+  "language_info": {
+   "name": "sysml",
+   "file_extension": ".sysml"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}