diff --git a/.git-blame-ignore-revs b/.git-blame-ignore-revs
new file mode 100644
index 000000000..51a2c0029
--- /dev/null
+++ b/.git-blame-ignore-revs
@@ -0,0 +1,2 @@
+# Format source with oxfmt
+449d17627fc405743130964a45b184b2fb6c6af0
diff --git a/.github/example-width.toml b/.github/example-width.toml
new file mode 100644
index 000000000..60b7e17ae
--- /dev/null
+++ b/.github/example-width.toml
@@ -0,0 +1,49 @@
+width = 80
+markdown = ["**/*.md"]
+shared_digest = "28b74bae1f7a06731fea5a150cbde4430179b7788b7564ea1644c3951df8531b"
+checker_digest = "eb87afceb3fc8f11ef5a478cd38f901ef3950e89ff94fbe0ca281c0cfc1a0e2e"
+allow_ceiling = 8
+
+[[exclude]]
+glob = "notes/research/**"
+reason = "dated research notes with pasted tool output and probes, kept as written; no reader copies code from them"
+
+[[allow]]
+path = "site/src/content/docs/ports/py/examples/capture-pane-output.md"
+line = "    --with 'libtmux @ git+https://github.com/tmux-python/libtmux@9fdd083a8181a827889337b63cd4e6daea661a8c' \\"
+reason = "one quoted PEP 508 requirement pinning libtmux to a commit; the URL and revision cannot break"
+
+[[allow]]
+path = "site/src/content/docs/ports/py/guides/attaching-to-tmux.md"
+line = "    --with 'libtmux @ git+https://github.com/tmux-python/libtmux@9fdd083a8181a827889337b63cd4e6daea661a8c' \\"
+reason = "one quoted PEP 508 requirement pinning libtmux to a commit; the URL and revision cannot break"
+
+[[allow]]
+path = "WRITING.md"
+line = "Session session = await server.CreateSessionAsync(new NewSessionRequest(name: \"work\"));"
+reason = "the Bad example in the port block; it shows the width problem the Good example fixes"
+
+[[allow]]
+path = "site/src/content/docs/ports/julia/examples/observe-output.md"
+line = "with_server(; tmux=get(ENV, \"LIBTMUX_TEST_TMUX\", \"tmux\"), env=environment) do server"
+reason = "a copy of libtmux-julia's examples/output_stream.jl at the revision site/test/fixtures/program-examples.json pins (6f62bd7), checked by sha256; libtmux-julia#7 fits the source, and this line follows when the pin moves"
+
+[[allow]]
+path = "site/src/content/docs/ports/julia/examples/owned-capture.md"
+line = "        println(\"Captured \", string(pane.id), \": \", ncodeunits(screen), \" screen bytes\")"
+reason = "a copy of libtmux-julia's examples/owned_capture.jl at the revision site/test/fixtures/program-examples.json pins (6f62bd7), checked by sha256; libtmux-julia#7 fits the source, and this line follows when the pin moves"
+
+[[allow]]
+path = "site/src/content/docs/ports/julia/examples/shared-windows.md"
+line = "            only(windows(onlymatch(SessionWhere(name=\"ops\"), sessions(captured)))).ref"
+reason = "a copy of libtmux-julia's examples/shared_windows.jl at the revision site/test/fixtures/program-examples.json pins (6f62bd7), checked by sha256; libtmux-julia#7 fits the source, and this line follows when the pin moves"
+
+[[allow]]
+path = "site/src/content/docs/ports/julia/examples/shared-windows.md"
+line = "    selected = filter(PaneWhere(active=true, window=WindowWhere(name=\"api\")), panes(snap))"
+reason = "a copy of libtmux-julia's examples/shared_windows.jl at the revision site/test/fixtures/program-examples.json pins (6f62bd7), checked by sha256; libtmux-julia#7 fits the source, and this line follows when the pin moves"
+
+[[allow]]
+path = "site/src/content/docs/ports/julia/examples/shared-windows.md"
+line = "            only(Iterators.filter(p -> p.active && p.window.name == \"api\", panes(snap))).ref"
+reason = "a copy of libtmux-julia's examples/shared_windows.jl at the revision site/test/fixtures/program-examples.json pins (6f62bd7), checked by sha256; libtmux-julia#7 fits the source, and this line follows when the pin moves"
diff --git a/.github/workflows/shared-examples.yml b/.github/workflows/shared-examples.yml
new file mode 100644
index 000000000..8ca9f7b78
--- /dev/null
+++ b/.github/workflows/shared-examples.yml
@@ -0,0 +1,36 @@
+name: shared-examples
+
+# The example rules are one text and one checker in every libtmux port. This
+# job compares them with each port's default branch, so it needs the network
+# and stays out of the local test loops. It runs on a change to the shared
+# files or this gate, and weekly; a port that drifts on its own surfaces in
+# the weekly run instead of failing unrelated pull requests here.
+
+on:
+  push:
+    branches: [main]
+    paths: &shared
+      - WRITING.md
+      - scripts/check_example_width.py
+      - scripts/check_shared_examples.py
+      - .github/workflows/shared-examples.yml
+  pull_request:
+    paths: *shared
+  schedule:
+    - cron: '17 6 * * 1'
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  drift:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v7
+        with:
+          persist-credentials: false
+      - run: python3 scripts/check_shared_examples.py --self-test
+      - run: python3 scripts/check_shared_examples.py
+        env:
+          GITHUB_TOKEN: ${{ github.token }}
diff --git a/.oxfmtrc.json b/.oxfmtrc.json
new file mode 100644
index 000000000..c95054231
--- /dev/null
+++ b/.oxfmtrc.json
@@ -0,0 +1,21 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 120,
+  "ignorePatterns": [
+    "pnpm-lock.yaml",
+    "site/src/data/**",
+    "site/public/**",
+    "_site/**",
+    "dist/**",
+    ".port-sources/**",
+    "infra/**",
+    "**/*.json",
+    "**/*.yml",
+    "**/*.yaml",
+    "**/*.cff",
+    "**/*.css",
+    "**/*.md",
+    "**/*.mdx"
+  ]
+}
diff --git a/AGENTS.md b/AGENTS.md
index 971b36373..96e7e5e27 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -11,7 +11,10 @@ requested work.
 
 - Environment, Oxlint, formatting, tests, and pull requests:
   [CONTRIBUTING.md](CONTRIBUTING.md).
-- Documentation, user-facing text, comments, and commits: [WRITING.md](WRITING.md).
+- Documentation, user-facing text, comments, commits, and any code example
+  (example programs, console recipes, Markdown code blocks):
+  [WRITING.md](WRITING.md), and its [Documented examples that
+  run](WRITING.md#documented-examples-that-run) section for code a reader sees.
 
 Each guide is the single home for its subject.
 
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index b927d5875..b859b9c91 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -47,15 +47,68 @@ Run lint across the workspace and build scripts:
 $ pnpm run lint
 ```
 
-The theme package retains Biome in its formatting script; it is not the
-workspace lint gate. This command writes changes, so review its diff:
+`oxfmt` formats the site's own TypeScript, JavaScript, and Astro source at
+120 columns, with no semicolons and single quotes. It is pinned in the pnpm
+catalog; `.oxfmtrc.json` lists what it skips. Markdown stays out because
+`site/test/complete-examples.test.ts` pins fenced programs by hash. Check
+formatting, or rewrite files in place and review the diff:
 
 ```console
-$ pnpm --filter @libtmux/theme format
+$ pnpm run format:check
+```
+
+```console
+$ pnpm run format
 ```
 
 ## Checks
 
+Hold hand-written code fences to 80 columns. The check reads
+`.github/example-width.toml`, which lists the surfaces it covers and each
+line allowed to stay wider, with its reason:
+
+```console
+$ python3 scripts/check_example_width.py
+```
+
+The `--self-test` flag plants a failure for every rule the check enforces,
+plus clean controls.
+The medium loop and the publication audit run both.
+
+The checker and the shared section of `WRITING.md` must match every other
+libtmux port. CI compares them with each port's default branch weekly, and
+on pushes to `main` and pull requests that change them or the comparison
+itself. The comparison needs the network, so it is not part of the local
+loops:
+
+```console
+$ python3 scripts/check_shared_examples.py
+```
+
+A port with no checker or shared section fails, unless the script's
+`PENDING` list names it with a reason and the date it was listed. Every
+port is pending until its example-style change merges; a pending port that
+already has both files fails until it leaves the list, and an entry older
+than 30 days fails until it is merged or given a new reason and date.
+To roll out a change to the shared text or checker, record the digests
+the ports still carry in the script's `PREVIOUS` with the last day they
+are accepted, so ports can merge one at a time.
+
+A port the script cannot read, such as a private repository, goes in
+`NOT_FETCHED` with the place it is compared instead, and the script
+prints a notice for it; every port is public, so the list is empty. The
+script also lists the public, non-archived repositories of the `libtmux`
+organisation through the GitHub REST API, and fails for any repository
+outside `PORTS` whose `WRITING.md` carries the shared section, so a new
+port cannot adopt it unseen. Set `GITHUB_TOKEN` to avoid the
+unauthenticated rate limit.
+
+The script's `--self-test` runs without the network. It plants checker
+and text drift, a missing file, a stale pending entry, an entry for an
+unknown port, a pending port with drift or with both files, a previous
+digest inside and past its window, a port it must not fetch, an unlisted
+adopter, and an unlisted repository without the markers.
+
 Run workspace type checks:
 
 ```console
@@ -118,6 +171,12 @@ Install the pinned Chromium build for local browser checks with
 that build and its system dependencies before the publication audit.
 The standard ten-second browser timeout increases to twenty seconds on CI.
 
+`site/test/code-block-width.outer.test.ts` opens a built page at 1024 and
+1280 pixels and checks that its code blocks fit 80 columns. It measures in
+Chrome, because the bundled Chromium draws the code font narrower than the
+browsers readers use. It reads the assembled `_site`, so only the
+publication audit runs it; the loops skip it.
+
 Keep the complete assembly, all output suites, link audits, source/model
 freshness, and full browser matrix in the publication audit:
 
diff --git a/WRITING.md b/WRITING.md
index 5a21a5326..9523f05b2 100644
--- a/WRITING.md
+++ b/WRITING.md
@@ -167,10 +167,92 @@ project and `main.cpp`, installs the library with its public testing component,
 and builds against that installed prefix. The native source suite checks the
 same files against private tmux servers, including operation failure and cleanup.
 
-Put explanatory comments on separate lines above the code they describe.
-Limit example comments to 100 columns, including indentation; prefer shorter
-lines that fit the code panel. Put long source links and attribution in prose
-outside the code block.
+Put long source links and attribution in prose outside the code block.
+
+<!-- shared:examples -->
+
+An example is code written for a reader: a program under `examples/`, code in
+a doc comment or docstring, and every fenced block in a README or docs page.
+Shell blocks also follow [Code blocks](#code-blocks).
+
+The text between the shared markers is the same in every libtmux port.
+Change it in all of them together.
+
+### Width
+
+- **Examples stay within 80 columns.** They render in fixed-width boxes that
+  scroll sideways, and 80 columns fits a libtmux.org code block in a
+  laptop-width window. Comments inside examples wrap at 80 too.
+- **The width check enforces it.** It reads the tracked files that
+  `.github/example-width.toml` names and fails on a wider line. It measures
+  the whole source line, so code in a doc comment counts its indent and
+  comment marker. It skips output (a fence tagged `text`, and what a
+  `console` block prints), hidden setup lines, and a line that is only a URL;
+  an untagged fence counts as code.
+- **A line that must stay wider is listed there with its reason.** An entry
+  that no longer matches a line fails the check, so no stale entry stays.
+- **The formatter's width is the hard limit for all other source.** Example
+  directories set their formatter to 80 where the formatter takes a width.
+
+### Reaching 80
+
+- **Change the code, not the line breaks.** A formatter rejoins any line that
+  fits its width. Name a sub-expression, use a short example name, hide setup
+  the reader does not need, or print less.
+- **Break at the outermost level when a break is still needed:** after an
+  opening parenthesis with one argument per line, one call per line in a
+  chain, one field per line in a literal.
+- **Put a comment on its own line above the code it explains.** Never trail
+  one after code in an example, unless the repository's example runner reads
+  it there, as with an assertion marker.
+- **Break a long string at a word boundary,** never inside a tmux format
+  (`#{...}`) or an escape sequence; the joined text stays the same.
+- **Continue a long command in a `console` block the way its shell does:**
+  `\` after a `$ ` prompt, a backtick after `PS> `, one flag per continuation
+  line.
+
+### What never breaks
+
+- **Output a test compares.** Wrapping it changes what the test expects.
+- **A block copied from a source file.** Fix the width in the source, then
+  refresh the copy with the sync command the port block names, or by hand
+  where it names none; never fix the copy alone.
+- **Marker lines and URLs,** which tools and readers take whole.
+
+<!-- /shared:examples -->
+
+### In this repository
+
+- **Hard limit:** oxfmt (`.oxfmtrc.json`, `printWidth`) formats the site's
+  own source and has no example directory to hold to 80. The width check is
+  `python3 scripts/check_example_width.py`.
+- **Not formatted:** Markdown, which oxfmt skips because
+  `site/test/complete-examples.test.ts` pins fenced programs by sha256. Hold
+  every fence to 80 by hand.
+- **Runs, compiles, exempt:**
+  [Documented examples that run](#documented-examples-that-run) decides how
+  each kind of fence runs; every kind is held to the width, including blocks
+  quoted by hand and plain fences that do not run.
+- **Compared output and copied blocks:** output a program's run compares
+  never breaks. A program or console recipe pinned in
+  `site/test/fixtures/*-examples.json` changes only together with its new
+  hash or `shellRecipe` and a new native run on both recorded tmux versions.
+  Fix a quoted block in its port source, never on the page, and refresh the
+  `file=` quotes with `node scripts/gen-example-sources.mjs` once the port's
+  pinned revision moves.
+
+Bad, over 80:
+
+```csharp
+Session session = await server.CreateSessionAsync(new NewSessionRequest(name: "work"));
+```
+
+Good, the request named in its own statement:
+
+```csharp
+NewSessionRequest request = new(name: "work");
+Session session = await server.CreateSessionAsync(request);
+```
 
 ### Examples across ports
 
@@ -322,6 +404,8 @@ Reserve GitHub alert syntax for GitHub-only material and only when a warning
 is necessary; the warning's text must stand alone. Put blank lines around
 lists and headings, and preserve existing anchors when restructuring prose.
 
+### Code blocks
+
 Code blocks are paste-and-run units:
 
 - Put one command in each block. An explicit `&&`, `;`, or `\` chain counts
diff --git a/docs/ci.md b/docs/ci.md
index 5d532def0..277e07520 100644
--- a/docs/ci.md
+++ b/docs/ci.md
@@ -228,7 +228,8 @@ jobs:
     uses: libtmux/docs/.github/workflows/port-docs.yml@<sha>
     with:
       port: rs
-      tag-prefix: libtmux@  # stripped from a release tag; omit when tags are bare
+      # stripped from a release tag; omit when tags are bare
+      tag-prefix: libtmux@
       source-ref: ${{ inputs.source-ref }}
       version: ${{ inputs.version }}
       version-kind: ${{ inputs.version-kind }}
diff --git a/notes/upstream/libtmux-cxx-doxygen-comments.md b/notes/upstream/libtmux-cxx-doxygen-comments.md
index 451e17fde..aeb5eee88 100755
--- a/notes/upstream/libtmux-cxx-doxygen-comments.md
+++ b/notes/upstream/libtmux-cxx-doxygen-comments.md
@@ -19,7 +19,9 @@ $ python3 -c "
 import re, glob
 tot = empty = 0
 for f in glob.glob('xml/*.xml'):
-    for m in re.finditer(r'<briefdescription>(.*?)</briefdescription>', open(f).read(), re.S):
+    text = open(f).read()
+    pattern = r'<briefdescription>(.*?)</briefdescription>'
+    for m in re.finditer(pattern, text, re.S):
         tot += 1
         empty += not m.group(1).strip()
 print(tot, empty)"
diff --git a/package.json b/package.json
index 2eb832492..ebe8e0d50 100644
--- a/package.json
+++ b/package.json
@@ -9,6 +9,8 @@
     "preview": "pnpm --filter @libtmux/site preview",
     "build:site": "./scripts/build-site.sh",
     "type-check": "pnpm run --recursive type-check",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
     "lint": "pnpm run --recursive lint && oxlint scripts",
     "test": "node scripts/test-loop.mjs outer",
     "test:inner": "node scripts/test-loop.mjs inner",
@@ -21,11 +23,11 @@
   },
   "packageManager": "pnpm@12.7.0",
   "devDependencies": {
-    "@biomejs/biome": "catalog:",
     "entities": "catalog:",
     "happy-dom": "catalog:",
     "mdast-util-from-markdown": "2.0.3",
     "mdast-util-to-markdown": "2.1.3",
+    "oxfmt": "catalog:",
     "oxlint": "catalog:",
     "typescript": "catalog:"
   }
diff --git a/packages/api-model/src/builtins.ts b/packages/api-model/src/builtins.ts
index e6d7f2668..ca6e4da55 100644
--- a/packages/api-model/src/builtins.ts
+++ b/packages/api-model/src/builtins.ts
@@ -25,8 +25,7 @@ const rust = (page: string) => `https://doc.rust-lang.org/std/${page}`
 const go = (page: string) => `https://pkg.go.dev/${page}`
 const cpp = (page: string) => `https://en.cppreference.com/w/cpp/${page}`
 const swift = (page: string) => `https://developer.apple.com/documentation/swift/${page}`
-const mdn = (page: string) =>
-  `https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/${page}`
+const mdn = (page: string) => `https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/${page}`
 const ts = (page: string) => `https://www.typescriptlang.org/docs/handbook/2/${page}`
 
 /** Compiler-only utilities have no JavaScript global or DOM reference on MDN. */
@@ -63,48 +62,60 @@ const coroutines = (page: string) => `https://kotlinlang.org/api/kotlinx.corouti
 const catsEffect = (name: string) => `https://typelevel.org/cats-effect/api/3.x/cats/effect/kernel/${name}.html`
 
 /** Imports and unqualified references share the same verified destination. */
-const qualifiedKotlin = Object.fromEntries([
-  ['kotlin.time.Duration', kotlin('kotlin.time/-duration')],
-  ['kotlin.time.toKotlinDuration', kotlin('kotlin.time').replace(/\/$/, '/to-kotlin-duration.html')],
-  ['kotlin.time.toJavaDuration', kotlin('kotlin.time').replace(/\/$/, '/to-java-duration.html')],
-  ['kotlinx.coroutines.CoroutineScope', coroutines('kotlinx.coroutines/-coroutine-scope/')],
-  ['kotlinx.coroutines.CoroutineDispatcher', coroutines('kotlinx.coroutines/-coroutine-dispatcher/')],
-  ['kotlinx.coroutines.Dispatchers', coroutines('kotlinx.coroutines/-dispatchers/')],
-  ['kotlinx.coroutines.Dispatchers.IO', coroutines('kotlinx.coroutines/-dispatchers/-i-o.html')],
-  ['kotlinx.coroutines.Dispatchers.Default', coroutines('kotlinx.coroutines/-dispatchers/-default.html')],
-  ['kotlinx.coroutines.NonCancellable', coroutines('kotlinx.coroutines/-non-cancellable/')],
-  ['kotlinx.coroutines.launch', coroutines('kotlinx.coroutines/launch.html')],
-  ['kotlinx.coroutines.coroutineScope', coroutines('kotlinx.coroutines/coroutine-scope.html')],
-  ['kotlinx.coroutines.withContext', coroutines('kotlinx.coroutines/with-context.html')],
-  ['kotlinx.coroutines.runInterruptible', coroutines('kotlinx.coroutines/run-interruptible.html')],
-  ['kotlinx.coroutines.flow.Flow', coroutines('kotlinx.coroutines.flow/-flow/')],
-  ['kotlinx.coroutines.flow.StateFlow', coroutines('kotlinx.coroutines.flow/-state-flow/')],
-  ['kotlinx.coroutines.flow.MutableStateFlow', coroutines('kotlinx.coroutines.flow/-mutable-state-flow/')],
-].flatMap(([name, href]) => [[name!, href!], [name!.replace(/^kotlin(?:x\.coroutines(?:\.flow)?|\.time)\./, ''), href!]]))
+const qualifiedKotlin = Object.fromEntries(
+  [
+    ['kotlin.time.Duration', kotlin('kotlin.time/-duration')],
+    ['kotlin.time.toKotlinDuration', kotlin('kotlin.time').replace(/\/$/, '/to-kotlin-duration.html')],
+    ['kotlin.time.toJavaDuration', kotlin('kotlin.time').replace(/\/$/, '/to-java-duration.html')],
+    ['kotlinx.coroutines.CoroutineScope', coroutines('kotlinx.coroutines/-coroutine-scope/')],
+    ['kotlinx.coroutines.CoroutineDispatcher', coroutines('kotlinx.coroutines/-coroutine-dispatcher/')],
+    ['kotlinx.coroutines.Dispatchers', coroutines('kotlinx.coroutines/-dispatchers/')],
+    ['kotlinx.coroutines.Dispatchers.IO', coroutines('kotlinx.coroutines/-dispatchers/-i-o.html')],
+    ['kotlinx.coroutines.Dispatchers.Default', coroutines('kotlinx.coroutines/-dispatchers/-default.html')],
+    ['kotlinx.coroutines.NonCancellable', coroutines('kotlinx.coroutines/-non-cancellable/')],
+    ['kotlinx.coroutines.launch', coroutines('kotlinx.coroutines/launch.html')],
+    ['kotlinx.coroutines.coroutineScope', coroutines('kotlinx.coroutines/coroutine-scope.html')],
+    ['kotlinx.coroutines.withContext', coroutines('kotlinx.coroutines/with-context.html')],
+    ['kotlinx.coroutines.runInterruptible', coroutines('kotlinx.coroutines/run-interruptible.html')],
+    ['kotlinx.coroutines.flow.Flow', coroutines('kotlinx.coroutines.flow/-flow/')],
+    ['kotlinx.coroutines.flow.StateFlow', coroutines('kotlinx.coroutines.flow/-state-flow/')],
+    ['kotlinx.coroutines.flow.MutableStateFlow', coroutines('kotlinx.coroutines.flow/-mutable-state-flow/')],
+  ].flatMap(([name, href]) => [
+    [name!, href!],
+    [name!.replace(/^kotlin(?:x\.coroutines(?:\.flow)?|\.time)\./, ''), href!],
+  ]),
+)
 const qualifiedScala = Object.fromEntries([
   ...['Async', 'Deferred', 'Outcome', 'Resource', 'Fiber', 'Ref'].flatMap((name) =>
-    [name, `cats.effect.${name}`, `cats.effect.kernel.${name}`].map((alias) => [alias, catsEffect(name)])),
+    [name, `cats.effect.${name}`, `cats.effect.kernel.${name}`].map((alias) => [alias, catsEffect(name)]),
+  ),
   ...['Signal', 'SignallingRef'].flatMap((name) =>
-    [name, `fs2.concurrent.${name}`].map((alias) => [alias, `https://javadoc.io/static/co.fs2/fs2-core_3/3.13.0/fs2/concurrent/${name}.html`])),
+    [name, `fs2.concurrent.${name}`].map((alias) => [
+      alias,
+      `https://javadoc.io/static/co.fs2/fs2-core_3/3.13.0/fs2/concurrent/${name}.html`,
+    ]),
+  ),
 ])
 
-const qualifiedDotnetExceptions = Object.fromEntries([
-  'System.Exception',
-  'System.ArgumentException',
-  'System.ArgumentNullException',
-  'System.ArgumentOutOfRangeException',
-  'System.InvalidOperationException',
-  'System.NotSupportedException',
-  'System.ObjectDisposedException',
-  'System.TimeoutException',
-  'System.FormatException',
-  'System.OperationCanceledException',
-  'System.IO.InvalidDataException',
-  'System.IO.IOException',
-  'System.Text.RegularExpressions.RegexMatchTimeoutException',
-  'System.Text.Json.JsonException',
-  'System.Threading.Tasks.TaskCanceledException',
-].flatMap((name) => [name, name.split('.').at(-1)!].map((alias) => [alias, dotnet(name.toLowerCase())])))
+const qualifiedDotnetExceptions = Object.fromEntries(
+  [
+    'System.Exception',
+    'System.ArgumentException',
+    'System.ArgumentNullException',
+    'System.ArgumentOutOfRangeException',
+    'System.InvalidOperationException',
+    'System.NotSupportedException',
+    'System.ObjectDisposedException',
+    'System.TimeoutException',
+    'System.FormatException',
+    'System.OperationCanceledException',
+    'System.IO.InvalidDataException',
+    'System.IO.IOException',
+    'System.Text.RegularExpressions.RegexMatchTimeoutException',
+    'System.Text.Json.JsonException',
+    'System.Threading.Tasks.TaskCanceledException',
+  ].flatMap((name) => [name, name.split('.').at(-1)!].map((alias) => [alias, dotnet(name.toLowerCase())])),
+)
 
 export const BUILTINS: Record<string, Record<string, string>> = {
   julia: {
@@ -113,48 +124,76 @@ export const BUILTINS: Record<string, Record<string, string>> = {
     'Core.String': 'https://docs.julialang.org/en/v1/base/strings/#Core.String-Tuple%7BAbstractString%7D',
   },
   powershell: {
-    ...Object.fromEntries(Object.entries({
-      'Get-Member': 'microsoft.powershell.utility',
-      'Where-Object': 'microsoft.powershell.core',
-      'Invoke-WebRequest': 'microsoft.powershell.utility',
-      'Start-ThreadJob': 'threadjob',
-      'Receive-Job': 'microsoft.powershell.core',
-      'Set-Content': 'microsoft.powershell.management',
-    }).map(([name, module]) => [name,
-      `https://learn.microsoft.com/powershell/module/${module}/${name.toLowerCase()}?view=powershell-7.4`])),
+    ...Object.fromEntries(
+      Object.entries({
+        'Get-Member': 'microsoft.powershell.utility',
+        'Where-Object': 'microsoft.powershell.core',
+        'Invoke-WebRequest': 'microsoft.powershell.utility',
+        'Start-ThreadJob': 'threadjob',
+        'Receive-Job': 'microsoft.powershell.core',
+        'Set-Content': 'microsoft.powershell.management',
+      }).map(([name, module]) => [
+        name,
+        `https://learn.microsoft.com/powershell/module/${module}/${name.toLowerCase()}?view=powershell-7.4`,
+      ]),
+    ),
     FileInfo: dotnet('system.io.fileinfo'),
     ApplicationInfo: `${dotnet('system.management.automation.applicationinfo')}?view=powershellsdk-7.4.0`,
-    ...Object.fromEntries([
-      'ArgumentCompleter', 'ValidateCount', 'ValidateLength', 'ValidateNotNull',
-      'ValidateNotNullOrEmpty', 'ValidatePattern', 'ValidateRange', 'ValidateSet',
-    ].map((name) => [`System.Management.Automation.${name}Attribute`,
-      `${dotnet(`system.management.automation.${name.toLowerCase()}attribute`)}?view=powershellsdk-7.4.0`])),
-    ...Object.fromEntries(['String', 'Int32', 'Int64', 'Double', 'Boolean', 'Object', 'IO.FileInfo', 'Collections.IDictionary']
-      .map((name) => [`System.${name}`, dotnet(`system.${name.toLowerCase()}`)])),
+    ...Object.fromEntries(
+      [
+        'ArgumentCompleter',
+        'ValidateCount',
+        'ValidateLength',
+        'ValidateNotNull',
+        'ValidateNotNullOrEmpty',
+        'ValidatePattern',
+        'ValidateRange',
+        'ValidateSet',
+      ].map((name) => [
+        `System.Management.Automation.${name}Attribute`,
+        `${dotnet(`system.management.automation.${name.toLowerCase()}attribute`)}?view=powershellsdk-7.4.0`,
+      ]),
+    ),
+    ...Object.fromEntries(
+      ['String', 'Int32', 'Int64', 'Double', 'Boolean', 'Object', 'IO.FileInfo', 'Collections.IDictionary'].map(
+        (name) => [`System.${name}`, dotnet(`system.${name.toLowerCase()}`)],
+      ),
+    ),
     'System.Nullable': dotnet('system.nullable-1'),
     'System.Management.Automation.SwitchParameter': `${dotnet('system.management.automation.switchparameter')}?view=powershellsdk-7.4.0`,
     'System.Management.Automation.ActionPreference': `${dotnet('system.management.automation.actionpreference')}?view=powershellsdk-7.4.0`,
-    CommonParameters: 'https://learn.microsoft.com/powershell/module/microsoft.powershell.core/about/about_commonparameters?view=powershell-7.4',
+    CommonParameters:
+      'https://learn.microsoft.com/powershell/module/microsoft.powershell.core/about/about_commonparameters?view=powershell-7.4',
   },
   kotlin: {
     ...qualifiedKotlin,
     suspend: 'https://kotlinlang.org/docs/coroutines-basics.html#suspending-functions',
     finally: 'https://kotlinlang.org/docs/exceptions.html#finally-block',
-    String: kotlin('kotlin/-string'), Boolean: kotlin('kotlin/-boolean'),
-    Int: kotlin('kotlin/-int'), Long: kotlin('kotlin/-long'),
-    Unit: kotlin('kotlin/-unit'), Any: kotlin('kotlin/-any'),
-    List: kotlin('kotlin.collections/-list'), Map: kotlin('kotlin.collections/-map'),
+    String: kotlin('kotlin/-string'),
+    Boolean: kotlin('kotlin/-boolean'),
+    Int: kotlin('kotlin/-int'),
+    Long: kotlin('kotlin/-long'),
+    Unit: kotlin('kotlin/-unit'),
+    Any: kotlin('kotlin/-any'),
+    List: kotlin('kotlin.collections/-list'),
+    Map: kotlin('kotlin.collections/-map'),
     Iterable: kotlin('kotlin.collections/-iterable'),
     Flow: 'https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-flow/',
-    StateFlow: 'https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-state-flow/',
-    'collect()': 'https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/collect.html',
+    StateFlow:
+      'https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/-state-flow/',
+    'collect()':
+      'https://kotlinlang.org/api/kotlinx.coroutines/kotlinx-coroutines-core/kotlinx.coroutines.flow/collect.html',
     'singleOrNull()': 'https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.collections/single-or-null.html',
   },
   scala: {
     ...qualifiedScala,
-    String: scala('scala/Predef$'), Boolean: scala('scala/Boolean'),
-    Int: scala('scala/Int'), Long: scala('scala/Long'), Unit: scala('scala/Unit'),
-    Option: scala('scala/Option'), Either: scala('scala/util/Either'),
+    String: scala('scala/Predef$'),
+    Boolean: scala('scala/Boolean'),
+    Int: scala('scala/Int'),
+    Long: scala('scala/Long'),
+    Unit: scala('scala/Unit'),
+    Option: scala('scala/Option'),
+    Either: scala('scala/util/Either'),
     Vector: scala('scala/collection/immutable/Vector'),
     List: scala('scala/collection/immutable/List'),
     IterableOnce: scala('scala/collection/IterableOnce'),
@@ -170,8 +209,10 @@ export const BUILTINS: Record<string, Record<string, string>> = {
     option: fsharp('fsharp-core-fsharpoption-1'),
     list: fsharp('fsharp-collections-fsharplist-1'),
     seq: dotnet('system.collections.generic.ienumerable-1'),
-    string: dotnet('system.string'), bool: dotnet('system.boolean'),
-    int: dotnet('system.int32'), int64: dotnet('system.int64'),
+    string: dotnet('system.string'),
+    bool: dotnet('system.boolean'),
+    int: dotnet('system.int32'),
+    int64: dotnet('system.int64'),
     Task: dotnet('system.threading.tasks.task'),
     CancellationToken: dotnet('system.threading.cancellationtoken'),
     IReadOnlyList: dotnet('system.collections.generic.ireadonlylist-1'),
@@ -366,7 +407,8 @@ export const BUILTINS: Record<string, Record<string, string>> = {
     ...TYPESCRIPT_UTILITY_TYPES,
   },
   java: {
-    ExtensionContext: 'https://docs.junit.org/current/api/org.junit.jupiter.api/org/junit/jupiter/api/extension/ExtensionContext.html',
+    ExtensionContext:
+      'https://docs.junit.org/current/api/org.junit.jupiter.api/org/junit/jupiter/api/extension/ExtensionContext.html',
     boolean: 'https://docs.oracle.com/javase/specs/jls/se21/html/jls-4.html#jls-4.2.5',
     int: 'https://docs.oracle.com/javase/specs/jls/se21/html/jls-4.html#jls-4.2.1',
     long: 'https://docs.oracle.com/javase/specs/jls/se21/html/jls-4.html#jls-4.2.1',
@@ -377,9 +419,10 @@ export const BUILTINS: Record<string, Record<string, string>> = {
   // the subtype 5.3 added and LuaLS spells separately. `any` and `unknown`
   // are LuaLS annotation types, with no counterpart in the language.
   lua: Object.fromEntries([
-    ...['nil', 'boolean', 'number', 'integer', 'string', 'function', 'table', 'thread', 'userdata'].map(
-      (name) => [name, 'https://www.lua.org/manual/5.4/manual.html#2.1'],
-    ),
+    ...['nil', 'boolean', 'number', 'integer', 'string', 'function', 'table', 'thread', 'userdata'].map((name) => [
+      name,
+      'https://www.lua.org/manual/5.4/manual.html#2.1',
+    ]),
     ...['any', 'unknown'].map((name) => [name, 'https://luals.github.io/wiki/annotations/#documenting-types']),
   ]),
   py: {
@@ -394,8 +437,11 @@ export function builtinHref(port: string, name: string): string | undefined {
   if (!Object.hasOwn(BUILTINS, port)) return undefined
   const types = BUILTINS[port]!
   if (Object.hasOwn(types, name)) return types[name]
-  const nativeName = port === 'kotlin'
-    ? name.replace(/^kotlin\.(?:collections\.)?/, '')
-    : port === 'scala' ? name.replace(/^scala\.(?:Predef\.|collection\.(?:immutable\.)?|util\.)?/, '') : name
+  const nativeName =
+    port === 'kotlin'
+      ? name.replace(/^kotlin\.(?:collections\.)?/, '')
+      : port === 'scala'
+        ? name.replace(/^scala\.(?:Predef\.|collection\.(?:immutable\.)?|util\.)?/, '')
+        : name
   return Object.hasOwn(types, nativeName) ? types[nativeName] : undefined
 }
diff --git a/packages/api-model/src/concepts.ts b/packages/api-model/src/concepts.ts
index 4293449ac..15b1f3e6e 100644
--- a/packages/api-model/src/concepts.ts
+++ b/packages/api-model/src/concepts.ts
@@ -47,8 +47,10 @@ export const CONCEPTS: Record<string, Concept> = {
       julia: 'LibTmuxWorkspace.apply',
     },
     notes: {
-      powershell: 'Applies the exact reviewed `-Plan` after PowerShell confirmation. `-WhatIf` previews without applying it; application is detached.',
-      julia: 'Applies a prepared `WorkspacePlan` on an explicit `Server`, detached and under one deadline. Existing session names fail unless reuse is explicit.',
+      powershell:
+        'Applies the exact reviewed `-Plan` after PowerShell confirmation. `-WhatIf` previews without applying it; application is detached.',
+      julia:
+        'Applies a prepared `WorkspacePlan` on an explicit `Server`, detached and under one deadline. Existing session names fail unless reuse is explicit.',
     },
   },
   'freeze-workspace': {
@@ -257,7 +259,7 @@ export const CONCEPTS: Record<string, Concept> = {
     },
   },
   'rotate-panes': {
-    label: "Rotate panes within a window",
+    label: 'Rotate panes within a window',
     symbols: {
       py: 'libtmux.Window.rotate',
       ts: 'window.Window.rotate',
@@ -331,7 +333,7 @@ export const CONCEPTS: Record<string, Concept> = {
     },
   },
   'window-session': {
-    label: "Find the session containing a window placement",
+    label: 'Find the session containing a window placement',
     parentObject: 'session',
     symbols: {
       kotlin: 'io.github.libtmux.kotlin.Window.session',
@@ -1755,7 +1757,7 @@ export const CONCEPTS: Record<string, Concept> = {
       cxx: '`Server::tmux_version` asks the executable with `tmux -V` without reaching a server',
     },
   },
-  'snapshot': {
+  snapshot: {
     label: 'Capture the tmux hierarchy',
     symbols: {
       scala: 'io.github.libtmux.scaladsl.Server.snapshot',
@@ -3688,21 +3690,34 @@ const LUA_CONCEPTS: Record<string, string> = {
 // These Cats Effect operations forward to the corresponding Java handle;
 // their execution and ownership differ, while the tmux operation is shared.
 const SCALA_EFFECT_CONCEPTS: Record<string, string> = {
-  server: 'Server', session: 'Session', window: 'Window', pane: 'Pane',
-  'capture-pane': 'Pane.capture', 'send-keys': 'Pane.sendKeys',
-  'split-pane': 'Pane.split', 'split-window': 'Window.split',
-  'new-session': 'Server.newSession', 'new-window': 'Session.newWindow',
-  'kill-server': 'Server.killServer', 'list-sessions': 'Server.sessions',
-  'list-windows': 'Session.windows', 'list-panes': 'Window.panes',
-  'list-server-windows': 'Server.windows', 'list-server-panes': 'Server.panes',
-  'list-clients': 'Server.clients', snapshot: 'Server.snapshot',
-  'pane-window': 'Pane.window', 'window-session': 'Window.session',
-  'session-server': 'Session.server', 'window-server': 'Window.server',
-  'pane-server': 'Pane.server', 'client-server': 'Client.server',
+  server: 'Server',
+  session: 'Session',
+  window: 'Window',
+  pane: 'Pane',
+  'capture-pane': 'Pane.capture',
+  'send-keys': 'Pane.sendKeys',
+  'split-pane': 'Pane.split',
+  'split-window': 'Window.split',
+  'new-session': 'Server.newSession',
+  'new-window': 'Session.newWindow',
+  'kill-server': 'Server.killServer',
+  'list-sessions': 'Server.sessions',
+  'list-windows': 'Session.windows',
+  'list-panes': 'Window.panes',
+  'list-server-windows': 'Server.windows',
+  'list-server-panes': 'Server.panes',
+  'list-clients': 'Server.clients',
+  snapshot: 'Server.snapshot',
+  'pane-window': 'Pane.window',
+  'window-session': 'Window.session',
+  'session-server': 'Session.server',
+  'window-server': 'Window.server',
+  'pane-server': 'Pane.server',
+  'client-server': 'Client.server',
   'client-session': 'Client.session',
 }
 for (const [id, symbol] of Object.entries(SCALA_EFFECT_CONCEPTS)) {
-  const variants = CONCEPTS[id]!.variants ??= {}
+  const variants = (CONCEPTS[id]!.variants ??= {})
   variants.scala = [...(variants.scala ?? []), `io.github.libtmux.scaladsl.cats.${symbol}`]
 }
 for (const [id, symbol] of Object.entries(RUBY_CONCEPTS)) CONCEPTS[id]!.symbols.ruby = symbol
@@ -3713,63 +3728,171 @@ for (const [id, symbol] of Object.entries(LUA_CONCEPTS)) CONCEPTS[id]!.symbols.l
 // Keep those distinctions with the mappings instead of inventing facade classes.
 const HIERARCHY_CONCEPTS: Record<string, Record<string, { symbol: string; note: string; variants?: string[] }>> = {
   server: {
-    powershell: { symbol: 'LibTmux\\New-TmuxServer', note: 'This cmdlet constructs a shared .NET `LibTmux.Server` handle without contacting tmux.' },
-    julia: { symbol: 'LibTmux.Server', note: '`Server` describes an endpoint without contacting tmux. Read its hierarchy with `snapshot`.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Server', note: 'This F# module provides functions over the shared .NET `LibTmux.Server` type.' },
+    powershell: {
+      symbol: 'LibTmux\\New-TmuxServer',
+      note: 'This cmdlet constructs a shared .NET `LibTmux.Server` handle without contacting tmux.',
+    },
+    julia: {
+      symbol: 'LibTmux.Server',
+      note: '`Server` describes an endpoint without contacting tmux. Read its hierarchy with `snapshot`.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Server',
+      note: 'This F# module provides functions over the shared .NET `LibTmux.Server` type.',
+    },
   },
   session: {
-    powershell: { symbol: 'LibTmux\\Get-TmuxSession', note: 'This cmdlet reads and returns shared .NET `LibTmux.Session` objects. Child windows and panes require further acquisition.' },
-    julia: { symbol: 'LibTmux.SessionSnapshot', variants: ['LibTmux.SessionRef'], note: '`SessionSnapshot` holds captured session data. Actions use its `SessionRef`, a typed identity bound to an observed daemon generation.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Session', note: 'This F# module builds deferred child queries from a shared .NET `LibTmux.Session` and its server association. `Query.list` acquires their results from tmux.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxSession',
+      note: 'This cmdlet reads and returns shared .NET `LibTmux.Session` objects. Child windows and panes require further acquisition.',
+    },
+    julia: {
+      symbol: 'LibTmux.SessionSnapshot',
+      variants: ['LibTmux.SessionRef'],
+      note: '`SessionSnapshot` holds captured session data. Actions use its `SessionRef`, a typed identity bound to an observed daemon generation.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Session',
+      note: 'This F# module builds deferred child queries from a shared .NET `LibTmux.Session` and its server association. `Query.list` acquires their results from tmux.',
+    },
   },
   window: {
-    powershell: { symbol: 'LibTmux\\Get-TmuxWindow', note: 'This cmdlet reads shared .NET `LibTmux.Window` placements. Use `-Server` for all sessions or `-Session` for one session.' },
-    julia: { symbol: 'LibTmux.WindowSnapshot', variants: ['LibTmux.WindowRef'], note: '`WindowSnapshot` holds captured physical-window data. `WindowLink` records a placement in a session; actions use `WindowRef`.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Window', note: 'This F# module identifies shared .NET `LibTmux.Window` placements and builds deferred pane queries. `Query.list` acquires their results from tmux.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxWindow',
+      note: 'This cmdlet reads shared .NET `LibTmux.Window` placements. Use `-Server` for all sessions or `-Session` for one session.',
+    },
+    julia: {
+      symbol: 'LibTmux.WindowSnapshot',
+      variants: ['LibTmux.WindowRef'],
+      note: '`WindowSnapshot` holds captured physical-window data. `WindowLink` records a placement in a session; actions use `WindowRef`.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Window',
+      note: 'This F# module identifies shared .NET `LibTmux.Window` placements and builds deferred pane queries. `Query.list` acquires their results from tmux.',
+    },
   },
   pane: {
-    powershell: { symbol: 'LibTmux\\Get-TmuxPane', note: 'This cmdlet reads shared .NET `LibTmux.Pane` objects. Its `-Server`, `-Session`, and `-Window` parameter sets select the scope.' },
-    julia: { symbol: 'LibTmux.PaneSnapshot', variants: ['LibTmux.PaneRef'], note: '`PaneSnapshot` holds captured pane data. Actions use its `PaneRef`; `PaneOccurrence` adds a window placement in a session.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Pane', note: 'This F# module reads captured fields and starts explicit operations on the shared .NET `LibTmux.Pane` type.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxPane',
+      note: 'This cmdlet reads shared .NET `LibTmux.Pane` objects. Its `-Server`, `-Session`, and `-Window` parameter sets select the scope.',
+    },
+    julia: {
+      symbol: 'LibTmux.PaneSnapshot',
+      variants: ['LibTmux.PaneRef'],
+      note: '`PaneSnapshot` holds captured pane data. Actions use its `PaneRef`; `PaneOccurrence` adds a window placement in a session.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Pane',
+      note: 'This F# module reads captured fields and starts explicit operations on the shared .NET `LibTmux.Pane` type.',
+    },
   },
   'list-sessions': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxSession', note: 'Acquires sessions through `-Server`, with optional exact `-Id` and `-Name` selectors.' },
-    julia: { symbol: 'LibTmux.sessions', note: '`sessions` reads membership from a captured `Snapshot` without contacting tmux.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Server.sessions', note: 'Builds a deferred session query on `LibTmux.Server`. `Query.list` acquires the results; it does not traverse the handle’s captured membership.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxSession',
+      note: 'Acquires sessions through `-Server`, with optional exact `-Id` and `-Name` selectors.',
+    },
+    julia: {
+      symbol: 'LibTmux.sessions',
+      note: '`sessions` reads membership from a captured `Snapshot` without contacting tmux.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Server.sessions',
+      note: 'Builds a deferred session query on `LibTmux.Server`. `Query.list` acquires the results; it does not traverse the handle’s captured membership.',
+    },
   },
   'list-windows': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxWindow', note: 'Use the `-Session` parameter set to acquire placements in one session.' },
-    julia: { symbol: 'LibTmux.windows', note: '`windows` with a captured `SessionSnapshot` reads distinct physical windows in that session. Use `windowlinks` for placements.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Session.windows', note: 'Builds a deferred window query from one `LibTmux.Session` and its server. `Query.list` acquires placements scoped to that session ID.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxWindow',
+      note: 'Use the `-Session` parameter set to acquire placements in one session.',
+    },
+    julia: {
+      symbol: 'LibTmux.windows',
+      note: '`windows` with a captured `SessionSnapshot` reads distinct physical windows in that session. Use `windowlinks` for placements.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Session.windows',
+      note: 'Builds a deferred window query from one `LibTmux.Session` and its server. `Query.list` acquires placements scoped to that session ID.',
+    },
   },
   'list-panes': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxPane', note: 'Use the `-Window` parameter set to acquire panes in one window.' },
-    julia: { symbol: 'LibTmux.panes', note: '`panes` with a captured `WindowSnapshot` reads panes in that window; missing coverage is an error.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Window.panes', note: 'Builds a deferred pane query from one `LibTmux.Window` and its server. `Query.list` acquires panes scoped to that window ID.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxPane',
+      note: 'Use the `-Window` parameter set to acquire panes in one window.',
+    },
+    julia: {
+      symbol: 'LibTmux.panes',
+      note: '`panes` with a captured `WindowSnapshot` reads panes in that window; missing coverage is an error.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Window.panes',
+      note: 'Builds a deferred pane query from one `LibTmux.Window` and its server. `Query.list` acquires panes scoped to that window ID.',
+    },
   },
   'list-session-panes': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxPane', note: 'Use the `-Session` parameter set to acquire panes across that session’s windows.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Session.panes', note: 'Builds a deferred pane query from one `LibTmux.Session` and its server. `Query.list` acquires panes across that session’s windows.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxPane',
+      note: 'Use the `-Session` parameter set to acquire panes across that session’s windows.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Session.panes',
+      note: 'Builds a deferred pane query from one `LibTmux.Session` and its server. `Query.list` acquires panes across that session’s windows.',
+    },
   },
   'list-server-windows': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxWindow', note: 'Use the `-Server` parameter set to acquire window placements across all sessions.' },
-    julia: { symbol: 'LibTmux.windows', note: '`windows` with a `Snapshot` reads every captured physical window. Use `windowlinks` for session placements.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Server.windows', note: 'Builds a deferred query for placements across all sessions. `Query.list` acquires the results; a linked window appears once for each session placement.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxWindow',
+      note: 'Use the `-Server` parameter set to acquire window placements across all sessions.',
+    },
+    julia: {
+      symbol: 'LibTmux.windows',
+      note: '`windows` with a `Snapshot` reads every captured physical window. Use `windowlinks` for session placements.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Server.windows',
+      note: 'Builds a deferred query for placements across all sessions. `Query.list` acquires the results; a linked window appears once for each session placement.',
+    },
   },
   'list-server-panes': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxPane', note: 'Use the `-Server` parameter set to acquire panes across the server.' },
-    julia: { symbol: 'LibTmux.panes', note: '`panes` with a `Snapshot` reads every captured physical pane. Use `paneoccurrences` for session placements.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Server.panes', note: 'Builds a deferred pane query on the shared .NET `LibTmux.Server`. `Query.list` acquires panes across that server.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxPane',
+      note: 'Use the `-Server` parameter set to acquire panes across the server.',
+    },
+    julia: {
+      symbol: 'LibTmux.panes',
+      note: '`panes` with a `Snapshot` reads every captured physical pane. Use `paneoccurrences` for session placements.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Server.panes',
+      note: 'Builds a deferred pane query on the shared .NET `LibTmux.Server`. `Query.list` acquires panes across that server.',
+    },
   },
   'list-clients': {
-    powershell: { symbol: 'LibTmux\\Get-TmuxClient', note: 'Acquires attached clients through `-Server` and returns shared .NET `LibTmux.Client` objects.' },
-    julia: { symbol: 'LibTmux.clients', note: '`clients` reads attached clients from a captured `Snapshot` without contacting tmux.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Server.clients', note: 'Builds a deferred client query on the shared .NET `LibTmux.Server`. `Query.list` acquires attached clients.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxClient',
+      note: 'Acquires attached clients through `-Server` and returns shared .NET `LibTmux.Client` objects.',
+    },
+    julia: {
+      symbol: 'LibTmux.clients',
+      note: '`clients` reads attached clients from a captured `Snapshot` without contacting tmux.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Server.clients',
+      note: 'Builds a deferred client query on the shared .NET `LibTmux.Server`. `Query.list` acquires attached clients.',
+    },
   },
   snapshot: {
-    powershell: { symbol: 'LibTmux\\Get-TmuxSnapshot', note: 'Acquires a replacement `LibTmux.Server` to `-Depth` (panes by default). Acquisition is not atomic; retained handles do not refresh.' },
-    julia: { symbol: 'LibTmux.snapshot', note: 'Acquires a new `Snapshot` over an observation interval. Topology checks do not make it a transaction; earlier snapshots do not refresh.' },
-    fsharp: { symbol: 'LibTmux.FSharp.Server.capture', note: 'Acquires a replacement shared .NET `LibTmux.Server` to the requested depth. Acquisition is not atomic; retained handles do not refresh.' },
+    powershell: {
+      symbol: 'LibTmux\\Get-TmuxSnapshot',
+      note: 'Acquires a replacement `LibTmux.Server` to `-Depth` (panes by default). Acquisition is not atomic; retained handles do not refresh.',
+    },
+    julia: {
+      symbol: 'LibTmux.snapshot',
+      note: 'Acquires a new `Snapshot` over an observation interval. Topology checks do not make it a transaction; earlier snapshots do not refresh.',
+    },
+    fsharp: {
+      symbol: 'LibTmux.FSharp.Server.capture',
+      note: 'Acquires a replacement shared .NET `LibTmux.Server` to the requested depth. Acquisition is not atomic; retained handles do not refresh.',
+    },
   },
 }
 for (const [id, ports] of Object.entries(HIERARCHY_CONCEPTS)) {
@@ -3780,16 +3903,22 @@ for (const [id, ports] of Object.entries(HIERARCHY_CONCEPTS)) {
     if (binding.variants) (concept.variants ??= {})[port] = binding.variants
   }
 }
-CONCEPTS['list-session-panes']!.absent!.julia = 'Traverse `windows(session)` and `panes(window)` in the captured snapshot. `panes(snapshot)` has server-wide scope.'
+CONCEPTS['list-session-panes']!.absent!.julia =
+  'Traverse `windows(session)` and `panes(window)` in the captured snapshot. `panes(snapshot)` has server-wide scope.'
 for (const concept of Object.values(CONCEPTS)) {
   concept.absent ??= {}
-  if (!concept.symbols.powershell) concept.absent.powershell ??= 'No source-verified PowerShell equivalent is recorded for this operation.'
-  if (!concept.symbols.julia) concept.absent.julia ??= 'No source-verified Julia equivalent is recorded for this operation.'
+  if (!concept.symbols.powershell)
+    concept.absent.powershell ??= 'No source-verified PowerShell equivalent is recorded for this operation.'
+  if (!concept.symbols.julia)
+    concept.absent.julia ??= 'No source-verified Julia equivalent is recorded for this operation.'
   if (!concept.symbols.ruby) concept.absent.ruby = 'No source-verified Ruby equivalent is recorded for this operation.'
   if (!concept.symbols.lua) concept.absent.lua = 'No source-verified Lua equivalent is recorded for this operation.'
-  if (!concept.symbols.kotlin) concept.absent.kotlin = 'No source-verified Kotlin equivalent is recorded for this operation.'
-  if (!concept.symbols.scala) concept.absent.scala = 'No source-verified Scala equivalent is recorded for this operation.'
-  if (!concept.symbols.fsharp) concept.absent.fsharp = 'No source-verified F# equivalent is recorded for this operation.'
+  if (!concept.symbols.kotlin)
+    concept.absent.kotlin = 'No source-verified Kotlin equivalent is recorded for this operation.'
+  if (!concept.symbols.scala)
+    concept.absent.scala = 'No source-verified Scala equivalent is recorded for this operation.'
+  if (!concept.symbols.fsharp)
+    concept.absent.fsharp = 'No source-verified F# equivalent is recorded for this operation.'
 }
 
 /** Every concept naming this symbol, including concepts sharing an overload group. */
diff --git a/packages/api-model/src/doc/csharp.ts b/packages/api-model/src/doc/csharp.ts
index 5d7cbd739..24063871e 100644
--- a/packages/api-model/src/doc/csharp.ts
+++ b/packages/api-model/src/doc/csharp.ts
@@ -40,8 +40,7 @@ function sections(xml: string, tag: string): { attrs: string; body: string }[] {
   return out
 }
 
-const attr = (attrs: string, name: string): string | undefined =>
-  new RegExp(`${name}="([^"]*)"`).exec(attrs)?.[1]
+const attr = (attrs: string, name: string): string | undefined => new RegExp(`${name}="([^"]*)"`).exec(attrs)?.[1]
 
 /**
  * Tag soup to prose, keeping the marks a reader sees.
diff --git a/packages/api-model/src/doc/javadoc.ts b/packages/api-model/src/doc/javadoc.ts
index fd9e91c87..86e7afc82 100644
--- a/packages/api-model/src/doc/javadoc.ts
+++ b/packages/api-model/src/doc/javadoc.ts
@@ -46,7 +46,10 @@ export function javadocToMarkdown(raw: string): string {
   // libtmux-java's sits at the start of a line that a blank line already
   // precedes, so the tag is all that has to go.
   text = text.replace(/^([ \t]*)<\/?p>[ \t]*/gm, '$1')
-  text = text.replace(/^([ \t]*)<h([1-6])>([\s\S]*?)<\/h\2>[ \t]*$/gm, (_, i, l, t) => `${i}${'#'.repeat(Number(l))} ${t}`)
+  text = text.replace(
+    /^([ \t]*)<h([1-6])>([\s\S]*?)<\/h\2>[ \t]*$/gm,
+    (_, i, l, t) => `${i}${'#'.repeat(Number(l))} ${t}`,
+  )
   text = text.replace(/^([ \t]*)<li>([\s\S]*?)(?:<\/li>)?[ \t]*$/gm, '$1- $2')
   text = text.replace(/^[ \t]*<\/?[uo]l>[ \t]*$\n?/gm, '')
   text = text.replace(/<br\s*\/?>/g, '  \n')
diff --git a/packages/api-model/src/doc/markdown.ts b/packages/api-model/src/doc/markdown.ts
index 94d727fb3..505c9d922 100644
--- a/packages/api-model/src/doc/markdown.ts
+++ b/packages/api-model/src/doc/markdown.ts
@@ -226,9 +226,7 @@ export function parseMarkdownDocFull(raw: string, defaultLang = 'text'): ParsedM
       const rest = block[2] ?? ''
       const needsName = kind === 'param' || kind === 'throws'
       const [first, ...tail] = rest.split(/\s+/)
-      tag = needsName
-        ? { kind, name: first || undefined, text: tail }
-        : { kind, text: rest ? [rest] : [] }
+      tag = needsName ? { kind, name: first || undefined, text: tail } : { kind, text: rest ? [rest] : [] }
       continue
     }
     if (tag) {
diff --git a/packages/api-model/src/doc/python.ts b/packages/api-model/src/doc/python.ts
index 63b750749..621891d06 100644
--- a/packages/api-model/src/doc/python.ts
+++ b/packages/api-model/src/doc/python.ts
@@ -17,12 +17,8 @@ export function dedentDocstring(raw: string): string {
   s = s.replace(/("""|'''|"|')\s*$/, '')
   const lines = s.split('\n')
   const rest = lines.slice(1).filter((l) => l.trim())
-  const indent = rest.length
-    ? Math.min(...rest.map((l) => l.length - l.trimStart().length))
-    : 0
-  return [lines[0]?.trim() ?? '', ...lines.slice(1).map((l) => l.slice(indent))]
-    .join('\n')
-    .trim()
+  const indent = rest.length ? Math.min(...rest.map((l) => l.length - l.trimStart().length)) : 0
+  return [lines[0]?.trim() ?? '', ...lines.slice(1).map((l) => l.slice(indent))].join('\n').trim()
 }
 
 const SECTION =
@@ -61,7 +57,16 @@ export function pythonDocBody(text: string): string {
   const fence = (code: string[], lang: string, indent = '') => {
     const body = code.join('\n').replace(/\n+$/, '')
     const ticks = '`'.repeat(Math.max(3, ...[...body.matchAll(/`+/g)].map((m) => m[0].length + 1)))
-    out.push('', `${indent}${ticks}${lang}`, body.split('\n').map((line) => `${indent}${line}`).join('\n'), `${indent}${ticks}`, '')
+    out.push(
+      '',
+      `${indent}${ticks}${lang}`,
+      body
+        .split('\n')
+        .map((line) => `${indent}${line}`)
+        .join('\n'),
+      `${indent}${ticks}`,
+      '',
+    )
   }
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i]
@@ -79,7 +84,11 @@ export function pythonDocBody(text: string): string {
       const code = [line]
       while (i + 1 < lines.length && lines[i + 1].trim()) code.push(lines[++i])
       const indent = line.length - line.trimStart().length
-      fence(code.map((entry) => entry.slice(indent)), 'python', ' '.repeat(indent))
+      fence(
+        code.map((entry) => entry.slice(indent)),
+        'python',
+        ' '.repeat(indent),
+      )
       continue
     }
     const directive = /^(\s*)\.\.\s+(?:code-block|sourcecode|code)::\s*(\S*)\s*$/.exec(line)
@@ -95,18 +104,28 @@ export function pythonDocBody(text: string): string {
       }
       if (start < lines.length && lines[start].length - lines[start].trimStart().length > indent) {
         let end = start
-        while (end < lines.length && (!lines[end].trim() || lines[end].length - lines[end].trimStart().length > indent)) end++
+        while (end < lines.length && (!lines[end].trim() || lines[end].length - lines[end].trimStart().length > indent))
+          end++
         const code = lines.slice(start, end)
-        const margin = Math.min(...code.filter((entry) => entry.trim()).map((entry) => entry.length - entry.trimStart().length))
+        const margin = Math.min(
+          ...code.filter((entry) => entry.trim()).map((entry) => entry.length - entry.trimStart().length),
+        )
         if (literal && line.trim() !== '::') out.push(line.replace(/::\s*$/, ':'))
-        fence(code.map((entry) => entry.slice(margin)), directive?.[2] || 'text', ' '.repeat(indent))
+        fence(
+          code.map((entry) => entry.slice(margin)),
+          directive?.[2] || 'text',
+          ' '.repeat(indent),
+        )
         i = end - 1
         continue
       }
     }
     out.push(line)
   }
-  return out.filter((entry, i) => entry !== '' || out[i - 1] !== '').join('\n').trim()
+  return out
+    .filter((entry, i) => entry !== '' || out[i - 1] !== '')
+    .join('\n')
+    .trim()
 }
 
 /**
@@ -277,8 +296,17 @@ function directives(text: string): {
 
   const close = () => {
     if (open) {
-      const margin = Math.min(...open.body.filter((line) => line.trim()).map((line) => line.length - line.trimStart().length))
-      found.push({ kind: open.kind, arg: open.arg, body: open.body.map((line) => line.slice(margin)).join('\n').trim() })
+      const margin = Math.min(
+        ...open.body.filter((line) => line.trim()).map((line) => line.length - line.trimStart().length),
+      )
+      found.push({
+        kind: open.kind,
+        arg: open.arg,
+        body: open.body
+          .map((line) => line.slice(margin))
+          .join('\n')
+          .trim(),
+      })
     }
     open = undefined
   }
@@ -363,8 +391,12 @@ export function parsePythonDoc(raw: string): ParsedDoc {
   }))
 
   const examplesText = (named.get('Examples') ?? []).join('\n')
-  const value = (kind: string) => dirs.filter((d) => d.kind === kind)
-    .map((d) => [d.arg, d.body].filter(Boolean).join(' — ').trim()).filter(Boolean).join('\n\n') || undefined
+  const value = (kind: string) =>
+    dirs
+      .filter((d) => d.kind === kind)
+      .map((d) => [d.arg, d.body].filter(Boolean).join(' — ').trim())
+      .filter(Boolean)
+      .join('\n\n') || undefined
   const deprecated = value('deprecated')
   const since = value('versionadded')
   const changed = value('versionchanged')
diff --git a/packages/api-model/src/doc/roles.ts b/packages/api-model/src/doc/roles.ts
index f174affcf..1636d9b70 100644
--- a/packages/api-model/src/doc/roles.ts
+++ b/packages/api-model/src/doc/roles.ts
@@ -92,8 +92,7 @@ const INTRA_DOC_RE = /\[`?([A-Za-z_][\w]*(?:::[\w]+)+)`?\](?!\()/g
  *
  * https://doc.rust-lang.org/rustdoc/write-documentation/linking-to-items-by-name.html
  */
-const INTRA_DOC_PAREN_RE =
-  /\[`?([^\]`]+)`?\]\(((?:crate|self|super|Self)?(?:::)?[A-Za-z_]\w*(?:::\w+)*)\)/g
+const INTRA_DOC_PAREN_RE = /\[`?([^\]`]+)`?\]\(((?:crate|self|super|Self)?(?:::)?[A-Za-z_]\w*(?:::\w+)*)\)/g
 
 /**
  * A backticked path with no scope operator: `` [`Window`] ``.
@@ -235,9 +234,7 @@ const SYNTAX: Record<string, ReadonlySet<string>> = {
  */
 export function docSummaryText(text: string, lang?: string): string {
   return tokenizeDoc(text, lang)
-    .map((span) =>
-      span.kind === 'ref' || span.kind === 'citation' ? span.label : span.text,
-    )
+    .map((span) => (span.kind === 'ref' || span.kind === 'citation' ? span.label : span.text))
     .join('')
 }
 
@@ -256,11 +253,17 @@ export function tokenizeDoc(text: string, lang?: string): DocSpan[] {
       const label = match[1] ? match[2] : match[3]
       const target = match[4].trim()
       if (syntax.has('documenter') && /^@ref(?:\s|$)/.test(target)) {
-        hits.push({ start: match.index, end: match.index + match[0].length,
-          span: { kind: 'ref', role: 'any', target: target.slice(4).trim() || label, label } })
+        hits.push({
+          start: match.index,
+          end: match.index + match[0].length,
+          span: { kind: 'ref', role: 'any', target: target.slice(4).trim() || label, label },
+        })
       } else if (/^(?:https?:\/\/|\/(?!\/)|#)/.test(target)) {
-        hits.push({ start: match.index, end: match.index + match[0].length,
-          span: { kind: 'link', text: label, href: target, ...(match[1] ? { code: true } : {}) } })
+        hits.push({
+          start: match.index,
+          end: match.index + match[0].length,
+          span: { kind: 'link', text: label, href: target, ...(match[1] ? { code: true } : {}) },
+        })
       }
     }
   }
@@ -283,8 +286,11 @@ export function tokenizeDoc(text: string, lang?: string): DocSpan[] {
       const target = syntax.has('scaladoc') ? match[1] : (match[2] ?? match[1])
       const label = syntax.has('scaladoc') ? (match[2] ?? match[1]) : match[1]
       if (!/^[\w.#]+$/.test(target)) continue
-      hits.push({ start: match.index, end: match.index + match[0].length,
-        span: { kind: 'ref', role: 'any', target, label } })
+      hits.push({
+        start: match.index,
+        end: match.index + match[0].length,
+        span: { kind: 'ref', role: 'any', target, label },
+      })
     }
   }
 
@@ -372,26 +378,27 @@ export function tokenizeDoc(text: string, lang?: string): DocSpan[] {
     }
   }
 
-  if (syntax.has('rest')) for (const m of text.matchAll(ROLE_RE)) {
-    const role = m[1].replace(/^py:/, '')
-    const { target, label } = labelFor(m[2])
-    if (!ROLES.has(m[1])) {
-      // A role this resolver does not handle — `:term:`, `:ref:`, `:doc:` —
-      // still has to claim its range. Skipping it outright leaves its
-      // backticks visible to the single-backtick fallback below, which then
-      // invents a symbol reference out of a glossary term: `:term:`winlinks
-      // <winlink>`` was being reported as an unresolved symbol named
-      // `winlinks`. Emitting the label as literal text is both correct
-      // rendering and correct masking.
-      hits.push({ start: m.index, end: m.index + m[0].length, span: { kind: 'text', text: label } })
-      continue
+  if (syntax.has('rest'))
+    for (const m of text.matchAll(ROLE_RE)) {
+      const role = m[1].replace(/^py:/, '')
+      const { target, label } = labelFor(m[2])
+      if (!ROLES.has(m[1])) {
+        // A role this resolver does not handle — `:term:`, `:ref:`, `:doc:` —
+        // still has to claim its range. Skipping it outright leaves its
+        // backticks visible to the single-backtick fallback below, which then
+        // invents a symbol reference out of a glossary term: `:term:`winlinks
+        // <winlink>`` was being reported as an unresolved symbol named
+        // `winlinks`. Emitting the label as literal text is both correct
+        // rendering and correct masking.
+        hits.push({ start: m.index, end: m.index + m[0].length, span: { kind: 'text', text: label } })
+        continue
+      }
+      hits.push({
+        start: m.index,
+        end: m.index + m[0].length,
+        span: { kind: 'ref', role, target, label },
+      })
     }
-    hits.push({
-      start: m.index,
-      end: m.index + m[0].length,
-      span: { kind: 'ref', role, target, label },
-    })
-  }
   for (const m of text.matchAll(LITERAL_RE)) {
     hits.push({
       start: m.index,
@@ -433,13 +440,17 @@ export function tokenizeDoc(text: string, lang?: string): DocSpan[] {
 
   if (lang === 'powershell') {
     // Native help stores these references as plain text rather than Markdown.
-    const names = /(?<![\w$])(?:\$[A-Za-z_]\w*|(?:LibTmux|System)(?:\.[A-Za-z_]\w*)+|(?:[A-Za-z_]\w*\\)?[A-Z][a-z]+-[A-Z][A-Za-z0-9]*|-[A-Z][A-Za-z0-9]*)(?!\w)/g
+    const names =
+      /(?<![\w$])(?:\$[A-Za-z_]\w*|(?:LibTmux|System)(?:\.[A-Za-z_]\w*)+|(?:[A-Za-z_]\w*\\)?[A-Z][a-z]+-[A-Z][A-Za-z0-9]*|-[A-Z][A-Za-z0-9]*)(?!\w)/g
     for (const match of text.matchAll(names)) {
       const start = match.index
       const end = start + match[0].length
       if (hits.some((hit) => hit.start < end && hit.end > start)) continue
-      hits.push({ start, end, span: { kind: 'ref',
-        role: match[0].startsWith('$') ? 'variable' : 'any', target: match[0], label: match[0] } })
+      hits.push({
+        start,
+        end,
+        span: { kind: 'ref', role: match[0].startsWith('$') ? 'variable' : 'any', target: match[0], label: match[0] },
+      })
     }
   }
 
@@ -459,15 +470,21 @@ export function referencesIn(text: string): { role: string; target: string }[] {
   // Bodies may retain narrative code blocks. Their code and delimiter ticks
   // are literals, not cross-references or names to add to the search graph.
   let fence: string | undefined
-  const prose = text.split('\n').map((line) => {
-    if (fence) {
-      if (new RegExp(`^\\s*${fence[0]}{${fence.length},}\\s*$`).test(line)) fence = undefined
-      return ''
-    }
-    const start = /^\s*(`{3,}|~{3,})/.exec(line)
-    if (start) { fence = start[1]; return '' }
-    return line
-  }).join('\n')
+  const prose = text
+    .split('\n')
+    .map((line) => {
+      if (fence) {
+        if (new RegExp(`^\\s*${fence[0]}{${fence.length},}\\s*$`).test(line)) fence = undefined
+        return ''
+      }
+      const start = /^\s*(`{3,}|~{3,})/.exec(line)
+      if (start) {
+        fence = start[1]
+        return ''
+      }
+      return line
+    })
+    .join('\n')
   return tokenizeDoc(prose)
     .filter((s): s is Extract<DocSpan, { kind: 'ref' }> => s.kind === 'ref')
     .map(({ role, target }) => ({ role, target }))
diff --git a/packages/api-model/src/index.ts b/packages/api-model/src/index.ts
index 78809ba65..adae8cae4 100644
--- a/packages/api-model/src/index.ts
+++ b/packages/api-model/src/index.ts
@@ -22,7 +22,15 @@ export * from './prose.ts'
 export { BUILTINS, builtinHref } from './builtins.ts'
 export * from './nav.ts'
 export { NAV } from './nav-config.ts'
-export { MEMBER_TIERS, memberSignals, memberTier, compareMembers, membersOf, type MemberSignals, type MemberTier } from './member-order.ts'
+export {
+  MEMBER_TIERS,
+  memberSignals,
+  memberTier,
+  compareMembers,
+  membersOf,
+  type MemberSignals,
+  type MemberTier,
+} from './member-order.ts'
 
 export { parentInventory } from './parent-inventory.ts'
 
diff --git a/packages/api-model/src/inventory.ts b/packages/api-model/src/inventory.ts
index 03218e52c..b647e2ba0 100644
--- a/packages/api-model/src/inventory.ts
+++ b/packages/api-model/src/inventory.ts
@@ -96,13 +96,27 @@ const JS_ROLE: Partial<Record<SymbolKind, string>> = {
 }
 
 const C_ROLE: Partial<Record<SymbolKind, string>> = {
-  struct: 'struct', union: 'union', enum: 'enum', function: 'function',
-  typealias: 'type', attribute: 'var', constant: 'var',
+  struct: 'struct',
+  union: 'union',
+  enum: 'enum',
+  function: 'function',
+  typealias: 'type',
+  attribute: 'var',
+  constant: 'var',
 }
 
 function roleFor(language: string, kind: SymbolKind): string {
-  const domain = language === 'c' ? 'c' : DOMAIN[language as PortSlug] ?? 'std'
-  const table = domain === 'py' ? PY_ROLE : domain === 'cpp' ? CPP_ROLE : domain === 'js' ? JS_ROLE : domain === 'c' ? C_ROLE : undefined
+  const domain = language === 'c' ? 'c' : (DOMAIN[language as PortSlug] ?? 'std')
+  const table =
+    domain === 'py'
+      ? PY_ROLE
+      : domain === 'cpp'
+        ? CPP_ROLE
+        : domain === 'js'
+          ? JS_ROLE
+          : domain === 'c'
+            ? C_ROLE
+            : undefined
   // `std:label` is the honest home for a language Sphinx has no domain for.
   return `${domain}:${table?.[kind] ?? 'label'}`
 }
@@ -125,7 +139,10 @@ export interface InventoryOptions {
 }
 
 /** Serialise a model as `objects.inv` bytes. */
-export function writeInventory(model: ApiModelBase & { port?: string; language?: string }, options: InventoryOptions): Buffer {
+export function writeInventory(
+  model: ApiModelBase & { port?: string; language?: string },
+  options: InventoryOptions,
+): Buffer {
   const header =
     '# Sphinx inventory version 2\n' +
     `# Project: ${escape(options.project)}\n` +
@@ -133,32 +150,38 @@ export function writeInventory(model: ApiModelBase & { port?: string; language?:
     '# The remainder of this file is compressed using zlib.\n'
 
   const lines: string[] = []
-  const parentKinds = model.language === 'c'
-    ? new Map(model.symbols.map((symbol) => [symbol.id, symbol.kind])) : undefined
-  const symbolRole = (symbol: ApiSymbol) => model.language === 'c' && symbol.modifiers.includes('macro') ? 'c:macro'
-    : model.language === 'c' && symbol.parent && symbol.kind === 'constant' && parentKinds?.get(symbol.parent) === 'enum'
-      ? 'c:enumerator'
-      : model.language === 'c' && symbol.parent && ['attribute', 'property'].includes(symbol.kind)
-        ? 'c:member'
-        : roleFor(model.port ?? model.language ?? '', symbol.kind)
-  const cName = (symbol: ApiSymbol) => symbolRole(symbol) === 'c:enumerator' ? symbol.name : qualifiedNameOf(symbol)
+  const parentKinds =
+    model.language === 'c' ? new Map(model.symbols.map((symbol) => [symbol.id, symbol.kind])) : undefined
+  const symbolRole = (symbol: ApiSymbol) =>
+    model.language === 'c' && symbol.modifiers.includes('macro')
+      ? 'c:macro'
+      : model.language === 'c' &&
+          symbol.parent &&
+          symbol.kind === 'constant' &&
+          parentKinds?.get(symbol.parent) === 'enum'
+        ? 'c:enumerator'
+        : model.language === 'c' && symbol.parent && ['attribute', 'property'].includes(symbol.kind)
+          ? 'c:member'
+          : roleFor(model.port ?? model.language ?? '', symbol.kind)
+  const cName = (symbol: ApiSymbol) => (symbolRole(symbol) === 'c:enumerator' ? symbol.name : qualifiedNameOf(symbol))
   const spellings = new Map<string, number>()
-  if (model.language === 'c') for (const symbol of model.symbols) {
-    const key = `${symbolRole(symbol)}:${cName(symbol)}`
-    spellings.set(key, (spellings.get(key) ?? 0) + 1)
-  }
+  if (model.language === 'c')
+    for (const symbol of model.symbols) {
+      const key = `${symbolRole(symbol)}:${cName(symbol)}`
+      spellings.set(key, (spellings.get(key) ?? 0) + 1)
+    }
   // Sorted, so the file is byte-stable across runs and a diff means a real
   // change rather than a map iteration order.
-  const sorted = [...model.symbols].sort((a, b) =>
-    (a.publicId ?? a.id).localeCompare(b.publicId ?? b.id),
-  )
+  const sorted = [...model.symbols].sort((a, b) => (a.publicId ?? a.id).localeCompare(b.publicId ?? b.id))
   for (const symbol of sorted) {
     const role = symbolRole(symbol)
     const spelling = cName(symbol)
     // Sphinx consumers ask for C spellings, not our declaration IDs. A
     // duplicated file-local name or an anonymous type keeps its scoped ID.
-    const name = model.language === 'c' && !/\s/.test(spelling) && spellings.get(`${role}:${spelling}`) === 1
-      ? spelling : symbol.publicId ?? symbol.id
+    const name =
+      model.language === 'c' && !/\s/.test(spelling) && spellings.get(`${role}:${spelling}`) === 1
+        ? spelling
+        : (symbol.publicId ?? symbol.id)
     // Records are whitespace-delimited, so a name containing whitespace is
     // not representable — Sphinx's reader mis-splits it and the entry is
     // silently lost. Two Java symbols disappeared exactly this way, because
diff --git a/packages/api-model/src/languages/csharp-examples.ts b/packages/api-model/src/languages/csharp-examples.ts
index f9d478b68..f277fb6cd 100644
--- a/packages/api-model/src/languages/csharp-examples.ts
+++ b/packages/api-model/src/languages/csharp-examples.ts
@@ -25,21 +25,29 @@ export function attachCompleteCSharpExamples(
   const raw = read('examples/api/manifest.json')
   if (raw === undefined) return
   const manifest = JSON.parse(raw) as Manifest
-  if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.examples) || !manifest.examples.length ||
-      JSON.stringify(manifest.setupFiles) !== JSON.stringify(['global.json', 'examples/api/NuGet.config'])) {
+  if (
+    manifest.schemaVersion !== 1 ||
+    !Array.isArray(manifest.examples) ||
+    !manifest.examples.length ||
+    JSON.stringify(manifest.setupFiles) !== JSON.stringify(['global.json', 'examples/api/NuGet.config'])
+  ) {
     throw new Error('Invalid C# example manifest')
   }
   const programs = manifest.examples.filter((program) => program.profile === 'csharp')
   const profile = manifest.profiles?.csharp
   if (!programs.length && !profile) return
   if (!programs.length) throw new Error('C# example profile has no complete programs')
-  if (profile?.package !== 'LibTmux' || profile.projectFile !== 'examples/api/csharp/Example.csproj' ||
-      profile.entrypoint !== 'Program.cs') throw new Error('Invalid C# example profile')
+  if (
+    profile?.package !== 'LibTmux' ||
+    profile.projectFile !== 'examples/api/csharp/Example.csproj' ||
+    profile.entrypoint !== 'Program.cs'
+  )
+    throw new Error('Invalid C# example profile')
   if (source.repo !== 'libtmux/libtmux-dotnet' || !/^[0-9a-f]{40}$/.test(source.revision)) {
     throw new Error('C# examples require the public repository and full source revision')
   }
   const codeFor = (path: string): string => {
-    if (path !== 'global.json' && !/^examples\/(?:[\w.-]+\/)*[\w.-]+$/.test(path) || path.split('/').includes('..')) {
+    if ((path !== 'global.json' && !/^examples\/(?:[\w.-]+\/)*[\w.-]+$/.test(path)) || path.split('/').includes('..')) {
       throw new Error(`Invalid C# example source path: ${path}`)
     }
     const code = read(path)
@@ -58,46 +66,67 @@ export function attachCompleteCSharpExamples(
   if (!/^\d+\.\d+\.\d+$/.test(sdk ?? '')) throw new Error('C# examples require a pinned SDK')
   const ids = new Set<string>()
   for (const program of programs) {
-    if (!/^csharp-[A-Za-z0-9]+$/.test(program.id) || ids.has(program.id) ||
-        typeof program.title !== 'string' || !program.title.trim() ||
-        typeof program.description !== 'string' || !program.description.trim() ||
-        !/^examples\/LibTmux\.Examples\/Programs\/[A-Za-z0-9]+\.cs$/.test(program.sourceFile) ||
-        typeof program.output !== 'string' || !program.output.trim() ||
-        !program.output.endsWith('\n') || program.output.includes('\r') ||
-        !Array.isArray(program.targets) || !program.targets.length) {
+    if (
+      !/^csharp-[A-Za-z0-9]+$/.test(program.id) ||
+      ids.has(program.id) ||
+      typeof program.title !== 'string' ||
+      !program.title.trim() ||
+      typeof program.description !== 'string' ||
+      !program.description.trim() ||
+      !/^examples\/LibTmux\.Examples\/Programs\/[A-Za-z0-9]+\.cs$/.test(program.sourceFile) ||
+      typeof program.output !== 'string' ||
+      !program.output.trim() ||
+      !program.output.endsWith('\n') ||
+      program.output.includes('\r') ||
+      !Array.isArray(program.targets) ||
+      !program.targets.length
+    ) {
       throw new Error(`Invalid C# example metadata: ${program.id}`)
     }
     ids.add(program.id)
-    const blocks: NonNullable<DocBlock['examples']> = [{
-      lang: 'console',
-      intro: `${program.description.replace(/\n/g, ' ')} Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK ${sdk}, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:`,
-      code: `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout --detach ${source.revision}\n`,
-    }]
-    for (const file of setup) blocks.push({
-      lang: file.lang, intro: `Save this complete consumer setup as ${file.path}:`,
-      sourceUrl: urlFor(file.sourceFile), code: codeFor(file.sourceFile),
-    })
-    blocks.push({
-      lang: 'csharp',
-      intro: 'Save this complete program as Program.cs. It creates a private server; await using disposes its owned scopes after success, cancellation or failure. The complete file contains explicit imports, a top-level async entry point and a cancellation deadline.',
-      sourceUrl: urlFor(program.sourceFile), code: codeFor(program.sourceFile),
-    }, {
-      lang: 'console',
-      intro: 'Build the exact source package and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:',
-      code: '$ export NUGET_PACKAGES="$PWD/packages" && \\\n' +
-        '  dotnet restore libtmux-source/src/LibTmux/LibTmux.csproj --locked-mode && \\\n' +
-        '  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \\\n' +
-        '    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \\\n' +
-        '    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \\\n' +
-        '  dotnet restore Example.csproj --configfile NuGet.config && \\\n' +
-        '  dotnet build Example.csproj --configuration Release --no-restore --warnaserror && \\\n' +
-        '  export LIBTMUX_TMUX="$(command -v tmux)" && \\\n' +
-        '  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \\\n' +
-        '  mkdir -p "$TMUX_TMPDIR" && \\\n' +
-        '  unset TMUX TMUX_PANE && \\\n' +
-        '  dotnet bin/Release/net8.0/Example.dll && \\\n' +
-        '  dotnet bin/Release/net10.0/Example.dll\n',
-    }, { lang: 'text', intro: 'Expected program output from each framework:', code: program.output })
+    const blocks: NonNullable<DocBlock['examples']> = [
+      {
+        lang: 'console',
+        intro: `${program.description.replace(/\n/g, ' ')} Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK ${sdk}, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:`,
+        code: `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout --detach ${source.revision}\n`,
+      },
+    ]
+    for (const file of setup)
+      blocks.push({
+        lang: file.lang,
+        intro: `Save this complete consumer setup as ${file.path}:`,
+        sourceUrl: urlFor(file.sourceFile),
+        code: codeFor(file.sourceFile),
+      })
+    blocks.push(
+      {
+        lang: 'csharp',
+        intro:
+          'Save this complete program as Program.cs. It creates a private server; await using disposes its owned scopes after success, cancellation or failure. The complete file contains explicit imports, a top-level async entry point and a cancellation deadline.',
+        sourceUrl: urlFor(program.sourceFile),
+        code: codeFor(program.sourceFile),
+      },
+      {
+        lang: 'console',
+        intro:
+          'Build the exact source package and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:',
+        code:
+          '$ export NUGET_PACKAGES="$PWD/packages" && \\\n' +
+          '  dotnet restore libtmux-source/src/LibTmux/LibTmux.csproj --locked-mode && \\\n' +
+          '  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \\\n' +
+          '    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \\\n' +
+          '    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \\\n' +
+          '  dotnet restore Example.csproj --configfile NuGet.config && \\\n' +
+          '  dotnet build Example.csproj --configuration Release --no-restore --warnaserror && \\\n' +
+          '  export LIBTMUX_TMUX="$(command -v tmux)" && \\\n' +
+          '  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \\\n' +
+          '  mkdir -p "$TMUX_TMPDIR" && \\\n' +
+          '  unset TMUX TMUX_PANE && \\\n' +
+          '  dotnet bin/Release/net8.0/Example.dll && \\\n' +
+          '  dotnet bin/Release/net10.0/Example.dll\n',
+      },
+      { lang: 'text', intro: 'Expected program output from each framework:', code: program.output },
+    )
     const targets = new Set<string>()
     const pages = new Set<ApiSymbol>()
     for (const target of program.targets) {
@@ -107,10 +136,16 @@ export function attachCompleteCSharpExamples(
       }
       if (targets.has(target)) throw new Error(`Duplicate C# compiler target: ${target}`)
       targets.add(target)
-      const id = target.slice(2).replace(/\(.*$/, '').replace(/`{1,2}\d+/g, '')
+      const id = target
+        .slice(2)
+        .replace(/\(.*$/, '')
+        .replace(/`{1,2}\d+/g, '')
       const matches = symbols.filter((symbol) => symbol.id === id)
-      const kinds = target.startsWith('M:') ? ['method'] : target.startsWith('P:')
-        ? ['property'] : ['class', 'interface', 'struct', 'enum']
+      const kinds = target.startsWith('M:')
+        ? ['method']
+        : target.startsWith('P:')
+          ? ['property']
+          : ['class', 'interface', 'struct', 'enum']
       if (matches.length !== 1 || !kinds.includes(matches[0].kind)) {
         throw new Error(`C# example target must resolve once with its native kind: ${target}`)
       }
diff --git a/packages/api-model/src/languages/cxx-examples.test.ts b/packages/api-model/src/languages/cxx-examples.test.ts
index 9e326cccd..c7388d70d 100644
--- a/packages/api-model/src/languages/cxx-examples.test.ts
+++ b/packages/api-model/src/languages/cxx-examples.test.ts
@@ -4,15 +4,29 @@ import { attachCompleteCxxExamples } from './cxx-examples.ts'
 
 const source = { repo: 'libtmux/libtmux-cxx', revision: 'a'.repeat(40) }
 const symbol = (): ApiSymbol => ({
-  id: 'libtmux::Server', name: 'Server', slug: 'libtmux-server', kind: 'class',
-  signatures: [], modifiers: [], source: { file: 'include/libtmux/server.hpp' },
+  id: 'libtmux::Server',
+  name: 'Server',
+  slug: 'libtmux-server',
+  kind: 'class',
+  signatures: [],
+  modifiers: [],
+  source: { file: 'include/libtmux/server.hpp' },
   doc: { summary: 'A tmux server address.', examples: [{ lang: 'cpp', code: 'const int old = 1;\n' }] },
 })
 const fixture = () => {
   const manifest = {
-    schemaVersion: 1, projectFile: 'examples/api/project/CMakeLists.txt',
-    programs: [{ id: 'server', symbols: ['libtmux::Server'], title: 'List sessions',
-      description: 'Read the server listing.', expectedOutput: 'api\n', file: 'examples/api/server.cpp' }],
+    schemaVersion: 1,
+    projectFile: 'examples/api/project/CMakeLists.txt',
+    programs: [
+      {
+        id: 'server',
+        symbols: ['libtmux::Server'],
+        title: 'List sessions',
+        description: 'Read the server listing.',
+        expectedOutput: 'api\n',
+        file: 'examples/api/server.cpp',
+      },
+    ],
   }
   const projectCode = 'cmake_minimum_required(VERSION 3.25)\nproject(example LANGUAGES CXX)\n'
   const programCode = '#include <libtmux/libtmux.hpp>\nint main() { return 0; }\n'
@@ -20,8 +34,7 @@ const fixture = () => {
     'examples/api/project/CMakeLists.txt': projectCode,
     'examples/api/server.cpp': programCode,
   }
-  const read = (path: string) => path === 'examples/api/api-examples.json'
-    ? JSON.stringify(manifest) : files[path]
+  const read = (path: string) => (path === 'examples/api/api-examples.json' ? JSON.stringify(manifest) : files[path])
   return { manifest, files, read, projectCode, programCode }
 }
 
@@ -36,9 +49,11 @@ describe('complete C++ API examples', () => {
     expect(blocks[3].code).toBe(projectCode)
     expect(blocks[4].code).toBe(programCode)
     expect(blocks[3].sourceUrl).toBe(
-      `https://github.com/${source.repo}/blob/${source.revision}/examples/api/project/CMakeLists.txt`)
+      `https://github.com/${source.repo}/blob/${source.revision}/examples/api/project/CMakeLists.txt`,
+    )
     expect(blocks[4].sourceUrl).toBe(
-      `https://github.com/${source.repo}/blob/${source.revision}/examples/api/server.cpp`)
+      `https://github.com/${source.repo}/blob/${source.revision}/examples/api/server.cpp`,
+    )
     expect(blocks[1].code).toContain(`git -C libtmux-source checkout ${source.revision}`)
     expect(blocks[2].code).toContain('-DLIBTMUX_BUILD_TESTING_LIBRARY=ON')
     expect(blocks[5].code).toContain('-DCMAKE_PREFIX_PATH="$PWD/libtmux-prefix"')
@@ -53,19 +68,84 @@ describe('complete C++ API examples', () => {
   })
 
   it.each([
-    ['unknown target', (f: ReturnType<typeof fixture>) => { f.manifest.programs[0].symbols = ['libtmux::Unknown'] }],
-    ['duplicate target', (f: ReturnType<typeof fixture>) => { f.manifest.programs[0].symbols.push('libtmux::Server') }],
-    ['duplicate program', (f: ReturnType<typeof fixture>) => { f.manifest.programs.push(f.manifest.programs[0]) }],
-    ['missing program', (f: ReturnType<typeof fixture>) => { delete f.files[f.manifest.programs[0].file] }],
-    ['missing project', (f: ReturnType<typeof fixture>) => { delete f.files[f.manifest.projectFile] }],
-    ['partial file', (f: ReturnType<typeof fixture>) => { f.files[f.manifest.programs[0].file] = 'int main() {}' }],
-    ['hidden entry point', (f: ReturnType<typeof fixture>) => { f.files[f.manifest.programs[0].file] = 'void example() {}\n' }],
-    ['unsafe path', (f: ReturnType<typeof fixture>) => { f.manifest.programs[0].file = '../server.cpp' }],
-    ['unexpected project', (f: ReturnType<typeof fixture>) => { f.manifest.projectFile = 'CMakeLists.txt' }],
-    ['empty output', (f: ReturnType<typeof fixture>) => { f.manifest.programs[0].expectedOutput = '' }],
-    ['missing output newline', (f: ReturnType<typeof fixture>) => { f.manifest.programs[0].expectedOutput = 'api' }],
-    ['missing description', (f: ReturnType<typeof fixture>) => { f.manifest.programs[0].description = ' ' }],
-    ['unsupported schema', (f: ReturnType<typeof fixture>) => { f.manifest.schemaVersion = 2 }],
+    [
+      'unknown target',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs[0].symbols = ['libtmux::Unknown']
+      },
+    ],
+    [
+      'duplicate target',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs[0].symbols.push('libtmux::Server')
+      },
+    ],
+    [
+      'duplicate program',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs.push(f.manifest.programs[0])
+      },
+    ],
+    [
+      'missing program',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files[f.manifest.programs[0].file]
+      },
+    ],
+    [
+      'missing project',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files[f.manifest.projectFile]
+      },
+    ],
+    [
+      'partial file',
+      (f: ReturnType<typeof fixture>) => {
+        f.files[f.manifest.programs[0].file] = 'int main() {}'
+      },
+    ],
+    [
+      'hidden entry point',
+      (f: ReturnType<typeof fixture>) => {
+        f.files[f.manifest.programs[0].file] = 'void example() {}\n'
+      },
+    ],
+    [
+      'unsafe path',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs[0].file = '../server.cpp'
+      },
+    ],
+    [
+      'unexpected project',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.projectFile = 'CMakeLists.txt'
+      },
+    ],
+    [
+      'empty output',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs[0].expectedOutput = ''
+      },
+    ],
+    [
+      'missing output newline',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs[0].expectedOutput = 'api'
+      },
+    ],
+    [
+      'missing description',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.programs[0].description = ' '
+      },
+    ],
+    [
+      'unsupported schema',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.schemaVersion = 2
+      },
+    ],
   ])('rejects %s', (_name, change) => {
     const f = fixture()
     change(f)
@@ -75,7 +155,11 @@ describe('complete C++ API examples', () => {
   it('rejects ambiguous identities, unpinned revisions and a foreign repository', () => {
     const { read } = fixture()
     expect(() => attachCompleteCxxExamples([symbol(), symbol()], read, source)).toThrow('resolve once')
-    expect(() => attachCompleteCxxExamples([symbol()], read, { ...source, revision: 'master' })).toThrow('full revision')
-    expect(() => attachCompleteCxxExamples([symbol()], read, { ...source, repo: 'other/repo' })).toThrow('C++ repository')
+    expect(() => attachCompleteCxxExamples([symbol()], read, { ...source, revision: 'master' })).toThrow(
+      'full revision',
+    )
+    expect(() => attachCompleteCxxExamples([symbol()], read, { ...source, repo: 'other/repo' })).toThrow(
+      'C++ repository',
+    )
   })
 })
diff --git a/packages/api-model/src/languages/cxx-examples.ts b/packages/api-model/src/languages/cxx-examples.ts
index 7c1315259..a12d56103 100644
--- a/packages/api-model/src/languages/cxx-examples.ts
+++ b/packages/api-model/src/languages/cxx-examples.ts
@@ -27,10 +27,11 @@ export function attachCompleteCxxExamples(
   const require = (condition: unknown, message: string): void => {
     if (!condition) throw new Error(`Invalid complete C++ examples: ${message}`)
   }
-  require(source.repo === 'libtmux/libtmux-cxx' && /^[a-f0-9]{40}$/.test(source.revision),
-    'source must name the C++ repository and a full revision')
-  require(manifest?.schemaVersion === 1 && Array.isArray(manifest.programs) && manifest.programs.length,
-    'unsupported or empty manifest')
+  require(source.repo === 'libtmux/libtmux-cxx' &&
+    /^[a-f0-9]{40}$/.test(source.revision), 'source must name the C++ repository and a full revision')
+  require(manifest?.schemaVersion === 1 &&
+    Array.isArray(manifest.programs) &&
+    manifest.programs.length, 'unsupported or empty manifest')
   require(manifest.projectFile === 'examples/api/project/CMakeLists.txt', 'unexpected consumer project')
   const codeFor = (path: string): string => {
     const code = read(path)
@@ -44,18 +45,22 @@ export function attachCompleteCxxExamples(
   const names = new Set<string>()
   const targets = new Set<string>()
   for (const example of manifest.programs) {
-    require(/^[a-z][a-z0-9-]*$/.test(example.id) && !names.has(example.id),
-      'invalid or duplicate program name')
+    require(/^[a-z][a-z0-9-]*$/.test(example.id) && !names.has(example.id), 'invalid or duplicate program name')
     names.add(example.id)
     require(example.file === `examples/api/${example.id}.cpp`, 'unexpected program path')
-    require(typeof example.title === 'string' && example.title.trim() &&
-      typeof example.description === 'string' && example.description.trim(), 'task description is missing')
-    require(typeof example.expectedOutput === 'string' && example.expectedOutput.trim() &&
-      example.expectedOutput.endsWith('\n') && !example.expectedOutput.includes('\r'),
-      'expected output is missing or incomplete')
-    require(Array.isArray(example.symbols) && example.symbols.length &&
-      example.symbols.every((id) => typeof id === 'string' && /^libtmux::[A-Za-z_][\w:]*$/.test(id)),
-      'API targets are missing')
+    require(typeof example.title === 'string' &&
+      example.title.trim() &&
+      typeof example.description === 'string' &&
+      example.description.trim(), 'task description is missing')
+    require(typeof example.expectedOutput === 'string' &&
+      example.expectedOutput.trim() &&
+      example.expectedOutput.endsWith('\n') &&
+      !example.expectedOutput.includes('\r'), 'expected output is missing or incomplete')
+    require(Array.isArray(example.symbols) &&
+      example.symbols.length &&
+      example.symbols.every(
+        (id) => typeof id === 'string' && /^libtmux::[A-Za-z_][\w:]*$/.test(id),
+      ), 'API targets are missing')
     const program = codeFor(example.file)
     require(program.includes('int main()'), 'program entry point is missing')
     const blocks: NonNullable<DocBlock['examples']> = [
@@ -72,16 +77,20 @@ export function attachCompleteCxxExamples(
       {
         lang: 'cmake',
         intro: 'Save this complete consumer project as CMakeLists.txt:',
-        sourceUrl: urlFor(manifest.projectFile), code: project,
+        sourceUrl: urlFor(manifest.projectFile),
+        code: project,
       },
       {
         lang: 'cpp',
-        intro: 'Save this complete program as main.cpp. `ScopedTmuxServer` owns a private daemon and stops it when the program exits. Ordinary applications use `Server` for their own socket; these examples use the fixture until setup moves to ordinary server objects.',
-        sourceUrl: urlFor(example.file), code: program,
+        intro:
+          'Save this complete program as main.cpp. `ScopedTmuxServer` owns a private daemon and stops it when the program exits. Ordinary applications use `Server` for their own socket; these examples use the fixture until setup moves to ordinary server objects.',
+        sourceUrl: urlFor(example.file),
+        code: program,
       },
       {
         lang: 'console',
-        intro: 'Build against the installed library and run the saved program. An operation error produces a failing exit status:',
+        intro:
+          'Build against the installed library and run the saved program. An operation error produces a failing exit status:',
         code: '$ cmake -S . -B build -G Ninja \\\n    -DCMAKE_PREFIX_PATH="$PWD/libtmux-prefix" \\\n    -DCMAKE_CXX_COMPILER=clang++ \\\n    -DCMAKE_CXX_FLAGS=-stdlib=libc++ && \\\n  cmake --build build --parallel 2 && \\\n  ./build/api_example\n',
       },
       { lang: 'text', intro: 'Expected output:', code: example.expectedOutput },
diff --git a/packages/api-model/src/languages/doxygen.ts b/packages/api-model/src/languages/doxygen.ts
index c0e23a742..894bb8d07 100644
--- a/packages/api-model/src/languages/doxygen.ts
+++ b/packages/api-model/src/languages/doxygen.ts
@@ -61,11 +61,14 @@ function textOf(xml: string): string {
 /** Code XML keeps literal whitespace and decodes each entity exactly once. */
 function codeOf(xml: string): string {
   const entities: Record<string, string> = { lt: '<', gt: '>', amp: '&', quot: '"', apos: "'" }
-  return xml.replace(/<[^>]+>/g, '').replace(/&(lt|gt|amp|quot|apos|#\d+|#x[\da-f]+);/gi, (_, entity: string) => {
-    if (entity.startsWith('#x')) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16))
-    if (entity.startsWith('#')) return String.fromCodePoint(Number(entity.slice(1)))
-    return entities[entity]
-  }).trim()
+  return xml
+    .replace(/<[^>]+>/g, '')
+    .replace(/&(lt|gt|amp|quot|apos|#\d+|#x[\da-f]+);/gi, (_, entity: string) => {
+      if (entity.startsWith('#x')) return String.fromCodePoint(Number.parseInt(entity.slice(2), 16))
+      if (entity.startsWith('#')) return String.fromCodePoint(Number(entity.slice(1)))
+      return entities[entity]
+    })
+    .trim()
 }
 
 const syntheticCName = (name: string): boolean => /\[(?:struct|union)\]|__unnamed\d+__|@[\da-f]+/i.test(name)
@@ -73,9 +76,12 @@ const syntheticCName = (name: string): boolean => /\[(?:struct|union)\]|__unname
 /** Doxygen names anonymous C records for identity; those names are not C syntax. */
 function cDisplayName(name: string, kind?: string): string {
   const anonymous = syntheticCName(name)
-  const clean = name.replace(/\[(?:struct|union)\]\.?|__unnamed\d+__|@[\da-f]+/gi, '')
-    .replaceAll('::', '.').replace(/\.{2,}/g, '.').replace(/^\.|\.$/g, '')
-  return anonymous && kind ? clean ? `${clean} (anonymous ${kind})` : `anonymous ${kind}` : clean
+  const clean = name
+    .replace(/\[(?:struct|union)\]\.?|__unnamed\d+__|@[\da-f]+/gi, '')
+    .replaceAll('::', '.')
+    .replace(/\.{2,}/g, '.')
+    .replace(/^\.|\.$/g, '')
+  return anonymous && kind ? (clean ? `${clean} (anonymous ${kind})` : `anonymous ${kind}`) : clean
 }
 
 /** Reconstruct C declaration syntax from Doxygen's native declaration fields. */
@@ -85,12 +91,16 @@ function cDeclaration(block: string, nativeKind: string, name: string): string |
   const initializer = codeOf(tag(block, 'initializer') ?? '')
   if (nativeKind !== 'enum' && (syntheticCName(name) || syntheticCName(type))) return undefined
   if (nativeKind === 'enum') {
-    const values = [...block.matchAll(/<enumvalue([\s\S]*?)<\/enumvalue>/g)].map((match) =>
-      `${codeOf(tag(match[1], 'name') ?? '')}${tag(match[1], 'initializer') ? ` ${codeOf(tag(match[1], 'initializer') ?? '')}` : ''}`)
+    const values = [...block.matchAll(/<enumvalue([\s\S]*?)<\/enumvalue>/g)].map(
+      (match) =>
+        `${codeOf(tag(match[1], 'name') ?? '')}${tag(match[1], 'initializer') ? ` ${codeOf(tag(match[1], 'initializer') ?? '')}` : ''}`,
+    )
     return `enum${name.startsWith('@') ? '' : ` ${name}`} { ${values.join(', ')} };`
   }
   if (nativeKind === 'define') {
-    const parameters = [...block.matchAll(/<param>([\s\S]*?)<\/param>/g)].map((match) => codeOf(tag(match[1], 'defname') ?? ''))
+    const parameters = [...block.matchAll(/<param>([\s\S]*?)<\/param>/g)].map((match) =>
+      codeOf(tag(match[1], 'defname') ?? ''),
+    )
     return `#define ${name}${parameters.length ? `(${parameters.join(', ')})` : ''}${initializer ? ` ${initializer}` : ''}`
   }
   const pointer = /\(\s*(\*+(?:\s*(?:const|volatile|restrict)\b)*)\s*\)/
@@ -162,8 +172,7 @@ const afterEnumValues = (block: string): string => {
   return last === -1 ? block : block.slice(last)
 }
 
-const attr = (xml: string, name: string): string | undefined =>
-  new RegExp(`${name}="([^"]*)"`).exec(xml)?.[1]
+const attr = (xml: string, name: string): string | undefined => new RegExp(`${name}="([^"]*)"`).exec(xml)?.[1]
 
 /** C source locations distinguish a declaration from a same-file definition.
  * Doxygen 1.18 sometimes keeps a preceding callback's `line` for function
@@ -171,21 +180,27 @@ const attr = (xml: string, name: string): string | undefined =>
  * declaration. A cross-file body belongs to a different member record, and
  * repeated extern declarations are not definitions.
  */
-function cLocation(location: string, fallback: string, externDeclaration = false): {
-  source: { file: string; line: number }; isDefinition: boolean
+function cLocation(
+  location: string,
+  fallback: string,
+  externDeclaration = false,
+): {
+  source: { file: string; line: number }
+  isDefinition: boolean
 } {
   const field = (name: string) => new RegExp(`(?:^|\\s)${name}="([^"]*)"`).exec(location)?.[1]
   const file = field('file') ?? fallback
   const declaredLine = Number(field('line') ?? 1)
   const bodyLine = Number(field('bodystart'))
-  const isDefinition = !externDeclaration && field('bodyfile') === file
-    && Number.isInteger(bodyLine) && bodyLine > 0
+  const isDefinition = !externDeclaration && field('bodyfile') === file && Number.isInteger(bodyLine) && bodyLine > 0
   return { source: { file, line: isDefinition ? bodyLine : declaredLine }, isDefinition }
 }
 
 /** Programlisting is native linked source, not a runtime or complete call graph. */
 function cCalls(
-  documents: { xml: string }[], nativeIds: Map<string, string>, seen: Map<string, ApiSymbol>,
+  documents: { xml: string }[],
+  nativeIds: Map<string, string>,
+  seen: Map<string, ApiSymbol>,
   onDiagnostic?: (message: string) => void,
 ): void {
   const plain = (xml: string) => codeOf(`_${xml.replace(/<sp\s*\/>/g, ' ')}_`).slice(1, -1)
@@ -196,34 +211,49 @@ function cCalls(
     if (!listing) continue
     const lines = [...listing.matchAll(/<codeline\b([^>]*)>([\s\S]*?)<\/codeline>/g)].map((match) => {
       // Comments and literal contents cannot contain callable source tokens.
-      const codeXml = match[2].replace(/<highlight class="(?:comment|stringliteral|charliteral)">([\s\S]*?)<\/highlight>/g,
-        (part) => ' '.repeat(plain(part).length))
+      const codeXml = match[2].replace(
+        /<highlight class="(?:comment|stringliteral|charliteral)">([\s\S]*?)<\/highlight>/g,
+        (part) => ' '.repeat(plain(part).length),
+      )
       const refs = [...codeXml.matchAll(/<ref\b([^>]*)>([\s\S]*?)<\/ref>/g)].map((ref) => ({
-        id: nativeIds.get(attr(ref[1], 'refid') ?? ''), name: plain(ref[2]),
+        id: nativeIds.get(attr(ref[1], 'refid') ?? ''),
+        name: plain(ref[2]),
         start: plain(codeXml.slice(0, ref.index)).length,
         end: plain(codeXml.slice(0, ref.index + ref[0].length)).length,
       }))
-      return { line: Number(attr(match[1], 'lineno')), code: plain(codeXml), refs,
-        preprocessor: /<highlight class="preprocessor">/.test(codeXml) }
+      return {
+        line: Number(attr(match[1], 'lineno')),
+        code: plain(codeXml),
+        refs,
+        preprocessor: /<highlight class="preprocessor">/.test(codeXml),
+      }
     })
     const bodies = [...xml.matchAll(/<memberdef([\s\S]*?)<\/memberdef>/g)].flatMap((member) => {
       if (attr(member[1], 'kind') !== 'function') return []
       const symbol = seen.get(nativeIds.get(attr(member[1], 'id') ?? '') ?? '')
       const location = /<location\b([^>]*)\/>/.exec(member[1])?.[1] ?? ''
-      const start = Number(attr(location, 'bodystart')), end = Number(attr(location, 'bodyend'))
-      return symbol && attr(location, 'bodyfile') === file && start > 0 && end >= start
-        ? [{ symbol, start, end }] : []
+      const start = Number(attr(location, 'bodystart')),
+        end = Number(attr(location, 'bodyend'))
+      return symbol && attr(location, 'bodyfile') === file && start > 0 && end >= start ? [{ symbol, start, end }] : []
     })
     for (const { symbol, start, end } of bodies) {
       // Native body spans have line precision only. Two definitions can share
       // a line, so its first brace is not necessarily this function's body.
-      const conflicts = bodies.filter((body) => body.symbol.id !== symbol.id
-        && body.start <= end && start <= body.end)
+      const conflicts = bodies.filter((body) => body.symbol.id !== symbol.id && body.start <= end && start <= body.end)
       if (conflicts.length) {
-        onDiagnostic?.(`Omitted ambiguous function body ${symbol.id} at ${file}:${start}-${end}; overlaps ${conflicts.map((body) => body.symbol.id).sort().join(', ')}`)
+        onDiagnostic?.(
+          `Omitted ambiguous function body ${symbol.id} at ${file}:${start}-${end}; overlaps ${conflicts
+            .map((body) => body.symbol.id)
+            .sort()
+            .join(', ')}`,
+        )
         continue
       }
-      let opened = false, parentheses = 0, brackets = 0, braces = 1, continuation = false
+      let opened = false,
+        parentheses = 0,
+        brackets = 0,
+        braces = 1,
+        continuation = false
       for (const row of lines) {
         if (row.line < start || row.line > end) continue
         if (row.preprocessor || continuation) {
@@ -241,15 +271,26 @@ function cCalls(
         let limit = row.code.length
         for (let i = offset; i < row.code.length; i++) {
           if (row.code[i] === '{') braces++
-          else if (row.code[i] === '}' && --braces === 0) { limit = i; break }
+          else if (row.code[i] === '}' && --braces === 0) {
+            limit = i
+            break
+          }
         }
         const macro = row.refs.some((ref) => ref.id && seen.get(ref.id)?.modifiers.includes('macro'))
         for (const ref of row.refs) {
           const target = ref.id ? seen.get(ref.id) : undefined
-          if (macro || parentheses !== 0 || brackets !== 0 || ref.start < offset
-            || ref.end > limit || target?.kind !== 'function' || target.name !== ref.name
-            || (target.modifiers.includes('static') && target.source.file !== file)
-            || !/^\s*\(/.test(row.code.slice(ref.end))) continue
+          if (
+            macro ||
+            parentheses !== 0 ||
+            brackets !== 0 ||
+            ref.start < offset ||
+            ref.end > limit ||
+            target?.kind !== 'function' ||
+            target.name !== ref.name ||
+            (target.modifiers.includes('static') && target.source.file !== file) ||
+            !/^\s*\(/.test(row.code.slice(ref.end))
+          )
+            continue
           const prefix = row.code.slice(offset, ref.start)
           // Deliberately bounded: a direct statement, return, first condition,
           // or assignment RHS. Nested/continued expressions and macro arguments
@@ -257,10 +298,14 @@ function cCalls(
           const expression = /^\s*(?:return\s*\(*\s*|(?:if|while|switch)\s*\(\s*!?\s*)?$/.test(prefix)
           const assignment = !/[();{}]/.test(prefix) && /(?<![=!<>])=(?!=)\s*$/.test(prefix)
           if (!expression && !assignment) continue
-          const references = symbol.references ??= []
+          const references = (symbol.references ??= [])
           let edge = references.find((entry) => entry.kind === 'call' && entry.target === target.id)
-          if (!edge) { edge = { target: target.id, kind: 'call', sites: [] }; references.push(edge) }
-          if (!edge.sites!.some((site) => site.file === file && site.line === row.line)) edge.sites!.push({ file, line: row.line })
+          if (!edge) {
+            edge = { target: target.id, kind: 'call', sites: [] }
+            references.push(edge)
+          }
+          if (!edge.sites!.some((site) => site.file === file && site.line === row.line))
+            edge.sites!.push({ file, line: row.line })
         }
         for (const char of row.code.slice(offset, limit)) {
           if (char === '(') parentheses++
@@ -274,7 +319,8 @@ function cCalls(
   }
   for (const symbol of seen.values()) {
     symbol.references?.sort((a, b) => a.kind.localeCompare(b.kind) || a.target.localeCompare(b.target))
-    for (const edge of symbol.references ?? []) edge.sites?.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line)
+    for (const edge of symbol.references ?? [])
+      edge.sites?.sort((a, b) => a.file.localeCompare(b.file) || a.line - b.line)
   }
 }
 
@@ -345,16 +391,21 @@ function cppSignature(block: string): string | undefined {
   const name = codeOf(tag(block, 'name') ?? '')
   const qualified = codeOf(tag(block, 'qualifiedname') ?? '')
   // Inside an owner's panel, use the in-class spelling from the declaration.
-  let declaration = qualified && definition.endsWith(qualified)
-    ? `${definition.slice(0, -qualified.length)}${name}${args}` : `${definition}${args}`
+  let declaration =
+    qualified && definition.endsWith(qualified)
+      ? `${definition.slice(0, -qualified.length)}${name}${args}`
+      : `${definition}${args}`
   for (const keyword of ['explicit', 'static', 'constexpr', 'consteval']) {
-    if (attr(block, keyword) === 'yes' && !new RegExp(`\\b${keyword}\\b`).test(definition)) declaration = `${keyword} ${declaration}`
+    if (attr(block, keyword) === 'yes' && !new RegExp(`\\b${keyword}\\b`).test(definition))
+      declaration = `${keyword} ${declaration}`
   }
-  if (attr(block, 'nodiscard') === 'yes' && !definition.includes('[[nodiscard')) declaration = `[[nodiscard]] ${declaration}`
+  if (attr(block, 'nodiscard') === 'yes' && !definition.includes('[[nodiscard'))
+    declaration = `[[nodiscard]] ${declaration}`
   const template = cppTemplateParameters(block)
   const constraint = codeOf(tag(block, 'requiresclause') ?? '')
   if (constraint && !/\brequires\b/.test(args)) {
-    declaration = template.length ? `requires ${constraint}\n${declaration}`
+    declaration = template.length
+      ? `requires ${constraint}\n${declaration}`
       : declaration.replace(/(\s*=\s*(?:default|delete|0))?$/, (_, ending = '') => ` requires ${constraint}${ending}`)
   }
   if (template.length) declaration = `template <${template.join(', ')}>\n${declaration}`
@@ -392,9 +443,7 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
   const definitionIds = new Set<string>()
   const pendingTypes = new Map<string, string[]>()
 
-  const files = readdirSync(xmlDir).filter(
-    (f) => f.endsWith('.xml') && f !== 'index.xml' && f !== 'Doxyfile.xml',
-  )
+  const files = readdirSync(xmlDir).filter((f) => f.endsWith('.xml') && f !== 'index.xml' && f !== 'Doxyfile.xml')
 
   const documents = files.sort().map((file) => ({ file, xml: readFileSync(join(xmlDir, file), 'utf8') }))
   if (c) {
@@ -423,7 +472,7 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
     const owner = normalizeCppName(textOf(tag(xml, 'compoundname') ?? ''))
     if (!owner) continue
 
-    const ownerId = c ? nativeIds.get(compoundId) ?? owner : owner
+    const ownerId = c ? (nativeIds.get(compoundId) ?? owner) : owner
     if (kind && compound[1] !== 'namespace') {
       // A compound's own descriptions sit at the end of `<compounddef>`, after
       // every `<sectiondef>` and immediately before `<location>`. Taking the
@@ -447,17 +496,19 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
         const sym: ApiSymbol = {
           id: ownerId,
           publicId: ownerId,
-          ...(c ? { qualifiedName: cDisplayName(owner, kind), namespace: '', parent: compoundParents.get(compoundId) } : {}),
+          ...(c
+            ? { qualifiedName: cDisplayName(owner, kind), namespace: '', parent: compoundParents.get(compoundId) }
+            : {}),
           name: c ? cDisplayName(cppUnqualifiedName(owner), kind) : cppUnqualifiedName(owner),
           kind,
           modifiers: [],
-          signatures: c && !owner.includes('::') && !syntheticCName(owner) ? [{ raw: `${kind} ${owner};`, params: [] }] : [],
-          doc:
-            brief || detail
-              ? { summary: brief, body: detail || undefined }
-              : undefined,
+          signatures:
+            c && !owner.includes('::') && !syntheticCName(owner) ? [{ raw: `${kind} ${owner};`, params: [] }] : [],
+          doc: brief || detail ? { summary: brief, body: detail || undefined } : undefined,
           extends: bases.length ? bases : undefined,
-          source: c ? cLocation(ownLocation, file).source : { file: location?.[1] ?? file, line: Number(location?.[2] ?? 1) },
+          source: c
+            ? cLocation(ownLocation, file).source
+            : { file: location?.[1] ?? file, line: Number(location?.[2] ?? 1) },
         }
         seen.set(ownerId, sym)
         symbols.push(sym)
@@ -480,16 +531,25 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
       // share one identity; static declarations remain local to their file.
       const local = attr(block, 'static') === 'yes' || nativeKind === 'define' || name.startsWith('@')
       const id = c
-        ? parent ? `${parent}::${name}` : `c:${nativeKind}:${local ? `${owner}:` : ''}${name}`
+        ? parent
+          ? `${parent}::${name}`
+          : `c:${nativeKind}:${local ? `${owner}:` : ''}${name}`
         : `${parent ?? owner}::${name}`
       const nativeId = attr(block, 'id')
       if (c && nativeId) nativeIds.set(nativeId, id)
       const nativeLocation = /<location\b([^>]*)\/>/.exec(block)?.[1] ?? ''
-      const { source: nativeSource, isDefinition } = cLocation(nativeLocation, file,
-        attr(block, 'extern') === 'yes' && !tag(block, 'initializer'))
+      const { source: nativeSource, isDefinition } = cLocation(
+        nativeLocation,
+        file,
+        attr(block, 'extern') === 'yes' && !tag(block, 'initializer'),
+      )
       const sourceFile = nativeSource.file
       if (c) {
-        pendingTypes.set(id, [...(pendingTypes.get(id) ?? []), codeOf(tag(block, 'type') ?? ''), codeOf(tag(block, 'argsstring') ?? '')])
+        pendingTypes.set(id, [
+          ...(pendingTypes.get(id) ?? []),
+          codeOf(tag(block, 'type') ?? ''),
+          codeOf(tag(block, 'argsstring') ?? ''),
+        ])
         const refs = pendingReferences.get(id) ?? []
         for (const typeBlock of block.matchAll(/<type>([\s\S]*?)<\/type>/g)) {
           for (const ref of typeBlock[1].matchAll(/<ref\b([^>]*)>([\s\S]*?)<\/ref>/g)) {
@@ -525,8 +585,11 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
           ? {
               params: paramsOf(block, paramDocs(block), c),
               ...(templateParameters.length ? { typeParams: templateParameters } : {}),
-              ...(c ? { raw: `${codeOf(tag(block, 'definition') ?? '')}${codeOf(tag(block, 'argsstring') ?? '')}` }
-                : cppSignature(block) ? { raw: cppSignature(block) } : {}),
+              ...(c
+                ? { raw: `${codeOf(tag(block, 'definition') ?? '')}${codeOf(tag(block, 'argsstring') ?? '')}` }
+                : cppSignature(block)
+                  ? { raw: cppSignature(block) }
+                  : {}),
               returns: returnType || undefined,
               returnsDoc: returnDoc || undefined,
             }
@@ -559,18 +622,24 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
       const sym: ApiSymbol = {
         id,
         publicId: id,
-        ...(c ? { qualifiedName: parent ? cDisplayName(`${owner}::${name}`, syntheticCName(name) ? nativeKind : undefined) : cDisplayName(name, nativeKind), namespace: '' } : {}),
+        ...(c
+          ? {
+              qualifiedName: parent
+                ? cDisplayName(`${owner}::${name}`, syntheticCName(name) ? nativeKind : undefined)
+                : cDisplayName(name, nativeKind),
+              namespace: '',
+            }
+          : {}),
         name: c ? cDisplayName(name, /^(struct|union|enum)\b/.exec(returnType)?.[1] ?? nativeKind) : name,
         kind: memberKind === 'method' && !parent ? 'function' : memberKind,
         modifiers: c && nativeKind === 'define' ? [...modifiersOf(block), 'macro'] : modifiersOf(block),
         parent,
         signatures: signature ? [signature] : c ? [{ raw: cDeclaration(block, nativeKind, name), params: [] }] : [],
         type: signature ? undefined : returnType || undefined,
-        ...(c && tag(block, 'initializer') ? { value: codeOf(tag(block, 'initializer') ?? '').replace(/^=\s*/, '') } : {}),
-        doc:
-          brief || detail
-            ? { summary: brief, body: detail || undefined }
-            : undefined,
+        ...(c && tag(block, 'initializer')
+          ? { value: codeOf(tag(block, 'initializer') ?? '').replace(/^=\s*/, '') }
+          : {}),
+        doc: brief || detail ? { summary: brief, body: detail || undefined } : undefined,
         source: c ? nativeSource : { file: location?.[1] ?? file, line: Number(location?.[2] ?? 1) },
       }
       if (c && isDefinition) definitionIds.add(id)
@@ -595,18 +664,28 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
           const valueSym: ApiSymbol = {
             id: valueId,
             publicId: valueId,
-            ...(c ? { qualifiedName: valueName, namespace: '', value: codeOf(tag(value, 'initializer') ?? '').replace(/^=\s*/, '') || undefined } : {}),
+            ...(c
+              ? {
+                  qualifiedName: valueName,
+                  namespace: '',
+                  value: codeOf(tag(value, 'initializer') ?? '').replace(/^=\s*/, '') || undefined,
+                }
+              : {}),
             name: valueName,
             // No `variant` kind exists, and a named member of an enum is
             // what a constant is — the same choice the tree-sitter specs make.
             kind: 'constant',
             modifiers: [],
             parent: id,
-            signatures: c ? [{ raw: `${valueName}${tag(value, 'initializer') ? ` ${codeOf(tag(value, 'initializer') ?? '')}` : ''}`, params: [] }] : [],
-            doc:
-              valueBrief || valueDetail
-                ? { summary: valueBrief, body: valueDetail || undefined }
-                : undefined,
+            signatures: c
+              ? [
+                  {
+                    raw: `${valueName}${tag(value, 'initializer') ? ` ${codeOf(tag(value, 'initializer') ?? '')}` : ''}`,
+                    params: [],
+                  },
+                ]
+              : [],
+            doc: valueBrief || valueDetail ? { summary: valueBrief, body: valueDetail || undefined } : undefined,
             source: c ? { file: sourceFile } : { file: location?.[1] ?? file, line: Number(location?.[2] ?? 1) },
           }
           if (c && attr(value, 'id')) nativeIds.set(attr(value, 'id')!, valueId)
@@ -628,9 +707,15 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
         // Preserve that uncertainty instead of claiming a compiler call edge.
         const kind = ref.kind
         const related = seen.get(target)!
-        if (kind === 'reference' && related.kind === 'function'
-          && related.modifiers.includes('static') && related.source.file !== symbol.source.file) {
-          options.onDiagnostic?.(`Omitted cross-file static reference ${symbol.id} -> ${target} (${ref.nativeId}); ${symbol.source.file} -> ${related.source.file}`)
+        if (
+          kind === 'reference' &&
+          related.kind === 'function' &&
+          related.modifiers.includes('static') &&
+          related.source.file !== symbol.source.file
+        ) {
+          options.onDiagnostic?.(
+            `Omitted cross-file static reference ${symbol.id} -> ${target} (${ref.nativeId}); ${symbol.source.file} -> ${related.source.file}`,
+          )
           continue
         }
         unique.set(`${kind}:${target}`, { target, kind })
@@ -639,19 +724,34 @@ export function extractDoxygen(xmlDir: string, sourceRoot = '', options: Doxygen
       // Doxygen omits a ref when a C tag and a function share the name.
       // An explicit tag keyword resolves in C's tag namespace, never to the
       // same-named ordinary function or typedef.
-      const types = [...(pendingTypes.get(symbol.id) ?? []), symbol.type, ...symbol.signatures.flatMap((signature) => [signature.returns, ...signature.params.map((param) => param.type)])]
-      for (const type of types) for (const match of (type ?? '').matchAll(/\b(struct|union|enum)\s+([A-Za-z_]\w*)/g)) {
-        const target = `c:${match[1]}:${match[2]}`
-        if (!seen.has(target) || target === symbol.id) continue
-        unique.set(`type:${target}`, { target, kind: 'type' })
-        ;(symbol.imports ??= {})[match[2]] = target
-      }
-      if (unique.size) symbol.references = [...unique.values()].sort((a, b) => a.kind.localeCompare(b.kind) || a.target.localeCompare(b.target))
-      const displayType = (type: string | undefined) => type && syntheticCName(type)
-        ? `anonymous ${/\b(struct|union|enum)\b/.exec(type)?.[1] ?? 'type'}` : type
+      const types = [
+        ...(pendingTypes.get(symbol.id) ?? []),
+        symbol.type,
+        ...symbol.signatures.flatMap((signature) => [
+          signature.returns,
+          ...signature.params.map((param) => param.type),
+        ]),
+      ]
+      for (const type of types)
+        for (const match of (type ?? '').matchAll(/\b(struct|union|enum)\s+([A-Za-z_]\w*)/g)) {
+          const target = `c:${match[1]}:${match[2]}`
+          if (!seen.has(target) || target === symbol.id) continue
+          unique.set(`type:${target}`, { target, kind: 'type' })
+          ;(symbol.imports ??= {})[match[2]] = target
+        }
+      if (unique.size)
+        symbol.references = [...unique.values()].sort(
+          (a, b) => a.kind.localeCompare(b.kind) || a.target.localeCompare(b.target),
+        )
+      const displayType = (type: string | undefined) =>
+        type && syntheticCName(type) ? `anonymous ${/\b(struct|union|enum)\b/.exec(type)?.[1] ?? 'type'}` : type
       if (symbol.type) symbol.type = displayType(symbol.type)
       for (const signature of symbol.signatures) {
-        if (syntheticCName(signature.returns ?? '') || signature.params.some((param) => syntheticCName(param.type ?? ''))) delete signature.raw
+        if (
+          syntheticCName(signature.returns ?? '') ||
+          signature.params.some((param) => syntheticCName(param.type ?? ''))
+        )
+          delete signature.raw
         if (signature.returns) signature.returns = displayType(signature.returns)
         for (const param of signature.params) if (param.type) param.type = displayType(param.type)
       }
diff --git a/packages/api-model/src/languages/fsharp-examples.ts b/packages/api-model/src/languages/fsharp-examples.ts
index 0cc97fc20..e25a8436c 100644
--- a/packages/api-model/src/languages/fsharp-examples.ts
+++ b/packages/api-model/src/languages/fsharp-examples.ts
@@ -25,18 +25,26 @@ export function attachCompleteFSharpExamples(
   const raw = read('examples/api/manifest.json')
   if (raw === undefined) return
   const manifest = JSON.parse(raw) as Manifest
-  if (manifest.schemaVersion !== 1 || !Array.isArray(manifest.examples) || !manifest.examples.length ||
-      JSON.stringify(manifest.setupFiles) !== JSON.stringify(['global.json', 'examples/api/NuGet.config'])) {
+  if (
+    manifest.schemaVersion !== 1 ||
+    !Array.isArray(manifest.examples) ||
+    !manifest.examples.length ||
+    JSON.stringify(manifest.setupFiles) !== JSON.stringify(['global.json', 'examples/api/NuGet.config'])
+  ) {
     throw new Error('Invalid F# example manifest')
   }
   const profile = manifest.profiles?.fsharp
-  if (profile?.package !== 'LibTmux.FSharp' || profile.projectFile !== 'examples/api/fsharp/Example.fsproj' ||
-      profile.entrypoint !== 'Program.fs') throw new Error('Invalid F# example profile')
+  if (
+    profile?.package !== 'LibTmux.FSharp' ||
+    profile.projectFile !== 'examples/api/fsharp/Example.fsproj' ||
+    profile.entrypoint !== 'Program.fs'
+  )
+    throw new Error('Invalid F# example profile')
   if (source.repo !== 'libtmux/libtmux-dotnet' || !/^[0-9a-f]{40}$/.test(source.revision)) {
     throw new Error('F# examples require the public repository and full source revision')
   }
   const codeFor = (path: string): string => {
-    if (path !== 'global.json' && !/^examples\/(?:[\w.-]+\/)*[\w.-]+$/.test(path) || path.split('/').includes('..')) {
+    if ((path !== 'global.json' && !/^examples\/(?:[\w.-]+\/)*[\w.-]+$/.test(path)) || path.split('/').includes('..')) {
       throw new Error(`Invalid F# example source path: ${path}`)
     }
     const code = read(path)
@@ -56,49 +64,70 @@ export function attachCompleteFSharpExamples(
   const ids = new Set<string>()
   for (const program of manifest.examples) {
     if (program.profile !== 'fsharp') continue
-    if (!/^fsharp-[A-Za-z0-9]+$/.test(program.id) || ids.has(program.id) ||
-        typeof program.title !== 'string' || !program.title.trim() ||
-        typeof program.description !== 'string' || !program.description.trim() ||
-        !/^examples\/LibTmux\.FSharp\.Examples\/Programs\/[A-Za-z0-9]+\.fs$/.test(program.sourceFile) ||
-        typeof program.output !== 'string' || !program.output.trim() ||
-        !program.output.endsWith('\n') || program.output.includes('\r') ||
-        !Array.isArray(program.targets) || !program.targets.length) {
+    if (
+      !/^fsharp-[A-Za-z0-9]+$/.test(program.id) ||
+      ids.has(program.id) ||
+      typeof program.title !== 'string' ||
+      !program.title.trim() ||
+      typeof program.description !== 'string' ||
+      !program.description.trim() ||
+      !/^examples\/LibTmux\.FSharp\.Examples\/Programs\/[A-Za-z0-9]+\.fs$/.test(program.sourceFile) ||
+      typeof program.output !== 'string' ||
+      !program.output.trim() ||
+      !program.output.endsWith('\n') ||
+      program.output.includes('\r') ||
+      !Array.isArray(program.targets) ||
+      !program.targets.length
+    ) {
       throw new Error(`Invalid F# example metadata: ${program.id}`)
     }
     ids.add(program.id)
-    const blocks: NonNullable<DocBlock['examples']> = [{
-      lang: 'console',
-      intro: `${program.description.replace(/\n/g, ' ')} Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK ${sdk}, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:`,
-      code: `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout --detach ${source.revision}\n`,
-    }]
-    for (const file of setup) blocks.push({
-      lang: file.lang, intro: `Save this complete consumer setup as ${file.path}:`,
-      sourceUrl: urlFor(file.sourceFile), code: codeFor(file.sourceFile),
-    })
-    blocks.push({
-      lang: 'fsharp',
-      intro: 'Save this complete program as Program.fs. It creates a private server with LibTmux.Server.CreateOwnedAsync; use! disposes owned scopes after success, cancellation or failure. The F# facade has no separate server constructor.',
-      sourceUrl: urlFor(program.sourceFile), code: codeFor(program.sourceFile),
-    }, {
-      lang: 'console',
-      intro: 'Build the exact source packages and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:',
-      code: '$ export NUGET_PACKAGES="$PWD/packages" && \\\n' +
-        '  dotnet restore libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj --locked-mode && \\\n' +
-        '  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \\\n' +
-        '    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \\\n' +
-        '    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \\\n' +
-        '  dotnet pack libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj \\\n' +
-        '    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \\\n' +
-        '    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \\\n' +
-        '  dotnet restore Example.fsproj --configfile NuGet.config && \\\n' +
-        '  dotnet build Example.fsproj --configuration Release --no-restore --warnaserror && \\\n' +
-        '  export LIBTMUX_TMUX="$(command -v tmux)" && \\\n' +
-        '  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \\\n' +
-        '  mkdir -p "$TMUX_TMPDIR" && \\\n' +
-        '  unset TMUX TMUX_PANE && \\\n' +
-        '  dotnet bin/Release/net8.0/Example.dll && \\\n' +
-        '  dotnet bin/Release/net10.0/Example.dll\n',
-    }, { lang: 'text', intro: 'Expected program output from each framework:', code: program.output })
+    const blocks: NonNullable<DocBlock['examples']> = [
+      {
+        lang: 'console',
+        intro: `${program.description.replace(/\n/g, ' ')} Use Linux or macOS with Git, tmux 3.2a or newer, .NET SDK ${sdk}, and the .NET 8 and 10 runtimes. In an empty directory, fetch the documented library revision:`,
+        code: `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout --detach ${source.revision}\n`,
+      },
+    ]
+    for (const file of setup)
+      blocks.push({
+        lang: file.lang,
+        intro: `Save this complete consumer setup as ${file.path}:`,
+        sourceUrl: urlFor(file.sourceFile),
+        code: codeFor(file.sourceFile),
+      })
+    blocks.push(
+      {
+        lang: 'fsharp',
+        intro:
+          'Save this complete program as Program.fs. It creates a private server with LibTmux.Server.CreateOwnedAsync; use! disposes owned scopes after success, cancellation or failure. The F# facade has no separate server constructor.',
+        sourceUrl: urlFor(program.sourceFile),
+        code: codeFor(program.sourceFile),
+      },
+      {
+        lang: 'console',
+        intro:
+          'Build the exact source packages and the saved consumer, then run both supported frameworks. The local package feed prevents an unrelated published package from satisfying the restore. Each program checks its result and exits unsuccessfully after an unhandled error:',
+        code:
+          '$ export NUGET_PACKAGES="$PWD/packages" && \\\n' +
+          '  dotnet restore libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj --locked-mode && \\\n' +
+          '  dotnet pack libtmux-source/src/LibTmux/LibTmux.csproj \\\n' +
+          '    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \\\n' +
+          '    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \\\n' +
+          '  dotnet pack libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj \\\n' +
+          '    --configuration Release --no-restore -p:ContinuousIntegrationBuild=true \\\n' +
+          '    --output "$PWD/libtmux-source/artifacts/api-example-packages" && \\\n' +
+          '  dotnet restore Example.fsproj --configfile NuGet.config && \\\n' +
+          '  dotnet build Example.fsproj --configuration Release --no-restore --warnaserror && \\\n' +
+          '  export LIBTMUX_TMUX="$(command -v tmux)" && \\\n' +
+          '  export TMUX_TMPDIR=/tmp/libtmux-dotnet-dev && \\\n' +
+          '  mkdir -p "$TMUX_TMPDIR" && \\\n' +
+          '  unset TMUX TMUX_PANE && \\\n' +
+          '  dotnet bin/Release/net8.0/Example.dll && \\\n' +
+          '  dotnet bin/Release/net10.0/Example.dll\n',
+      },
+      { lang: 'text', intro: 'Expected program output from each framework:', code: program.output },
+    )
     const targets = new Set<string>()
     for (const target of program.targets) {
       // XML documentation addresses include kind, generic arity and parameter metadata.
@@ -106,12 +135,18 @@ export function attachCompleteFSharpExamples(
       if (typeof target !== 'string' || !/^[MT]:LibTmux\.FSharp\.[\w.]+(?:`{1,2}\d+)?(?:\([^()\s]+\))?$/.test(target)) {
         throw new Error(`Invalid F# compiler target: ${target}`)
       }
-      const id = target.slice(2).replace(/\(.*$/, '').replace(/`{1,2}\d+$/, '')
+      const id = target
+        .slice(2)
+        .replace(/\(.*$/, '')
+        .replace(/`{1,2}\d+$/, '')
       if (targets.has(id)) throw new Error(`Duplicate F# example target: ${target}`)
       const matches = symbols.filter((symbol) => symbol.id === id)
-      if (matches.length !== 1 || (target.startsWith('M:')
-        ? !['function', 'method'].includes(matches[0].kind)
-        : !['module', 'class', 'struct', 'enum', 'typealias'].includes(matches[0].kind))) {
+      if (
+        matches.length !== 1 ||
+        (target.startsWith('M:')
+          ? !['function', 'method'].includes(matches[0].kind)
+          : !['module', 'class', 'struct', 'enum', 'typealias'].includes(matches[0].kind))
+      ) {
         throw new Error(`F# example target must resolve once with its native kind: ${target}`)
       }
       targets.add(id)
diff --git a/packages/api-model/src/languages/fsharp.ts b/packages/api-model/src/languages/fsharp.ts
index 2d61e909a..cd3bf297a 100644
--- a/packages/api-model/src/languages/fsharp.ts
+++ b/packages/api-model/src/languages/fsharp.ts
@@ -29,9 +29,13 @@ interface FSharpArtifact {
 /** Convert the native compiler's public signature tree to the shared reference model. */
 export function extractFSharpArtifact(input: unknown, revision?: string): ApiModel {
   const artifact = input as FSharpArtifact
-  if (artifact?.schema !== 1 || artifact.port !== 'fsharp' ||
-      typeof artifact.compiler !== 'string' || !Array.isArray(artifact.declarations) ||
-      !artifact.declarations.length) {
+  if (
+    artifact?.schema !== 1 ||
+    artifact.port !== 'fsharp' ||
+    typeof artifact.compiler !== 'string' ||
+    !Array.isArray(artifact.declarations) ||
+    !artifact.declarations.length
+  ) {
     throw new Error('F# compiler artifact has an unsupported schema or no declarations')
   }
   const ids = new Set(artifact.declarations.map((item) => item.id))
@@ -70,7 +74,10 @@ export function extractFSharpArtifact(input: unknown, revision?: string): ApiMod
   const merged = new Map<string, ApiSymbol>()
   for (const symbol of symbols) {
     const previous = merged.get(symbol.id)
-    if (!previous) { merged.set(symbol.id, symbol); continue }
+    if (!previous) {
+      merged.set(symbol.id, symbol)
+      continue
+    }
     // F# permits a type and its companion module to share a public name.
     if (previous.kind !== 'module' && symbol.kind !== 'module') {
       throw new Error(`Duplicate F# public declaration: ${symbol.id}`)
@@ -80,7 +87,8 @@ export function extractFSharpArtifact(input: unknown, revision?: string): ApiMod
     previous.doc ??= symbol.doc
   }
   return {
-    port: 'fsharp', revision,
+    port: 'fsharp',
+    revision,
     extractor: `FSharp.Compiler.Service ${artifact.compiler} (public .fsi syntax)`,
     symbols: [...merged.values()],
   }
@@ -92,7 +100,9 @@ export function extractFSharp(root: string, revision?: string): ApiModel {
   if (projects.length !== 1) throw new Error(`Expected one F# project in ${root}`)
   const script = fileURLToPath(new URL('../../scripts/extract-fsharp.fsx', import.meta.url))
   const output = execFileSync('dotnet', ['fsi', '--warnaserror', '--exec', script, join(root, projects[0])], {
-    cwd: root, encoding: 'utf8', maxBuffer: 16 * 1024 * 1024,
+    cwd: root,
+    encoding: 'utf8',
+    maxBuffer: 16 * 1024 * 1024,
     stdio: ['ignore', 'pipe', 'inherit'],
   })
   return extractFSharpArtifact(JSON.parse(output), revision)
diff --git a/packages/api-model/src/languages/go-examples.ts b/packages/api-model/src/languages/go-examples.ts
index 510b96bbd..6faa4677c 100644
--- a/packages/api-model/src/languages/go-examples.ts
+++ b/packages/api-model/src/languages/go-examples.ts
@@ -11,9 +11,7 @@ export interface CompleteGoExample {
 }
 
 /** Read opt-in native examples without turning ordinary test helpers into API pages. */
-export async function readCompleteGoExamples(
-  files: { file: string; code: string }[],
-): Promise<CompleteGoExample[]> {
+export async function readCompleteGoExamples(files: { file: string; code: string }[]): Promise<CompleteGoExample[]> {
   const parser = await parserFor('go')
   const examples: CompleteGoExample[] = []
   const seen = new Set<string>()
@@ -34,13 +32,15 @@ export async function readCompleteGoExamples(
         const name = declaration.childForFieldName('name')?.text ?? ''
         const match = /^Example([A-Z][A-Za-z0-9]*)(?:_([A-Z][A-Za-z0-9]*))?_complete$/.exec(name)
         if (!match) fail('expected ExampleName_complete or ExampleType_Method_complete')
-        if (declaration.childForFieldName('parameters')?.namedChildCount ||
-            declaration.childForFieldName('result') || declaration.childForFieldName('type_parameters')) {
+        if (
+          declaration.childForFieldName('parameters')?.namedChildCount ||
+          declaration.childForFieldName('result') ||
+          declaration.childForFieldName('type_parameters')
+        ) {
           fail('Example functions cannot have parameters, results, or type parameters')
         }
         const scope = basename(dirname(file))
-        const packageName = root.namedChildren.find((node) => node?.type === 'package_clause')
-          ?.namedChildren[0]?.text
+        const packageName = root.namedChildren.find((node) => node?.type === 'package_clause')?.namedChildren[0]?.text
         if (packageName !== `${scope}_test`) fail('use an external test package beside its API')
         const symbol = `${scope}.${match![1]}${match![2] ? `.${match![2]}` : ''}`
         if (seen.has(symbol)) fail(`duplicate example for ${symbol}`)
@@ -58,8 +58,15 @@ export async function readCompleteGoExamples(
         if (!intro) fail('a task description is required')
         const output = /\/\/ Output:([^\n]*)\n((?:[\t ]*\/\/[^\n]*\n)*)[\t ]*\}$/.exec(declaration.text)
         if (!output) fail('a final Output assertion is required')
-        const expected = [output![1].trim(), ...output![2].trimEnd().split('\n')
-          .map((line) => line.replace(/^[\t ]*\/\/ ?/, ''))].join('\n').trim()
+        const expected = [
+          output![1].trim(),
+          ...output![2]
+            .trimEnd()
+            .split('\n')
+            .map((line) => line.replace(/^[\t ]*\/\/ ?/, '')),
+        ]
+          .join('\n')
+          .trim()
         if (!expected) fail('the Output assertion must describe an observable result')
         seen.add(symbol)
         examples.push({ symbol, file, code, intro, output: expected })
@@ -98,13 +105,15 @@ export function attachCompleteGoExamples(
       },
       {
         lang: 'go',
-        intro: 'Save this complete example as example_test.go. It creates a private temporary socket and stops its server before removing the directory. Cleanup failure fails the example and retains the socket directory.',
+        intro:
+          'Save this complete example as example_test.go. It creates a private temporary socket and stops its server before removing the directory. Cleanup failure fails the example and retains the socket directory.',
         sourceUrl: `https://github.com/${source.repo}/blob/${source.revision}/${example.file}`,
         code: example.code,
       },
       {
         lang: 'console',
-        intro: 'Run the saved file. Go checks the Output comment and fails on different output or an operation or cleanup error:',
+        intro:
+          'Run the saved file. Go checks the Output comment and fails on different output or an operation or cleanup error:',
         code: '$ GOWORK=off go test -count=1 -v example_test.go\n',
       },
     ]
diff --git a/packages/api-model/src/languages/julia.ts b/packages/api-model/src/languages/julia.ts
index 41ec5899f..bc4554b5b 100644
--- a/packages/api-model/src/languages/julia.ts
+++ b/packages/api-model/src/languages/julia.ts
@@ -2,14 +2,28 @@ import { fromMarkdown } from 'mdast-util-from-markdown'
 import { toMarkdown } from 'mdast-util-to-markdown'
 import type { ApiModel, ApiProduct, ApiSymbol, DocBlock, Signature } from '../model.ts'
 
-interface Source { file: string; line: number }
-interface Documentation { signature: string; markdown: string; source: Source; fields: Record<string, string> }
+interface Source {
+  file: string
+  line: number
+}
+interface Documentation {
+  signature: string
+  markdown: string
+  source: Source
+  fields: Record<string, string>
+}
 interface Method {
   identity: string
   kind: 'function' | 'constructor' | 'call'
   signature: string
   sourceSignature: string | null
-  parameters: { name: string | null; type: string | null; default: string | null; keyword: boolean; variadic: boolean }[]
+  parameters: {
+    name: string | null
+    type: string | null
+    default: string | null
+    keyword: boolean
+    variadic: boolean
+  }[]
   typeParameters: string[]
   receiver: { name: string; type: string } | null
   module: string
@@ -54,34 +68,48 @@ interface JuliaArtifact {
 
 function assertArtifact(input: unknown, revision?: string): JuliaArtifact {
   const artifact = input as JuliaArtifact
-  if (artifact?.schema !== 1 || artifact.port !== 'julia' || !Array.isArray(artifact.symbols) ||
-    !Array.isArray(artifact.modules) || !Array.isArray(artifact.extensionMethods) ||
-    !/^[a-f0-9]{40}$/.test(artifact.source?.revision ?? '')) {
+  if (
+    artifact?.schema !== 1 ||
+    artifact.port !== 'julia' ||
+    !Array.isArray(artifact.symbols) ||
+    !Array.isArray(artifact.modules) ||
+    !Array.isArray(artifact.extensionMethods) ||
+    !/^[a-f0-9]{40}$/.test(artifact.source?.revision ?? '')
+  ) {
     throw new Error('Julia documentation artifact has an unsupported schema or source identity')
   }
-  if (revision && artifact.source.revision !== revision) throw new Error('Julia artifact source revision differs from the selected checkout')
+  if (revision && artifact.source.revision !== revision)
+    throw new Error('Julia artifact source revision differs from the selected checkout')
   const ids = new Set<string>()
   for (const symbol of artifact.symbols) {
-    if (ids.has(symbol.id) || symbol.id !== `${symbol.module}.${symbol.name}`) throw new Error(`Julia binding has a duplicate or unknown identity: ${symbol.id}`)
+    if (ids.has(symbol.id) || symbol.id !== `${symbol.module}.${symbol.name}`)
+      throw new Error(`Julia binding has a duplicate or unknown identity: ${symbol.id}`)
     ids.add(symbol.id)
     if (!symbol.source?.file || !symbol.source.line) throw new Error(`Julia binding lost its source: ${symbol.id}`)
   }
   for (const entry of artifact.modules) {
     const expected = [...entry.bindings, ...entry.supportingBindings].sort()
-    const actual = artifact.symbols.filter((symbol) => symbol.module === entry.module).map((symbol) => symbol.name).sort()
-    if (JSON.stringify(expected) !== JSON.stringify(actual)) throw new Error(`Julia module inventory differs: ${entry.module}`)
+    const actual = artifact.symbols
+      .filter((symbol) => symbol.module === entry.module)
+      .map((symbol) => symbol.name)
+      .sort()
+    if (JSON.stringify(expected) !== JSON.stringify(actual))
+      throw new Error(`Julia module inventory differs: ${entry.module}`)
   }
   for (const symbol of [...artifact.symbols, ...artifact.extensionMethods]) {
-    if (new Set(symbol.methods.map((method) => method.identity)).size !== symbol.methods.length) throw new Error(`Julia binding repeats a method: ${symbol.id}`)
+    if (new Set(symbol.methods.map((method) => method.identity)).size !== symbol.methods.length)
+      throw new Error(`Julia binding repeats a method: ${symbol.id}`)
     for (const method of symbol.methods) {
       if (!method.identity || !method.signature || !method.source?.file || !method.source.line || !method.kind) {
         throw new Error(`Julia method lost its signature or source: ${symbol.id}`)
       }
-      if (method.requiresExtension && !artifact.extensions.includes(method.module)) throw new Error(`Julia method requires an unloaded extension: ${method.module}`)
+      if (method.requiresExtension && !artifact.extensions.includes(method.module))
+        throw new Error(`Julia method requires an unloaded extension: ${method.module}`)
     }
   }
   for (const symbol of artifact.symbols.filter((entry) => entry.kind === 'type' && entry.aliasOf)) {
-    if (!symbol.definition || !symbol.typeArguments.length || !ids.has(symbol.aliasOf!)) throw new Error(`Julia alias lost its definition or target: ${symbol.id}`)
+    if (!symbol.definition || !symbol.typeArguments.length || !ids.has(symbol.aliasOf!))
+      throw new Error(`Julia alias lost its definition or target: ${symbol.id}`)
   }
   return artifact
 }
@@ -95,7 +123,7 @@ function documentation(records: Documentation[], names: Set<string> = new Set())
   for (const node of tree.children) {
     if (node.type === 'heading') {
       if (node.depth <= argumentsDepth) argumentsDepth = 0
-      const title = node.children.map((part) => 'value' in part ? part.value : '').join('')
+      const title = node.children.map((part) => ('value' in part ? part.value : '')).join('')
       if (/^(?:(?:Keyword|Positional)\s+)?Arguments$/i.test(title)) argumentsDepth = node.depth
     }
     if (!argumentsDepth || node.type !== 'list') continue
@@ -103,13 +131,17 @@ function documentation(records: Documentation[], names: Set<string> = new Set())
       const first = item.children[0]
       if (first?.type !== 'paragraph') return true
       const [label, separator, ...rest] = first.children
-      if (label?.type !== 'inlineCode' || separator?.type !== 'text' || !/^\s*[:–-]\s*/.test(separator.value)) return true
+      if (label?.type !== 'inlineCode' || separator?.type !== 'text' || !/^\s*[:–-]\s*/.test(separator.value))
+        return true
       const name = label.value.split(/::|=|\.\.\./)[0]!.trim()
       if (!names.has(name)) return true
-      const description = toMarkdown({ type: 'root', children: [
-        { ...first, children: [{ ...separator, value: separator.value.replace(/^\s*[:–-]\s*/, '') }, ...rest] },
-        ...item.children.slice(1),
-      ] }).trim()
+      const description = toMarkdown({
+        type: 'root',
+        children: [
+          { ...first, children: [{ ...separator, value: separator.value.replace(/^\s*[:–-]\s*/, '') }, ...rest] },
+          ...item.children.slice(1),
+        ],
+      }).trim()
       if (!description) return true
       const previous = params.get(name)
       params.set(name, previous && previous !== description ? `${previous}\n\n${description}` : description)
@@ -118,9 +150,16 @@ function documentation(records: Documentation[], names: Set<string> = new Set())
   }
   tree.children = tree.children.filter((node) => node.type !== 'list' || node.children.length > 0)
   // Once its list moved to Parameters, an empty Arguments heading adds no information.
-  tree.children = tree.children.filter((node, i, nodes) => !(node.type === 'heading' &&
-    /^(?:(?:Keyword|Positional)\s+)?Arguments$/i.test(node.children.map((part) => 'value' in part ? part.value : '').join('')) &&
-    (!nodes[i + 1] || (nodes[i + 1]!.type === 'heading' && (nodes[i + 1] as typeof node).depth <= node.depth))))
+  tree.children = tree.children.filter(
+    (node, i, nodes) =>
+      !(
+        node.type === 'heading' &&
+        /^(?:(?:Keyword|Positional)\s+)?Arguments$/i.test(
+          node.children.map((part) => ('value' in part ? part.value : '')).join(''),
+        ) &&
+        (!nodes[i + 1] || (nodes[i + 1]!.type === 'heading' && (nodes[i + 1] as typeof node).depth <= node.depth))
+      ),
+  )
   const text = params.size ? toMarkdown(tree).trim() : raw
   if (!text) return { params, doc: undefined }
   const prose = text.replace(/^```[^\n]*\n[\s\S]*?```\s*/, '')
@@ -134,39 +173,66 @@ function documentation(records: Documentation[], names: Set<string> = new Set())
 export function extractJulia(input: unknown, expectedRevision?: string): ApiModel {
   const artifact = assertArtifact(input, expectedRevision)
   const source = (location: Source): ApiSymbol['source'] => ({
-    file: location.file, line: location.line, repo: artifact.source.repository,
-    revision: artifact.source.revision, extractedRevision: artifact.source.revision,
+    file: location.file,
+    line: location.line,
+    repo: artifact.source.repository,
+    revision: artifact.source.revision,
+    extractedRevision: artifact.source.revision,
   })
   const methodSignature = (method: Method): Signature => {
-    const parsed = documentation(method.documentation, new Set(method.parameters.flatMap((parameter) => parameter.name ? [parameter.name] : [])))
+    const parsed = documentation(
+      method.documentation,
+      new Set(method.parameters.flatMap((parameter) => (parameter.name ? [parameter.name] : []))),
+    )
     return {
-    identity: method.identity, methodKind: method.kind, raw: method.signature,
-    params: method.parameters.map((parameter, index) => ({
-      name: parameter.name && !parameter.name.startsWith('#') ? parameter.name : `argument${index + 1}`,
-      type: parameter.type ?? undefined, default: parameter.default ?? undefined,
-      keywordOnly: parameter.keyword,
-      variadic: parameter.variadic ? (parameter.keyword ? 'keyword' : 'positional') : undefined,
-      doc: parameter.name ? parsed.params.get(parameter.name) : undefined,
-    })),
-    typeParams: method.typeParameters,
-    receiver: method.receiver ?? undefined,
-    doc: parsed.doc, source: source(method.source),
-    extension: method.requiresExtension ? method.module : undefined,
+      identity: method.identity,
+      methodKind: method.kind,
+      raw: method.signature,
+      params: method.parameters.map((parameter, index) => ({
+        name: parameter.name && !parameter.name.startsWith('#') ? parameter.name : `argument${index + 1}`,
+        type: parameter.type ?? undefined,
+        default: parameter.default ?? undefined,
+        keywordOnly: parameter.keyword,
+        variadic: parameter.variadic ? (parameter.keyword ? 'keyword' : 'positional') : undefined,
+        doc: parameter.name ? parsed.params.get(parameter.name) : undefined,
+      })),
+      typeParams: method.typeParameters,
+      receiver: method.receiver ?? undefined,
+      doc: parsed.doc,
+      source: source(method.source),
+      extension: method.requiresExtension ? method.module : undefined,
     }
   }
   const symbols: ApiSymbol[] = []
   for (const entry of artifact.symbols) {
     const binding: ApiSymbol = {
-      id: entry.id, publicId: entry.id, name: entry.name, namespace: entry.module,
-      package: entry.package, product: entry.product,
-      kind: entry.kind === 'type' ? (entry.aliasOf ? 'typealias' : entry.abstract ? 'class' : 'struct') : entry.kind === 'macro' ? 'function' : entry.kind,
-      modifiers: [...(entry.abstract ? ['abstract' as const] : []), ...(entry.kind === 'macro' ? ['macro' as const] : [])],
+      id: entry.id,
+      publicId: entry.id,
+      name: entry.name,
+      namespace: entry.module,
+      package: entry.package,
+      product: entry.product,
+      kind:
+        entry.kind === 'type'
+          ? entry.aliasOf
+            ? 'typealias'
+            : entry.abstract
+              ? 'class'
+              : 'struct'
+          : entry.kind === 'macro'
+            ? 'function'
+            : entry.kind,
+      modifiers: [
+        ...(entry.abstract ? ['abstract' as const] : []),
+        ...(entry.kind === 'macro' ? ['macro' as const] : []),
+      ],
       apiScope: entry.supporting ? 'supporting' : 'exported',
       signatures: entry.methods.map(methodSignature),
       doc: documentation(entry.documentation.filter((record) => record.signature === 'Union{}')).doc,
-      type: entry.kind === 'type' ? entry.definition ?? entry.type : entry.kind === 'constant' ? entry.type : undefined,
+      type:
+        entry.kind === 'type' ? (entry.definition ?? entry.type) : entry.kind === 'constant' ? entry.type : undefined,
       typeParams: entry.kind === 'type' ? entry.typeArguments : undefined,
-      value: entry.kind === 'constant' ? entry.definition ?? undefined : undefined,
+      value: entry.kind === 'constant' ? (entry.definition ?? undefined) : undefined,
       extends: entry.supertype && entry.supertype !== 'Any' && !entry.aliasOf ? [entry.supertype] : undefined,
       imports: entry.aliasOf ? { [entry.name]: entry.aliasOf } : undefined,
       source: source(entry.kind === 'function' && entry.methods.length === 1 ? entry.methods[0]!.source : entry.source),
@@ -175,12 +241,23 @@ export function extractJulia(input: unknown, expectedRevision?: string): ApiMode
     // Aliases link to the underlying type; fields remain owned by that type.
     if (entry.aliasOf) continue
     for (const field of entry.fields) {
-      const fieldDoc = entry.documentation.map((record) => record.fields[field.name]).filter(Boolean).join('\n\n')
+      const fieldDoc = entry.documentation
+        .map((record) => record.fields[field.name])
+        .filter(Boolean)
+        .join('\n\n')
       symbols.push({
-        id: `${entry.id}.${field.name}`, publicId: `${entry.id}.${field.name}`,
-        name: field.name, namespace: entry.module, parent: entry.id, kind: 'property',
-        modifiers: entry.mutable ? [] : ['readonly'], type: field.type, signatures: [],
-        package: entry.package, product: entry.product, apiScope: binding.apiScope,
+        id: `${entry.id}.${field.name}`,
+        publicId: `${entry.id}.${field.name}`,
+        name: field.name,
+        namespace: entry.module,
+        parent: entry.id,
+        kind: 'property',
+        modifiers: entry.mutable ? [] : ['readonly'],
+        type: field.type,
+        signatures: [],
+        package: entry.package,
+        product: entry.product,
+        apiScope: binding.apiScope,
         doc: fieldDoc ? { summary: fieldDoc } : undefined,
         // Reflection gives field types but no field line; link to the containing source file.
         source: { ...source(entry.source), line: undefined },
@@ -191,9 +268,16 @@ export function extractJulia(input: unknown, expectedRevision?: string): ApiMode
     if (symbols.some((symbol) => symbol.id === entry.module)) continue
     const pkg = artifact.packages.find((candidate) => candidate.name === entry.package)!
     symbols.push({
-      id: entry.module, publicId: entry.module, name: entry.module, kind: 'module',
-      modifiers: [], signatures: [], package: entry.package, product: entry.product,
-      apiScope: 'exported', source: source({ file: pkg.file, line: 1 }),
+      id: entry.module,
+      publicId: entry.module,
+      name: entry.module,
+      kind: 'module',
+      modifiers: [],
+      signatures: [],
+      package: entry.package,
+      product: entry.product,
+      apiScope: 'exported',
+      source: source({ file: pkg.file, line: 1 }),
     })
   }
   for (const entry of artifact.extensionMethods) {
@@ -206,22 +290,34 @@ export function extractJulia(input: unknown, expectedRevision?: string): ApiMode
       const owner = artifact.modules.find((candidate) => candidate.package === packageName)
       if (!owner) throw new Error(`Julia external method has an unknown package: ${packageName}`)
       symbols.push({
-        id: `${packageName}.${entry.id}`, publicId: `${packageName}.${entry.id}`,
-        qualifiedName: entry.id, name: entry.id, namespace: owner.module,
-        kind: 'function', modifiers: [], signatures: methods.map(methodSignature),
-        package: packageName, product: owner.product, apiScope: 'exported',
+        id: `${packageName}.${entry.id}`,
+        publicId: `${packageName}.${entry.id}`,
+        qualifiedName: entry.id,
+        name: entry.id,
+        namespace: owner.module,
+        kind: 'function',
+        modifiers: [],
+        signatures: methods.map(methodSignature),
+        package: packageName,
+        product: owner.product,
+        apiScope: 'exported',
         doc: documentation(entry.documentation.filter((record) => record.signature === 'Union{}')).doc,
         source: source(methods[0]!.source),
       })
     }
   }
   return {
-    port: 'julia', repo: artifact.source.repository, revision: artifact.source.revision,
+    port: 'julia',
+    repo: artifact.source.repository,
+    revision: artifact.source.revision,
     extractor: `@libtmux/api-model@0.0.1 (${artifact.exporter.name} v${artifact.exporter.version})`,
     nativeProvenance: { files: artifact.source.files, exporter: artifact.exporter },
     sources: artifact.packages.map((pkg) => ({
-      package: pkg.name, product: artifact.modules.find((entry) => entry.package === pkg.name)!.product,
-      version: pkg.version, repo: artifact.source.repository, revision: artifact.source.revision,
+      package: pkg.name,
+      product: artifact.modules.find((entry) => entry.package === pkg.name)!.product,
+      version: pkg.version,
+      repo: artifact.source.repository,
+      revision: artifact.source.revision,
       extractedRevision: artifact.source.revision,
     })),
     symbols,
diff --git a/packages/api-model/src/languages/jvm-examples.ts b/packages/api-model/src/languages/jvm-examples.ts
index eac0579f6..f4f203644 100644
--- a/packages/api-model/src/languages/jvm-examples.ts
+++ b/packages/api-model/src/languages/jvm-examples.ts
@@ -3,7 +3,10 @@ import { qualifiedNameOf } from '../modules.ts'
 
 type JvmPort = 'java' | 'kotlin' | 'scala'
 type Variant = 'java' | 'kotlin' | 'scala-direct' | 'scala-cats'
-interface SourceFile { sourceFile: string; path: string }
+interface SourceFile {
+  sourceFile: string
+  path: string
+}
 interface Program extends SourceFile {
   id: string
   variant: Variant
@@ -20,11 +23,16 @@ interface Manifest {
 }
 
 const languages: Record<Variant, JvmPort> = {
-  java: 'java', kotlin: 'kotlin', 'scala-direct': 'scala', 'scala-cats': 'scala',
+  java: 'java',
+  kotlin: 'kotlin',
+  'scala-direct': 'scala',
+  'scala-cats': 'scala',
 }
 const setupLanguages: Record<string, string> = {
-  'settings.gradle.kts': 'kotlin', 'build.gradle.kts': 'kotlin',
-  'gradle.properties': 'properties', 'run.sh': 'sh',
+  'settings.gradle.kts': 'kotlin',
+  'build.gradle.kts': 'kotlin',
+  'gradle.properties': 'properties',
+  'run.sh': 'sh',
 }
 
 /** Read every displayed file from the same committed source revision as its citation. */
@@ -58,47 +66,71 @@ export function attachCompleteJvmExamples(
       throw new Error(`Invalid JVM example variant: ${program.id}`)
     }
     if (program.language !== port) continue
-    if (typeof program.id !== 'string' || !program.id || ids.has(program.id) ||
-        !Array.isArray(program.targets) || !program.targets.length ||
-        !program.targets.every((target) => typeof target === 'string' && target.length && !/\s/.test(target)) ||
-        typeof program.description !== 'string' || !program.description.trim() ||
-        typeof program.expectedOutput !== 'string' || !program.expectedOutput.trim() ||
-        !program.expectedOutput.endsWith('\n') ||
-        !/^io\.github\.libtmux(?:\.[\w$]+)+$/.test(program.mainClass) ||
-        !new RegExp(`^src/main/${port}/(?:[\\w]+/)*[\\w]+\\.${port === 'kotlin' ? 'kt' : port}$`).test(program.path)) {
+    if (
+      typeof program.id !== 'string' ||
+      !program.id ||
+      ids.has(program.id) ||
+      !Array.isArray(program.targets) ||
+      !program.targets.length ||
+      !program.targets.every((target) => typeof target === 'string' && target.length && !/\s/.test(target)) ||
+      typeof program.description !== 'string' ||
+      !program.description.trim() ||
+      typeof program.expectedOutput !== 'string' ||
+      !program.expectedOutput.trim() ||
+      !program.expectedOutput.endsWith('\n') ||
+      !/^io\.github\.libtmux(?:\.[\w$]+)+$/.test(program.mainClass) ||
+      !new RegExp(`^src/main/${port}/(?:[\\w]+/)*[\\w]+\\.${port === 'kotlin' ? 'kt' : port}$`).test(program.path)
+    ) {
       throw new Error(`Invalid JVM example metadata: ${program.id}`)
     }
     ids.add(program.id)
     const files = manifest.variants[program.variant]?.files
-    if (!Array.isArray(files) || files.length !== 4 || new Set(files.map((file) => file.path)).size !== 4 ||
-        !files.every((file) => Object.hasOwn(setupLanguages, file.path))) {
+    if (
+      !Array.isArray(files) ||
+      files.length !== 4 ||
+      new Set(files.map((file) => file.path)).size !== 4 ||
+      !files.every((file) => Object.hasOwn(setupLanguages, file.path))
+    ) {
       throw new Error(`Invalid JVM example setup: ${program.variant}`)
     }
-    const blocks: NonNullable<DocBlock['examples']> = [{
-      lang: 'console',
-      intro: `${program.description.replace(/\n/g, ' ')} Use JDK 25, Git, and tmux 3.2a through 3.7c on Linux, with /bin/cat and /bin/sh available. In an empty directory, fetch the documented library revision:`,
-      code: `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`,
-    }]
-    for (const file of files) blocks.push({
-      lang: setupLanguages[file.path],
-      intro: file.path === 'run.sh'
-        ? 'Save this launcher as run.sh. It creates and stops a private tmux server, including after program failure. A shutdown failure retains its socket directory and exits unsuccessfully.'
-        : `Save this consumer setup as ${file.path}:`,
-      sourceUrl: urlFor(file.sourceFile), code: codeFor(file.sourceFile),
-    })
-    blocks.push({
-      lang: port,
-      intro: `Save this complete program as ${program.path}. It opens an ordinary client for the launcher's server; closing the client releases its transport.`,
-      sourceUrl: urlFor(program.sourceFile), code: codeFor(program.sourceFile),
-    }, {
-      lang: 'console',
-      intro: 'Build the minimal consumer and run the saved program with the private fixture. An operation or cleanup error makes the command exit unsuccessfully:',
-      code: `$ ./libtmux-source/gradlew --project-dir . --console=plain --quiet \\\n    installDist -PexampleMain=${program.mainClass} && \\\n  sh run.sh build/install/api-example/bin/api-example\n`,
-    }, { lang: 'text', intro: 'Expected output:', code: program.expectedOutput })
+    const blocks: NonNullable<DocBlock['examples']> = [
+      {
+        lang: 'console',
+        intro: `${program.description.replace(/\n/g, ' ')} Use JDK 25, Git, and tmux 3.2a through 3.7c on Linux, with /bin/cat and /bin/sh available. In an empty directory, fetch the documented library revision:`,
+        code: `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`,
+      },
+    ]
+    for (const file of files)
+      blocks.push({
+        lang: setupLanguages[file.path],
+        intro:
+          file.path === 'run.sh'
+            ? 'Save this launcher as run.sh. It creates and stops a private tmux server, including after program failure. A shutdown failure retains its socket directory and exits unsuccessfully.'
+            : `Save this consumer setup as ${file.path}:`,
+        sourceUrl: urlFor(file.sourceFile),
+        code: codeFor(file.sourceFile),
+      })
+    blocks.push(
+      {
+        lang: port,
+        intro: `Save this complete program as ${program.path}. It opens an ordinary client for the launcher's server; closing the client releases its transport.`,
+        sourceUrl: urlFor(program.sourceFile),
+        code: codeFor(program.sourceFile),
+      },
+      {
+        lang: 'console',
+        intro:
+          'Build the minimal consumer and run the saved program with the private fixture. An operation or cleanup error makes the command exit unsuccessfully:',
+        code: `$ ./libtmux-source/gradlew --project-dir . --console=plain --quiet \\\n    installDist -PexampleMain=${program.mainClass} && \\\n  sh run.sh build/install/api-example/bin/api-example\n`,
+      },
+      { lang: 'text', intro: 'Expected output:', code: program.expectedOutput },
+    )
     const targets = new Set<string>()
     for (const target of program.targets) {
       if (targets.has(target)) throw new Error(`Duplicate JVM example target: ${target}`)
-      const matches = symbols.filter((symbol) => port === 'java' ? qualifiedNameOf(symbol) === target : symbol.id === target)
+      const matches = symbols.filter((symbol) =>
+        port === 'java' ? qualifiedNameOf(symbol) === target : symbol.id === target,
+      )
       if (matches.length !== 1) throw new Error(`JVM example target must resolve once: ${target}`)
       targets.add(target)
       const symbol = matches[0]
diff --git a/packages/api-model/src/languages/jvm.ts b/packages/api-model/src/languages/jvm.ts
index e51cf816e..bc8bd65ea 100644
--- a/packages/api-model/src/languages/jvm.ts
+++ b/packages/api-model/src/languages/jvm.ts
@@ -21,20 +21,31 @@ const visible = (node: Node) => {
 
 /** Public declarations only: method bodies and private containers never become API pages. */
 function declarations(node: Node, language: Language): Node[] {
-  const types = language === 'kotlin'
-    ? /^(class_declaration|object_declaration|companion_object|function_declaration|property_declaration|type_alias|secondary_constructor|enum_entry)$/
-    : /^(class_definition|trait_definition|object_definition|enum_definition|type_definition|function_definition|function_declaration|val_definition|var_definition|given_definition|extension_definition|export_declaration|simple_enum_case|full_enum_case)$/
-  return childrenOf(node).flatMap((child) => child.type === 'enum_case_definitions'
-    ? declarations(child, language) : types.test(child.type) ? [child] : [])
+  const types =
+    language === 'kotlin'
+      ? /^(class_declaration|object_declaration|companion_object|function_declaration|property_declaration|type_alias|secondary_constructor|enum_entry)$/
+      : /^(class_definition|trait_definition|object_definition|enum_definition|type_definition|function_definition|function_declaration|val_definition|var_definition|given_definition|extension_definition|export_declaration|simple_enum_case|full_enum_case)$/
+  return childrenOf(node).flatMap((child) =>
+    child.type === 'enum_case_definitions' ? declarations(child, language) : types.test(child.type) ? [child] : [],
+  )
 }
 
 function documentation(node: Node, language: Language, signature: Signature, comments: Node[], source: string) {
   // A grammar can attach a trailing comment to the preceding expression's
   // body. Source adjacency, rather than sibling ownership, binds the comment.
   const before = comments.findLast((comment) => comment.endIndex <= node.startIndex)
-  if (!before || node.startPosition.row > before.endPosition.row + 1 ||
-      source.slice(before.endIndex, node.startIndex).trim()) return undefined
-  const raw = before.text.slice(3, -2).split('\n').map((line) => line.replace(/^\s*\* ?/, '')).join('\n').trim()
+  if (
+    !before ||
+    node.startPosition.row > before.endPosition.row + 1 ||
+    source.slice(before.endIndex, node.startIndex).trim()
+  )
+    return undefined
+  const raw = before.text
+    .slice(3, -2)
+    .split('\n')
+    .map((line) => line.replace(/^\s*\* ?/, ''))
+    .join('\n')
+    .trim()
   // Keep native links intact; the inline tokenizer must distinguish them
   // from generic brackets inside code such as `Execution[F]`.
   const parsed = parseMarkdownDocFull(raw, language)
@@ -45,35 +56,52 @@ function documentation(node: Node, language: Language, signature: Signature, com
 }
 
 function parameters(node: Node, language: Language, firstGroupOnly = false): Param[] {
-  const groups = node.type === 'primary_constructor' ? [node] : childrenOf(node).filter((child) => language === 'kotlin'
-    ? ['function_value_parameters', 'class_parameters'].includes(child.type)
-    : ['parameters', 'class_parameters'].includes(child.type))
-  return (firstGroupOnly ? groups.slice(0, 1) : groups).flatMap((group) => childrenOf(group)
-    .filter((param) => /^(parameter|class_parameter)$/.test(param.type))
-    .map((param): Param => {
-      const name = field(param, 'name') ?? named(param, 'simple_identifier', 'identifier')
-      const type = field(param, 'type') ?? param.children.find((child, index, all) => all[index - 1]?.type === ':')
-      const value = field(param, 'default_value') ?? field(param, 'value') ??
-        param.children.find((child, index, all) => all[index - 1]?.type === '=') ??
-        (param.nextSibling?.type === '=' ? param.nextSibling.nextSibling : undefined)
-      if (!name || !type) throw new Error(`Unparsed ${language} parameter: ${param.text}`)
-      return {
-        name: name.text,
-        type: compact(type.text),
-        ...(value ? { default: compact(value.text) } : {}),
-        ...(/\bvararg\b/.test(param.text) ? { variadic: 'positional' as const } : {}),
-      }
-    }))
+  const groups =
+    node.type === 'primary_constructor'
+      ? [node]
+      : childrenOf(node).filter((child) =>
+          language === 'kotlin'
+            ? ['function_value_parameters', 'class_parameters'].includes(child.type)
+            : ['parameters', 'class_parameters'].includes(child.type),
+        )
+  return (firstGroupOnly ? groups.slice(0, 1) : groups).flatMap((group) =>
+    childrenOf(group)
+      .filter((param) => /^(parameter|class_parameter)$/.test(param.type))
+      .map((param): Param => {
+        const name = field(param, 'name') ?? named(param, 'simple_identifier', 'identifier')
+        const type = field(param, 'type') ?? param.children.find((child, index, all) => all[index - 1]?.type === ':')
+        const value =
+          field(param, 'default_value') ??
+          field(param, 'value') ??
+          param.children.find((child, index, all) => all[index - 1]?.type === '=') ??
+          (param.nextSibling?.type === '=' ? param.nextSibling.nextSibling : undefined)
+        if (!name || !type) throw new Error(`Unparsed ${language} parameter: ${param.text}`)
+        return {
+          name: name.text,
+          type: compact(type.text),
+          ...(value ? { default: compact(value.text) } : {}),
+          ...(/\bvararg\b/.test(param.text) ? { variadic: 'positional' as const } : {}),
+        }
+      }),
+  )
 }
 
 /** Bound names only: nested arguments such as the `_` in `F[_]` are not binders. */
 function typeParameters(node: Node, language: Language): string[] {
   const group = named(node, 'type_parameters')
-  return group ? childrenOf(group).flatMap((param) => {
-    const name = language === 'kotlin' ? named(param, 'type_identifier')
-      : param.type === 'identifier' ? param : /^(co|contra)variant_type_parameter$/.test(param.type) ? field(param, 'name') : undefined
-    return name ? [name.text] : []
-  }) : []
+  return group
+    ? childrenOf(group).flatMap((param) => {
+        const name =
+          language === 'kotlin'
+            ? named(param, 'type_identifier')
+            : param.type === 'identifier'
+              ? param
+              : /^(co|contra)variant_type_parameter$/.test(param.type)
+                ? field(param, 'name')
+                : undefined
+        return name ? [name.text] : []
+      })
+    : []
 }
 
 /** Extract handwritten declarations and generated extensions in one symbol table. */
@@ -95,7 +123,10 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
 
   const emit = (symbol: ApiSymbol) => {
     const previous = symbols.get(symbol.id)
-    if (!previous) { symbols.set(symbol.id, symbol); return }
+    if (!previous) {
+      symbols.set(symbol.id, symbol)
+      return
+    }
     const companion = previous.kind === 'module' || symbol.kind === 'module'
     if (companion) {
       // A Scala opaque type and its companion share the public name. Keep
@@ -144,50 +175,97 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
           // an internal implementation. A private subtree cannot contribute
           // declarations. Every error in public syntax still stops extraction.
           if (!visible(node)) return
-          if (node.isError || node.isMissing) throw new Error(`${file}:${node.startPosition.row + 1}: unparsed public ${port} syntax: ${node.text}`)
-          for (const child of childrenOf(node)) if (child.hasError || child.isError || child.isMissing) checkSyntax(child)
+          if (node.isError || node.isMissing)
+            throw new Error(`${file}:${node.startPosition.row + 1}: unparsed public ${port} syntax: ${node.text}`)
+          for (const child of childrenOf(node))
+            if (child.hasError || child.isError || child.isMissing) checkSyntax(child)
         }
         checkSyntax(root)
 
-        const walk = (body: Node, parent?: string, receiver?: string, extensionHeader?: string,
-          extensionTypes: string[] = [], extensionReceiver?: Param): void => {
+        const walk = (
+          body: Node,
+          parent?: string,
+          receiver?: string,
+          extensionHeader?: string,
+          extensionTypes: string[] = [],
+          extensionReceiver?: Param,
+        ): void => {
           for (const node of declarations(body, port)) {
             if (!visible(node)) continue
             if (node.type === 'export_declaration') {
               if (!parent || !named(node, 'namespace_wildcard')) {
                 throw new Error(`Unsupported Scala export: ${node.text}`)
               }
-              const target = childrenOf(node).filter((child) => child.type === 'identifier').map((child) => child.text).join('.')
+              const target = childrenOf(node)
+                .filter((child) => child.type === 'identifier')
+                .map((child) => child.text)
+                .join('.')
               exports.push({ parent, target })
               continue
             }
             if (node.type === 'extension_definition') {
               const params = parameters(node, port, true)
-              if (params.length !== 1 || !params[0].type) throw new Error(`Unsupported extension receiver: ${node.text}`)
-              const end = Math.max(...childrenOf(node).filter((child) => ['parameters', 'type_parameters'].includes(child.type)).map((child) => child.endIndex))
+              if (params.length !== 1 || !params[0].type)
+                throw new Error(`Unsupported extension receiver: ${node.text}`)
+              const end = Math.max(
+                ...childrenOf(node)
+                  .filter((child) => ['parameters', 'type_parameters'].includes(child.type))
+                  .map((child) => child.endIndex),
+              )
               const header = node.text.slice(0, end - node.startIndex).trim()
               walk(node, parent, receiverId(params[0].type), header, typeParameters(node, port), params[0])
               continue
             }
             const variable = named(node, 'variable_declaration')
-            const nameNode = field(node, 'name') ?? (variable && named(variable, 'simple_identifier')) ?? named(node, 'simple_identifier', 'type_identifier', 'identifier')
-            const name = nameNode?.text ?? (node.type === 'companion_object' ? 'Companion'
-              : node.type === 'given_definition' ? `given_${field(node, 'return_type')?.text.replace(/\W+/g, '_').replace(/_$/, '')}` : undefined)
-            if (!name) throw new Error(`Unnamed public ${port} declaration in ${file}:${node.startPosition.row + 1}: ${node.type}`)
-            const container = /^(class_declaration|object_declaration|companion_object|class_definition|trait_definition|object_definition|enum_definition)$/.test(node.type)
-            const kind: SymbolKind = /^(object_|companion_)/.test(node.type) ? 'module'
-              : /enum/.test(node.type) ? (container ? 'enum' : 'constant')
-              : /trait/.test(node.type) ? 'trait'
-              : container ? (node.children.some((child) => child?.type === 'interface') ? 'interface' : 'class')
-              : /type_(alias|definition)/.test(node.type) ? 'typealias'
-              : /function/.test(node.type) ? (parent || receiver ? 'method' : 'function')
-              : /given/.test(node.type) ? 'constant' : 'property'
+            const nameNode =
+              field(node, 'name') ??
+              (variable && named(variable, 'simple_identifier')) ??
+              named(node, 'simple_identifier', 'type_identifier', 'identifier')
+            const name =
+              nameNode?.text ??
+              (node.type === 'companion_object'
+                ? 'Companion'
+                : node.type === 'given_definition'
+                  ? `given_${field(node, 'return_type')?.text.replace(/\W+/g, '_').replace(/_$/, '')}`
+                  : undefined)
+            if (!name)
+              throw new Error(
+                `Unnamed public ${port} declaration in ${file}:${node.startPosition.row + 1}: ${node.type}`,
+              )
+            const container =
+              /^(class_declaration|object_declaration|companion_object|class_definition|trait_definition|object_definition|enum_definition)$/.test(
+                node.type,
+              )
+            const kind: SymbolKind = /^(object_|companion_)/.test(node.type)
+              ? 'module'
+              : /enum/.test(node.type)
+                ? container
+                  ? 'enum'
+                  : 'constant'
+                : /trait/.test(node.type)
+                  ? 'trait'
+                  : container
+                    ? node.children.some((child) => child?.type === 'interface')
+                      ? 'interface'
+                      : 'class'
+                    : /type_(alias|definition)/.test(node.type)
+                      ? 'typealias'
+                      : /function/.test(node.type)
+                        ? parent || receiver
+                          ? 'method'
+                          : 'function'
+                        : /given/.test(node.type)
+                          ? 'constant'
+                          : 'property'
             let owner = parent
             let ownReceiver = receiver
             let receiverParam = extensionReceiver
             // Kotlin extensions put their receiver before the member name.
             if (port === 'kotlin' && !container && nameNode) {
-              const receiverNode = childrenOf(node).find((child) => /^(user_type|nullable_type|receiver_type)$/.test(child.type) && child.endIndex < nameNode.startIndex)
+              const receiverNode = childrenOf(node).find(
+                (child) =>
+                  /^(user_type|nullable_type|receiver_type)$/.test(child.type) && child.endIndex < nameNode.startIndex,
+              )
               if (receiverNode) {
                 ownReceiver = receiverId(receiverNode.text)
                 receiverParam = { name: 'this', type: compact(receiverNode.text) }
@@ -195,23 +273,37 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
             }
             if (ownReceiver) owner = ownReceiver
             const id = `${owner ?? namespace}.${name}`
-            const block = field(node, 'body') ?? named(node, 'class_body', 'enum_class_body', 'function_body', 'template_body', 'enum_body', 'getter')
+            const block =
+              field(node, 'body') ??
+              named(node, 'class_body', 'enum_class_body', 'function_body', 'template_body', 'enum_body', 'getter')
             const equal = node.children.find((child) => child?.type === '=')
-            const end = kind === 'typealias' ? node.endIndex : Math.min(block?.startIndex ?? node.endIndex, equal?.startIndex ?? node.endIndex)
+            const end =
+              kind === 'typealias'
+                ? node.endIndex
+                : Math.min(block?.startIndex ?? node.endIndex, equal?.startIndex ?? node.endIndex)
             let raw = source.slice(node.startIndex, end).trim()
             const constructor = named(node, 'primary_constructor')
             const scalaConstructorAccess = port === 'scala' && container ? named(node, 'access_modifier') : undefined
-            const privateConstructor = constructor && !visible(constructor) ||
-              scalaConstructorAccess && /\b(private|protected)\b/.test(scalaConstructorAccess.text)
+            const privateConstructor =
+              (constructor && !visible(constructor)) ||
+              (scalaConstructorAccess && /\b(private|protected)\b/.test(scalaConstructorAccess.text))
             if (constructor && !visible(constructor)) {
-              raw = (source.slice(node.startIndex, constructor.startIndex) + source.slice(constructor.endIndex, end)).trim()
+              raw = (
+                source.slice(node.startIndex, constructor.startIndex) + source.slice(constructor.endIndex, end)
+              ).trim()
             }
             if (scalaConstructorAccess && privateConstructor) {
-              const last = childrenOf(node).filter((child) => child.type === 'class_parameters').at(-1)
-              raw = (source.slice(node.startIndex, scalaConstructorAccess.startIndex) +
-                source.slice(last?.endIndex ?? scalaConstructorAccess.endIndex, end)).trim()
+              const last = childrenOf(node)
+                .filter((child) => child.type === 'class_parameters')
+                .at(-1)
+              raw = (
+                source.slice(node.startIndex, scalaConstructorAccess.startIndex) +
+                source.slice(last?.endIndex ?? scalaConstructorAccess.endIndex, end)
+              ).trim()
             }
-            const returns = field(node, 'return_type') ?? (variable && variable.children.find((child, i, all) => all[i - 1]?.type === ':')) ??
+            const returns =
+              field(node, 'return_type') ??
+              (variable && variable.children.find((child, i, all) => all[i - 1]?.type === ':')) ??
               node.children.find((child, i, all) => all[i - 1]?.type === ':')
             const signature: Signature = {
               raw: extensionHeader ? `${extensionHeader}\n${raw}` : raw,
@@ -224,10 +316,15 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
             // A private constructor is not a public callable signature.
             if (privateConstructor) signature.params = []
             const symbol: ApiSymbol = {
-              id, name, kind: ownReceiver && kind === 'function' ? 'method' : kind,
-              parent: owner, signatures: [signature], imports: Object.fromEntries(imports),
+              id,
+              name,
+              kind: ownReceiver && kind === 'function' ? 'method' : kind,
+              parent: owner,
+              signatures: [signature],
+              imports: Object.fromEntries(imports),
               modifiers: /\bsuspend\b/.test(named(node, 'modifiers')?.text ?? '') ? ['async'] : [],
-              doc: documentation(node, port, signature, comments, source), source: { file, line: node.startPosition.row + 1 },
+              doc: documentation(node, port, signature, comments, source),
+              source: { file, line: node.startPosition.row + 1 },
             }
             if (ownReceiver) extensions.push(symbol)
             else emit(symbol)
@@ -239,10 +336,16 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
                     const propName = field(prop, 'name')?.text
                     const propType = field(prop, 'type')?.text
                     if (!propName || !propType) throw new Error(`Unparsed public Scala property: ${prop.text}`)
-                    emit({ id: `${id}.${propName}`, name: propName, kind: 'property', parent: id,
-                      imports: Object.fromEntries(imports), modifiers: [],
+                    emit({
+                      id: `${id}.${propName}`,
+                      name: propName,
+                      kind: 'property',
+                      parent: id,
+                      imports: Object.fromEntries(imports),
+                      modifiers: [],
                       signatures: [{ raw: prop.text, params: [], returns: propType }],
-                      source: { file, line: prop.startPosition.row + 1 } })
+                      source: { file, line: prop.startPosition.row + 1 },
+                    })
                   }
                 }
               }
@@ -251,9 +354,15 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
                   if (!visible(prop) || !named(prop, 'binding_pattern_kind')) continue
                   const propName = named(prop, 'simple_identifier')?.text
                   if (!propName) throw new Error(`Unnamed constructor property: ${prop.text}`)
-                  emit({ id: `${id}.${propName}`, name: propName, kind: 'property', parent: id,
-                    modifiers: [], signatures: [{ raw: prop.text, params: [] }],
-                    source: { file, line: prop.startPosition.row + 1 } })
+                  emit({
+                    id: `${id}.${propName}`,
+                    name: propName,
+                    kind: 'property',
+                    parent: id,
+                    modifiers: [],
+                    signatures: [{ raw: prop.text, params: [] }],
+                    source: { file, line: prop.startPosition.row + 1 },
+                  })
                 }
               }
               if (block) walk(block, id)
@@ -261,14 +370,20 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
           }
         }
         walk(root)
-      } finally { tree.delete() }
+      } finally {
+        tree.delete()
+      }
     }
     for (const entry of exports) {
       const members = [...symbols.values()].filter((symbol) => symbol.parent === entry.target)
       if (!members.length) throw new Error(`Scala export target has no public members: ${entry.target}`)
       for (const member of members) {
-        emit({ ...structuredClone(member), id: `${entry.parent}.${member.name}`,
-          parent: entry.parent, exportedFrom: member.id })
+        emit({
+          ...structuredClone(member),
+          id: `${entry.parent}.${member.name}`,
+          parent: entry.parent,
+          exportedFrom: member.id,
+        })
       }
     }
     for (const extension of extensions) {
@@ -282,5 +397,7 @@ export async function extractJvm(port: Language, roots: string[], revision?: str
       emit(extension)
     }
     return { port, revision, extractor: `@libtmux/api-model (${port} syntax)`, symbols: [...symbols.values()] }
-  } finally { parser.delete() }
+  } finally {
+    parser.delete()
+  }
 }
diff --git a/packages/api-model/src/languages/lua-examples.ts b/packages/api-model/src/languages/lua-examples.ts
index 894dfaea5..417ba48cf 100644
--- a/packages/api-model/src/languages/lua-examples.ts
+++ b/packages/api-model/src/languages/lua-examples.ts
@@ -17,10 +17,11 @@ export function attachCompleteLuaExamples(
   const require = (condition: unknown, message: string): void => {
     if (!condition) throw new Error(`Invalid complete Lua examples: ${message}`)
   }
-  require(source.repository === 'libtmux/libtmux-lua' && /^[a-f0-9]{40}$/.test(source.revision),
-    'source must name the Lua repository and a full revision')
-  require(manifest?.schema === 1 && Array.isArray(manifest.examples) && manifest.examples.length,
-    'unsupported or empty manifest')
+  require(source.repository === 'libtmux/libtmux-lua' &&
+    /^[a-f0-9]{40}$/.test(source.revision), 'source must name the Lua repository and a full revision')
+  require(manifest?.schema === 1 &&
+    Array.isArray(manifest.examples) &&
+    manifest.examples.length, 'unsupported or empty manifest')
   require(/^5\.[1-5]\.\d+$/.test(manifest.setup?.lua ?? '') &&
     /^\d+\.\d+\.\d+-\d+$/.test(manifest.setup?.luv ?? ''), 'runtime versions must be pinned')
   require(manifest.setup.launcher === 'examples/api/run.sh', 'unexpected launcher path')
@@ -28,8 +29,10 @@ export function attachCompleteLuaExamples(
     const matches = files?.filter((file) => file.path === path) ?? []
     require(matches.length === 1, `source file must resolve once: ${path}`)
     const code = matches[0].content
-    require(typeof code === 'string' && code.trim() && code.endsWith('\n') && !code.includes('\r'),
-      `source file must retain complete LF bytes: ${path}`)
+    require(typeof code === 'string' &&
+      code.trim() &&
+      code.endsWith('\n') &&
+      !code.includes('\r'), `source file must retain complete LF bytes: ${path}`)
     return code
   }
   const launcher = read(manifest.setup.launcher)
@@ -41,8 +44,9 @@ export function attachCompleteLuaExamples(
     ids.add(example.id)
     require(example.file === `examples/api/${example.id}.lua`, 'unexpected program path')
     require(typeof example.description === 'string' && example.description.trim(), 'task description is missing')
-    require(typeof example.stdout === 'string' && example.stdout.trim() && example.stdout.endsWith('\n'),
-      'expected output is missing')
+    require(typeof example.stdout === 'string' &&
+      example.stdout.trim() &&
+      example.stdout.endsWith('\n'), 'expected output is missing')
     require(Array.isArray(example.symbols) && example.symbols.length, 'API targets are missing')
     const code = read(example.file)
     const name = `${example.id}.lua`
@@ -50,7 +54,8 @@ export function attachCompleteLuaExamples(
       {
         lang: 'console',
         intro: `${example.description} Use Lua ${manifest.setup.lua}, LuaRocks, Git, tmux 3.2a or newer, a C compiler, and CMake on Linux. In a new directory, install the documented source and standalone runtime dependency:`,
-        code: `$ git clone https://github.com/${source.repository}.git libtmux-source &&\n` +
+        code:
+          `$ git clone https://github.com/${source.repository}.git libtmux-source &&\n` +
           `  git -C libtmux-source checkout ${source.revision} &&\n` +
           `  luarocks --tree ./rocks install luv ${manifest.setup.luv} &&\n` +
           '  (cd libtmux-source &&\n' +
@@ -59,7 +64,8 @@ export function attachCompleteLuaExamples(
       },
       {
         lang: 'sh',
-        intro: 'Save this complete launcher as run.sh. It starts a private tmux daemon and cleans up after success or failure. A failed daemon shutdown reports and retains its socket directory.',
+        intro:
+          'Save this complete launcher as run.sh. It starts a private tmux daemon and cleans up after success or failure. A failed daemon shutdown reports and retains its socket directory.',
         sourceUrl: url(manifest.setup.launcher),
         code: launcher,
       },
diff --git a/packages/api-model/src/languages/lua.ts b/packages/api-model/src/languages/lua.ts
index de9129d5d..047e4147a 100644
--- a/packages/api-model/src/languages/lua.ts
+++ b/packages/api-model/src/languages/lua.ts
@@ -67,8 +67,7 @@ function source(node: LuaNode, artifact: LuaArtifact) {
   }
 }
 
-const argName = (argument?: LuaArg) =>
-  typeof argument?.name === 'string' ? argument.name : argument?.name?.view
+const argName = (argument?: LuaArg) => (typeof argument?.name === 'string' ? argument.name : argument?.name?.view)
 
 /** LuaLS prints an optional class as `(libtmux.PaneOptions)?`; the reference writes `libtmux.PaneOptions?`. */
 const typeView = (view?: string) => view?.replace(/\(([^()]*)\)\?/g, '$1?')
@@ -103,7 +102,10 @@ function signature(fn: LuaNode, receiver: boolean, raw: string | undefined): Sig
       ...(argument.rawdesc || argument.desc ? { doc: argument.rawdesc ?? argument.desc } : {}),
     }
   })
-  const returns = fn.returns?.map((entry) => typeView(entry.view)).filter(Boolean).join(', ')
+  const returns = fn.returns
+    ?.map((entry) => typeView(entry.view))
+    .filter(Boolean)
+    .join(', ')
   const written = `fun(${args.map((a) => `${argName(a)}: ${a.view}`).join(', ')})${returns ? `:${returns}` : ''}`
   return {
     raw: typeView(raw ?? fn.view ?? written),
@@ -201,14 +203,16 @@ export function extractLua(input: unknown, expectedRevision?: string): ApiModel
     repo: artifact.source.repository,
     revision: artifact.source.revision,
     extractor: `@libtmux/api-model@0.0.1 (${artifact.exporter.name} v${artifact.exporter.version}; LuaLS ${artifact.exporter.luals})`,
-    sources: [{
-      product: 'core',
-      package: artifact.package.name,
-      version: artifact.package.version,
-      repo: artifact.source.repository,
-      revision: artifact.source.revision,
-      extractedRevision: artifact.source.revision,
-    }],
+    sources: [
+      {
+        product: 'core',
+        package: artifact.package.name,
+        version: artifact.package.version,
+        repo: artifact.source.repository,
+        revision: artifact.source.revision,
+        extractedRevision: artifact.source.revision,
+      },
+    ],
     symbols,
   }
 }
diff --git a/packages/api-model/src/languages/powershell.ts b/packages/api-model/src/languages/powershell.ts
index c393edd6b..bf2af031f 100644
--- a/packages/api-model/src/languages/powershell.ts
+++ b/packages/api-model/src/languages/powershell.ts
@@ -1,7 +1,11 @@
 import { posix } from 'node:path'
 import type { ApiModel, ApiProduct, ApiSymbol, Param, Signature } from '../model.ts'
 
-interface Source { file: string; line: number; endLine?: number }
+interface Source {
+  file: string
+  line: number
+  endLine?: number
+}
 interface NativeParameter {
   name: string
   type: string
@@ -17,7 +21,11 @@ interface NativeParameter {
   declaration: { source: Source; declaration: string; default: string | null } | null
   attributes: NonNullable<Param['binding']>['attributes']
 }
-interface ParameterSet { name: string; isDefault: boolean; parameters: NativeParameter[] }
+interface ParameterSet {
+  name: string
+  isDefault: boolean
+  parameters: NativeParameter[]
+}
 interface NativeCommand extends Omit<NonNullable<ApiSymbol['command']>, 'defaultParameterSet'> {
   defaultParameterSet: string | null
   id: string
@@ -52,12 +60,17 @@ interface PowerShellArtifact {
 
 function assertArtifact(input: unknown, revision?: string): PowerShellArtifact {
   const artifact = input as PowerShellArtifact
-  if (artifact?.schema !== 1 || artifact.port !== 'powershell' ||
-    !Array.isArray(artifact.modules) || !Array.isArray(artifact.commands) ||
-    !/^[a-f0-9]{40}$/.test(artifact.source?.revision ?? '')) {
+  if (
+    artifact?.schema !== 1 ||
+    artifact.port !== 'powershell' ||
+    !Array.isArray(artifact.modules) ||
+    !Array.isArray(artifact.commands) ||
+    !/^[a-f0-9]{40}$/.test(artifact.source?.revision ?? '')
+  ) {
     throw new Error('PowerShell documentation artifact has an unsupported schema or source identity')
   }
-  if (revision && artifact.source.revision !== revision) throw new Error('PowerShell artifact source revision differs from the selected checkout')
+  if (revision && artifact.source.revision !== revision)
+    throw new Error('PowerShell artifact source revision differs from the selected checkout')
   const ids = new Set<string>()
   const modules = new Map(artifact.modules.map((entry) => [entry.name, entry]))
   for (const command of artifact.commands) {
@@ -65,7 +78,10 @@ function assertArtifact(input: unknown, revision?: string): PowerShellArtifact {
       throw new Error(`PowerShell command has a duplicate or unknown identity: ${command.id}`)
     }
     ids.add(command.id)
-    if (!command.parameterSets.length || new Set(command.parameterSets.map((set) => set.name)).size !== command.parameterSets.length) {
+    if (
+      !command.parameterSets.length ||
+      new Set(command.parameterSets.map((set) => set.name)).size !== command.parameterSets.length
+    ) {
       throw new Error(`PowerShell command lost distinct parameter sets: ${command.id}`)
     }
     for (const set of command.parameterSets) {
@@ -73,17 +89,28 @@ function assertArtifact(input: unknown, revision?: string): PowerShellArtifact {
         throw new Error(`PowerShell parameter set repeats a parameter: ${command.id}/${set.name}`)
       }
       for (const parameter of set.parameters) {
-        if (!parameter.type || typeof parameter.pipeline?.byValue !== 'boolean' || typeof parameter.pipeline?.byPropertyName !== 'boolean') {
-          throw new Error(`PowerShell parameter lost native binding metadata: ${command.id}/${set.name}/${parameter.name}`)
+        if (
+          !parameter.type ||
+          typeof parameter.pipeline?.byValue !== 'boolean' ||
+          typeof parameter.pipeline?.byPropertyName !== 'boolean'
+        ) {
+          throw new Error(
+            `PowerShell parameter lost native binding metadata: ${command.id}/${set.name}/${parameter.name}`,
+          )
         }
       }
     }
-    if (command.examples.some((example) => !example.code.trim())) throw new Error(`PowerShell command lost example code: ${command.id}`)
+    if (command.examples.some((example) => !example.code.trim()))
+      throw new Error(`PowerShell command lost example code: ${command.id}`)
   }
   for (const entry of artifact.modules) {
     const declared = [...entry.commands].sort()
-    const actual = artifact.commands.filter((command) => command.module === entry.name).map((command) => command.name).sort()
-    if (JSON.stringify(declared) !== JSON.stringify(actual)) throw new Error(`PowerShell module inventory differs: ${entry.name}`)
+    const actual = artifact.commands
+      .filter((command) => command.module === entry.name)
+      .map((command) => command.name)
+      .sort()
+    if (JSON.stringify(declared) !== JSON.stringify(actual))
+      throw new Error(`PowerShell module inventory differs: ${entry.name}`)
   }
   return artifact
 }
@@ -95,7 +122,10 @@ function splitTypes(value: string): string[] {
   for (let index = 0; index < value.length; index++) {
     if (value[index] === '[') depth++
     else if (value[index] === ']') depth--
-    else if (value[index] === ',' && depth === 0) { parts.push(value.slice(start, index)); start = index + 1 }
+    else if (value[index] === ',' && depth === 0) {
+      parts.push(value.slice(start, index))
+      start = index + 1
+    }
   }
   parts.push(value.slice(start))
   return parts
@@ -135,29 +165,43 @@ function parameter(entry: NativeParameter, source: (location: Source) => ApiSymb
   return {
     name: entry.name,
     type: powerShellType(entry.type),
-    doc: entry.description.trim() ? entry.description : entry.common ? commonParameterDescriptions[entry.name] : undefined,
+    doc: entry.description.trim()
+      ? entry.description
+      : entry.common
+        ? commonParameterDescriptions[entry.name]
+        : undefined,
     default: entry.documentedDefault && entry.documentedDefault !== 'None' ? entry.documentedDefault : undefined,
     keywordOnly: entry.position === null,
     binding: {
-      mandatory: entry.mandatory, position: entry.position ?? undefined,
-      switch: entry.switch, common: entry.common, dynamic: entry.dynamic,
-      aliases: entry.aliases, pipeline: entry.pipeline,
-      documentedDefault: entry.documentedDefault ?? undefined, nativeType: entry.type,
+      mandatory: entry.mandatory,
+      position: entry.position ?? undefined,
+      switch: entry.switch,
+      common: entry.common,
+      dynamic: entry.dynamic,
+      aliases: entry.aliases,
+      pipeline: entry.pipeline,
+      documentedDefault: entry.documentedDefault ?? undefined,
+      nativeType: entry.type,
       attributes: entry.attributes,
-      declaration: entry.declaration ? {
-        text: entry.declaration.declaration, initializer: entry.declaration.default ?? undefined,
-        source: source(entry.declaration.source),
-      } : undefined,
+      declaration: entry.declaration
+        ? {
+            text: entry.declaration.declaration,
+            initializer: entry.declaration.default ?? undefined,
+            source: source(entry.declaration.source),
+          }
+        : undefined,
     },
   }
 }
 
 function syntax(command: NativeCommand, set: ParameterSet): string {
-  const parameters = set.parameters.filter((entry) => !entry.common).map((entry) => {
-    const name = entry.position === null ? `-${entry.name}` : `[-${entry.name}]`
-    const value = entry.switch ? name : `${name} <${powerShellType(entry.type)}>`
-    return entry.mandatory ? value : `[${value}]`
-  })
+  const parameters = set.parameters
+    .filter((entry) => !entry.common)
+    .map((entry) => {
+      const name = entry.position === null ? `-${entry.name}` : `[-${entry.name}]`
+      const value = entry.switch ? name : `${name} <${powerShellType(entry.type)}>`
+      return entry.mandatory ? value : `[${value}]`
+    })
   if (set.parameters.some((entry) => entry.common)) parameters.push('[<CommonParameters>]')
   return `${command.name} ${parameters.join(' ')}`
 }
@@ -166,56 +210,100 @@ function syntax(command: NativeCommand, set: ParameterSet): string {
 export function extractPowerShell(input: unknown, expectedRevision?: string): ApiModel {
   const artifact = assertArtifact(input, expectedRevision)
   const source = (location: Source): ApiSymbol['source'] => ({
-    file: location.file, line: location.line, repo: artifact.source.repository,
-    revision: artifact.source.revision, extractedRevision: artifact.source.revision,
+    file: location.file,
+    line: location.line,
+    repo: artifact.source.repository,
+    revision: artifact.source.revision,
+    extractedRevision: artifact.source.revision,
   })
   const symbols: ApiSymbol[] = artifact.modules.map((entry) => ({
-    id: entry.name, publicId: entry.name, name: entry.name, kind: 'module', modifiers: [],
-    signatures: [], product: entry.product, package: entry.name, apiScope: 'exported',
-    source: source(entry.source), doc: { summary: entry.description },
+    id: entry.name,
+    publicId: entry.name,
+    name: entry.name,
+    kind: 'module',
+    modifiers: [],
+    signatures: [],
+    product: entry.product,
+    package: entry.name,
+    apiScope: 'exported',
+    source: source(entry.source),
+    doc: { summary: entry.description },
   }))
   for (const entry of artifact.commands) {
-    const href = (target: string) => /^(?:https?:|#)/.test(target) ? target
-      : `https://github.com/${artifact.source.repository}/blob/${artifact.source.revision}/${posix.normalize(posix.join(posix.dirname(entry.help.file), target))}`
-    const prose = (text: string) => text.replace(/\[([^\]\n]+)\]\(([^\s)]+)\)/g,
-      (_match, label: string, target: string) => `[${label}](${href(target)})`)
+    const href = (target: string) =>
+      /^(?:https?:|#)/.test(target)
+        ? target
+        : `https://github.com/${artifact.source.repository}/blob/${artifact.source.revision}/${posix.normalize(posix.join(posix.dirname(entry.help.file), target))}`
+    const prose = (text: string) =>
+      text.replace(
+        /\[([^\]\n]+)\]\(([^\s)]+)\)/g,
+        (_match, label: string, target: string) => `[${label}](${href(target)})`,
+      )
     const signatures: Signature[] = entry.parameterSets.map((set) => ({
-      identity: `${entry.id}/${set.name}`, label: set.name, isDefault: set.isDefault,
-      raw: syntax(entry, set), params: set.parameters.map((item) => parameter({ ...item, description: prose(item.description) }, source)),
+      identity: `${entry.id}/${set.name}`,
+      label: set.name,
+      isDefault: set.isDefault,
+      raw: syntax(entry, set),
+      params: set.parameters.map((item) => parameter({ ...item, description: prose(item.description) }, source)),
       returns: entry.outputTypes.map(powerShellType).join(' | ') || undefined,
-      returnsDoc: entry.documentedOutputs.map((item) => `\`${powerShellType(item.type)}\`${item.description ? `: ${item.description}` : ''}`).join('\n\n') || undefined,
+      returnsDoc:
+        entry.documentedOutputs
+          .map((item) => `\`${powerShellType(item.type)}\`${item.description ? `: ${item.description}` : ''}`)
+          .join('\n\n') || undefined,
       source: source(entry.source),
     }))
     symbols.push({
-      id: entry.id, publicId: entry.id, name: entry.name, kind: 'function', modifiers: [],
-      parent: entry.module, namespace: entry.module, signatures,
-      product: entry.product, package: entry.module, apiScope: 'exported', source: source(entry.source),
+      id: entry.id,
+      publicId: entry.id,
+      name: entry.name,
+      kind: 'function',
+      modifiers: [],
+      parent: entry.module,
+      namespace: entry.module,
+      signatures,
+      product: entry.product,
+      package: entry.module,
+      apiScope: 'exported',
+      source: source(entry.source),
       doc: {
         summary: prose(entry.synopsis),
         body: prose([entry.description, entry.notes ? `### Notes\n\n${entry.notes}` : ''].filter(Boolean).join('\n\n')),
         examples: entry.examples.map((example) => ({
-          lang: 'powershell', code: example.code,
+          lang: 'powershell',
+          code: example.code,
           intro: prose([example.title, example.introduction].filter(Boolean).join('\n\n')),
           outro: prose(example.remarks) || undefined,
           sourceUrl: `https://github.com/${artifact.source.repository}/blob/${artifact.source.revision}/${entry.help.file}`,
         })),
       },
       command: {
-        kind: entry.kind, aliases: entry.aliases, defaultParameterSet: entry.defaultParameterSet ?? undefined,
-        supportsShouldProcess: entry.supportsShouldProcess, supportsPaging: entry.supportsPaging,
-        supportsTransactions: entry.supportsTransactions, confirmImpact: entry.confirmImpact,
-        positionalBinding: entry.positionalBinding, inputTypes: entry.inputTypes.map((item) => ({ ...item, type: powerShellType(item.type) })),
-        outputTypes: entry.outputTypes.map(powerShellType), relatedLinks: entry.relatedLinks.map((link) => ({ ...link, href: link.href ? href(link.href) : '' })),
+        kind: entry.kind,
+        aliases: entry.aliases,
+        defaultParameterSet: entry.defaultParameterSet ?? undefined,
+        supportsShouldProcess: entry.supportsShouldProcess,
+        supportsPaging: entry.supportsPaging,
+        supportsTransactions: entry.supportsTransactions,
+        confirmImpact: entry.confirmImpact,
+        positionalBinding: entry.positionalBinding,
+        inputTypes: entry.inputTypes.map((item) => ({ ...item, type: powerShellType(item.type) })),
+        outputTypes: entry.outputTypes.map(powerShellType),
+        relatedLinks: entry.relatedLinks.map((link) => ({ ...link, href: link.href ? href(link.href) : '' })),
       },
     })
   }
   return {
-    port: 'powershell', repo: artifact.source.repository, revision: artifact.source.revision,
+    port: 'powershell',
+    repo: artifact.source.repository,
+    revision: artifact.source.revision,
     extractor: `@libtmux/api-model@0.0.1 (${artifact.exporter.name} v${artifact.exporter.version})`,
     nativeProvenance: { files: artifact.source.files, exporter: artifact.exporter },
     sources: artifact.modules.map((entry) => ({
-      product: entry.product, package: entry.name, version: entry.version,
-      repo: artifact.source.repository, revision: artifact.source.revision, extractedRevision: artifact.source.revision,
+      product: entry.product,
+      package: entry.name,
+      version: entry.version,
+      repo: artifact.source.repository,
+      revision: artifact.source.revision,
+      extractedRevision: artifact.source.revision,
     })),
     symbols,
   }
diff --git a/packages/api-model/src/languages/python.ts b/packages/api-model/src/languages/python.ts
index 7d7a6bcc2..02077e65b 100644
--- a/packages/api-model/src/languages/python.ts
+++ b/packages/api-model/src/languages/python.ts
@@ -73,9 +73,7 @@ function paramsOf(node: Node): Param[] {
       continue
     }
     const variadic =
-      p.type === 'list_splat_pattern' ? 'positional'
-      : p.type === 'dictionary_splat_pattern' ? 'keyword'
-      : undefined
+      p.type === 'list_splat_pattern' ? 'positional' : p.type === 'dictionary_splat_pattern' ? 'keyword' : undefined
     if (variadic === 'positional') keywordOnly = true
 
     const name = p.childForFieldName('name') ?? p.namedChild(0) ?? p
@@ -183,9 +181,7 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
     const decorators = decorated
       ? child.namedChildren.filter((n) => n?.type === 'decorator').map((n) => decoratorName(n!))
       : []
-    const modifiers = decorators
-      .map((d) => DECORATOR_MODIFIER[d])
-      .filter((m): m is Modifier => Boolean(m))
+    const modifiers = decorators.map((d) => DECORATOR_MODIFIER[d]).filter((m): m is Modifier => Boolean(m))
 
     if (def.type === 'class_definition') {
       const name = def.childForFieldName('name')?.text ?? '?'
@@ -220,8 +216,7 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
       const raw = docstringOf(def.childForFieldName('body'))
       const parsed = raw ? parsePythonDoc(raw) : undefined
       const sig = parsed ? applyDoc(signatureOf(def), parsed) : signatureOf(def)
-      const kind: SymbolKind =
-        decorators.includes('property') ? 'property' : parent ? 'method' : 'function'
+      const kind: SymbolKind = decorators.includes('property') ? 'property' : parent ? 'method' : 'function'
       const isAsync = def.children.some((c) => c?.type === 'async' || c?.text === 'async')
       emit(ctx, {
         id,
@@ -283,11 +278,7 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
 }
 
 /** Extract one Python file. `module` is its dotted name, e.g. `libtmux.pane`. */
-export async function extractPython(
-  file: string,
-  module: string,
-  options: ExtractOptions = {},
-): Promise<ApiSymbol[]> {
+export async function extractPython(file: string, module: string, options: ExtractOptions = {}): Promise<ApiSymbol[]> {
   const parser = await parserFor('python')
   const tree = parser.parse(readFileSync(file, 'utf8'))
   if (!tree) return []
diff --git a/packages/api-model/src/languages/ruby-examples.ts b/packages/api-model/src/languages/ruby-examples.ts
index bdc31e64b..c7e1f61cc 100644
--- a/packages/api-model/src/languages/ruby-examples.ts
+++ b/packages/api-model/src/languages/ruby-examples.ts
@@ -36,12 +36,19 @@ export function attachCompleteRubyExamples(
   const targets = new Set<string>()
   for (const program of selected) {
     const api = program.api
-    if (!/^examples\/(?:[\w-]+\/)*[\w-]+\.rb$/.test(program.path) ||
-        !/^libtmux(?:-[a-z]+)*$/.test(program.gem) ||
-        !api || !Array.isArray(api.symbols) || !api.symbols.length ||
-        !api.symbols.every((id) => typeof id === 'string' && id.length && !/\s/.test(id)) ||
-        typeof api.description !== 'string' || !api.description.trim() ||
-        typeof api.output !== 'string' || !api.output.trim() || !api.output.endsWith('\n')) {
+    if (
+      !/^examples\/(?:[\w-]+\/)*[\w-]+\.rb$/.test(program.path) ||
+      !/^libtmux(?:-[a-z]+)*$/.test(program.gem) ||
+      !api ||
+      !Array.isArray(api.symbols) ||
+      !api.symbols.length ||
+      !api.symbols.every((id) => typeof id === 'string' && id.length && !/\s/.test(id)) ||
+      typeof api.description !== 'string' ||
+      !api.description.trim() ||
+      typeof api.output !== 'string' ||
+      !api.output.trim() ||
+      !api.output.endsWith('\n')
+    ) {
       throw new Error(`Invalid Ruby API example metadata: ${program.path}`)
     }
     const code = files.get(program.path)
@@ -66,7 +73,8 @@ export function attachCompleteRubyExamples(
       },
       {
         lang: 'console',
-        intro: 'Install the runtime dependencies and run the saved program. An operation or cleanup error makes it exit unsuccessfully:',
+        intro:
+          'Install the runtime dependencies and run the saved program. An operation or cleanup error makes it exit unsuccessfully:',
         code: `$ bundle config set --local path vendor/bundle && \\\n  bundle install --jobs 2 && \\\n  bundle exec ruby ${filename}\n`,
       },
       { lang: 'text', intro: 'Expected output:', code: api.output },
diff --git a/packages/api-model/src/languages/ruby.ts b/packages/api-model/src/languages/ruby.ts
index 66507d724..39820327a 100644
--- a/packages/api-model/src/languages/ruby.ts
+++ b/packages/api-model/src/languages/ruby.ts
@@ -84,7 +84,9 @@ function docBlock(text = '', contract?: { id: string; title: string }): DocBlock
   const [summary = '', ...body] = trimmed.split(/\n\s*\n/)
   return {
     summary: summary || `Behavior: ${contract?.title}.`,
-    body: [body.join('\n\n'), contract ? `Behavior contract: ${contract.title}.` : ''].filter(Boolean).join('\n\n') || undefined,
+    body:
+      [body.join('\n\n'), contract ? `Behavior contract: ${contract.title}.` : ''].filter(Boolean).join('\n\n') ||
+      undefined,
   }
 }
 
@@ -131,24 +133,35 @@ function rbsSignature(raw: string, tags: RubyTag[] = []): Signature {
   const close = open < 0 ? -1 : closingParen(raw, open)
   const arrow = close < 0 ? -1 : topLevelArrow(raw, close + 1)
   const docs = new Map(tags.filter((tag) => tag.tag === 'param' && tag.name).map((tag) => [tag.name!, tag.text]))
-  const params: Param[] = open < 0 || close < 0 ? [] : splitTopLevel(raw.slice(open + 1, close)).map((part, index) => {
-    const keyword = /^(\??)([A-Za-z_]\w*[!?=]?):\s*(.+)$/.exec(part)
-    if (keyword) {
-      return {
-        name: keyword[2], type: keyword[3],
-        ...(keyword[1] ? { default: 'nil' } : {}),
-        ...(docs.get(keyword[2]) ? { doc: docs.get(keyword[2]) } : {}),
-      }
-    }
-    if (part.startsWith('**')) return { name: 'kwargs', type: part.slice(2), variadic: 'keyword' as const }
-    if (part.startsWith('*')) return { name: 'args', type: part.slice(1), variadic: 'positional' as const }
-    const optional = part.startsWith('?')
-    return { name: `arg${index + 1}`, type: optional ? part.slice(1) : part, ...(optional ? { default: 'nil' } : {}) }
-  })
+  const params: Param[] =
+    open < 0 || close < 0
+      ? []
+      : splitTopLevel(raw.slice(open + 1, close)).map((part, index) => {
+          const keyword = /^(\??)([A-Za-z_]\w*[!?=]?):\s*(.+)$/.exec(part)
+          if (keyword) {
+            return {
+              name: keyword[2],
+              type: keyword[3],
+              ...(keyword[1] ? { default: 'nil' } : {}),
+              ...(docs.get(keyword[2]) ? { doc: docs.get(keyword[2]) } : {}),
+            }
+          }
+          if (part.startsWith('**')) return { name: 'kwargs', type: part.slice(2), variadic: 'keyword' as const }
+          if (part.startsWith('*')) return { name: 'args', type: part.slice(1), variadic: 'positional' as const }
+          const optional = part.startsWith('?')
+          return {
+            name: `arg${index + 1}`,
+            type: optional ? part.slice(1) : part,
+            ...(optional ? { default: 'nil' } : {}),
+          }
+        })
   const typeParams = raw.startsWith('[') ? splitTopLevel(raw.slice(1, raw.indexOf(']'))) : undefined
-  const raises = tags.filter((tag) => tag.tag === 'raise').map((tag) => ({
-    type: tag.types?.join(' | ') || tag.name || 'StandardError', doc: tag.text,
-  }))
+  const raises = tags
+    .filter((tag) => tag.tag === 'raise')
+    .map((tag) => ({
+      type: tag.types?.join(' | ') || tag.name || 'StandardError',
+      doc: tag.text,
+    }))
   const returnsDoc = tags.find((tag) => tag.tag === 'return')?.text?.trim() || undefined
   return {
     raw,
diff --git a/packages/api-model/src/languages/rust-examples.ts b/packages/api-model/src/languages/rust-examples.ts
index 5dad0aaf0..46610986f 100644
--- a/packages/api-model/src/languages/rust-examples.ts
+++ b/packages/api-model/src/languages/rust-examples.ts
@@ -37,12 +37,15 @@ export function attachCompleteRustExamples(
     if (!condition) throw new Error(`Invalid complete Rust examples: ${message}`)
   }
   const manifest = JSON.parse(raw) as Manifest
-  require(source.repo === 'libtmux/libtmux-rs' && /^[a-f0-9]{40}$/.test(source.revision),
-    'source must name the Rust repository and a full revision')
-  require(manifest?.schemaVersion === 1 && manifest.language === 'rust' &&
-    Array.isArray(manifest.examples) && manifest.examples.length, 'unsupported or empty manifest')
+  require(source.repo === 'libtmux/libtmux-rs' &&
+    /^[a-f0-9]{40}$/.test(source.revision), 'source must name the Rust repository and a full revision')
+  require(manifest?.schemaVersion === 1 &&
+    manifest.language === 'rust' &&
+    Array.isArray(manifest.examples) &&
+    manifest.examples.length, 'unsupported or empty manifest')
   require(manifest.nativeInventory === 'crates/libtmux/docs/public-api.txt' &&
-    manifest.programFileName === 'src/main.rs' && manifest.runCommand === 'cargo run --quiet' &&
+    manifest.programFileName === 'src/main.rs' &&
+    manifest.runCommand === 'cargo run --quiet' &&
     JSON.stringify(manifest.setupFiles) === JSON.stringify(setup), 'unexpected consumer setup')
   const codeFor = (file: string): string => {
     const code = read(file)
@@ -63,34 +66,41 @@ export function attachCompleteRustExamples(
     value !== null && typeof value === 'object' && !Array.isArray(value) && !(value instanceof Date)
   const tokio = table(dependencies) && table(dependencies.tokio) ? dependencies.tokio : undefined
   const features = tokio?.features
-  require(table(packageInfo) && packageInfo.name === 'libtmux-api-example' &&
-    packageInfo.edition === '2024' && packageInfo.publish === false && table(workspace) &&
+  require(table(packageInfo) &&
+    packageInfo.name === 'libtmux-api-example' &&
+    packageInfo.edition === '2024' &&
+    packageInfo.publish === false &&
+    table(workspace) &&
     JSON.stringify(workspace.exclude) === JSON.stringify(['libtmux-source']) &&
-    table(dependencies) && table(dependencies.libtmux) &&
+    table(dependencies) &&
+    table(dependencies.libtmux) &&
     dependencies.libtmux.path === 'libtmux-source/crates/libtmux' &&
-    typeof dependencies.tempfile === 'string' && dependencies.tempfile.trim() &&
-    tokio && typeof tokio.version === 'string' && Array.isArray(features) &&
-    ['macros', 'rt', 'time'].every((feature) => features.includes(feature)),
-  'consumer dependencies or workspace boundary are missing')
+    typeof dependencies.tempfile === 'string' &&
+    dependencies.tempfile.trim() &&
+    tokio &&
+    typeof tokio.version === 'string' &&
+    Array.isArray(features) &&
+    ['macros', 'rt', 'time'].every((feature) =>
+      features.includes(feature),
+    ), 'consumer dependencies or workspace boundary are missing')
   const channel = table(toolchain) && typeof toolchain.channel === 'string' ? toolchain.channel : ''
   require(/^\d+\.\d+\.\d+$/.test(channel), 'toolchain must pin a Rust release')
 
   const native = new Map<string, string[]>()
-  for (const match of codeFor(manifest.nativeInventory).matchAll(
-    /^(\w+) (libtmux::[\w:]+)(?=: |$)/gm)) {
+  for (const match of codeFor(manifest.nativeInventory).matchAll(/^(\w+) (libtmux::[\w:]+)(?=: |$)/gm)) {
     native.set(match[2], [...(native.get(match[2]) ?? []), match[1]])
   }
   const isCore = (symbol: ApiSymbol) =>
-    /(?:^|\/)crates\/libtmux\/src\//.test(symbol.source.file) &&
-    (!symbol.product || symbol.product === 'core')
+    /(?:^|\/)crates\/libtmux\/src\//.test(symbol.source.file) && (!symbol.product || symbol.product === 'core')
   const resolve = (target: string): ApiSymbol => {
     const kinds = native.get(target) ?? []
     require(kinds.length === 1, `native target must resolve once: ${target}`)
     const kind = kinds[0] === 'function' ? 'method' : kinds[0]
     require(['struct', 'enum', 'trait', 'method'].includes(kind), `unsupported native kind: ${target}`)
     const suffix = target.slice('libtmux::'.length).replaceAll('::', '.')
-    const matches = symbols.filter((symbol) => isCore(symbol) && symbol.kind === kind &&
-      (symbol.id === suffix || symbol.id.endsWith(`.${suffix}`)))
+    const matches = symbols.filter(
+      (symbol) => isCore(symbol) && symbol.kind === kind && (symbol.id === suffix || symbol.id.endsWith(`.${suffix}`)),
+    )
     require(matches.length === 1, `API target must resolve once with its native kind: ${target}`)
     const symbol = matches[0]
     if (kind === 'method') {
@@ -103,41 +113,54 @@ export function attachCompleteRustExamples(
   const targets = new Set<string>()
   const pending: { symbol: ApiSymbol; blocks: NonNullable<DocBlock['examples']> }[] = []
   for (const program of manifest.examples) {
-    require(typeof program.id === 'string' && /^rust-[a-z]+$/.test(program.id) &&
+    require(typeof program.id === 'string' &&
+      /^rust-[a-z]+$/.test(program.id) &&
       !ids.has(program.id), 'invalid or duplicate program ID')
     ids.add(program.id)
     const name = program.id.slice('rust-'.length)
     require(program.cargoExample === `api_${name}` &&
       program.sourceFile === `crates/libtmux/examples/api_${name}.rs`, 'unexpected program path')
     require([program.title, program.description, program.expectedOutput].every(
-      (value) => typeof value === 'string' && value.trim() && !/[\r\n]/.test(value)),
-    'task description or expected output is missing')
+      (value) => typeof value === 'string' && value.trim() && !/[\r\n]/.test(value),
+    ), 'task description or expected output is missing')
     require(Array.isArray(program.targets) && program.targets.length, 'API targets are missing')
     const code = codeFor(program.sourceFile)
-    require(code.includes('#[tokio::main') && code.includes('async fn main()'),
-      'program entry point is missing')
-    require(!/\binclude(?:_str|_bytes)?!|^\s*mod\s+\w+\s*;|use\s+(?:crate|super)::/m.test(code),
-      'program depends on a hidden source helper')
-    const blocks: NonNullable<DocBlock['examples']> = [{
-      lang: 'console',
-      intro: `${program.title}. ${program.description} Use a Unix environment with Git, rustup, and tmux 3.2a or newer. The toolchain file below pins Rust ${channel}. In an empty directory, fetch the documented source:`,
-      code: `$ git clone https://github.com/${source.repo}.git libtmux-source &&\n  git -C libtmux-source checkout --detach ${source.revision}\n`,
-    }, ...setup.map((file, index) => ({
-      lang: 'toml', intro: `Save this complete consumer setup as ${file.name}:`,
-      sourceUrl: urlFor(file.sourceFile), code: setupCode[index],
-    })), {
-      lang: 'rust',
-      intro: 'Save this complete program as src/main.rs. It owns a private tmux socket, applies a ten-second task deadline, and reports both task and cleanup errors. Server::kill stops its daemon; Server::shutdown closes its client executor. Successful cleanup removes the temporary directory even when the task fails.',
-      sourceUrl: urlFor(program.sourceFile), code,
-    }, {
-      lang: 'console',
-      intro: 'Copy the complete files from the pinned checkout and run the consumer. This also creates src for the displayed program. Success exits with status 0; setup, operation, deadline or cleanup failures exit unsuccessfully and print diagnostics to stderr:',
-      code: '$ mkdir -p src &&\n' +
-        '  cp libtmux-source/crates/libtmux/examples/api/consumer.toml Cargo.toml &&\n' +
-        '  cp libtmux-source/rust-toolchain.toml rust-toolchain.toml &&\n' +
-        `  cp libtmux-source/${program.sourceFile} src/main.rs &&\n` +
-        `  ${manifest.runCommand}\n`,
-    }, { lang: 'text', intro: 'Expected output:', code: `${program.expectedOutput}\n` }]
+    require(code.includes('#[tokio::main') && code.includes('async fn main()'), 'program entry point is missing')
+    require(!/\binclude(?:_str|_bytes)?!|^\s*mod\s+\w+\s*;|use\s+(?:crate|super)::/m.test(
+      code,
+    ), 'program depends on a hidden source helper')
+    const blocks: NonNullable<DocBlock['examples']> = [
+      {
+        lang: 'console',
+        intro: `${program.title}. ${program.description} Use a Unix environment with Git, rustup, and tmux 3.2a or newer. The toolchain file below pins Rust ${channel}. In an empty directory, fetch the documented source:`,
+        code: `$ git clone https://github.com/${source.repo}.git libtmux-source &&\n  git -C libtmux-source checkout --detach ${source.revision}\n`,
+      },
+      ...setup.map((file, index) => ({
+        lang: 'toml',
+        intro: `Save this complete consumer setup as ${file.name}:`,
+        sourceUrl: urlFor(file.sourceFile),
+        code: setupCode[index],
+      })),
+      {
+        lang: 'rust',
+        intro:
+          'Save this complete program as src/main.rs. It owns a private tmux socket, applies a ten-second task deadline, and reports both task and cleanup errors. Server::kill stops its daemon; Server::shutdown closes its client executor. Successful cleanup removes the temporary directory even when the task fails.',
+        sourceUrl: urlFor(program.sourceFile),
+        code,
+      },
+      {
+        lang: 'console',
+        intro:
+          'Copy the complete files from the pinned checkout and run the consumer. This also creates src for the displayed program. Success exits with status 0; setup, operation, deadline or cleanup failures exit unsuccessfully and print diagnostics to stderr:',
+        code:
+          '$ mkdir -p src &&\n' +
+          '  cp libtmux-source/crates/libtmux/examples/api/consumer.toml Cargo.toml &&\n' +
+          '  cp libtmux-source/rust-toolchain.toml rust-toolchain.toml &&\n' +
+          `  cp libtmux-source/${program.sourceFile} src/main.rs &&\n` +
+          `  ${manifest.runCommand}\n`,
+      },
+      { lang: 'text', intro: 'Expected output:', code: `${program.expectedOutput}\n` },
+    ]
     for (const target of program.targets) {
       require(typeof target === 'string' && /^libtmux::[\w:]+$/.test(target), 'invalid native target')
       require(!targets.has(target), `duplicate API target: ${target}`)
diff --git a/packages/api-model/src/languages/spec.ts b/packages/api-model/src/languages/spec.ts
index 96b50a782..63a1fe0fc 100644
--- a/packages/api-model/src/languages/spec.ts
+++ b/packages/api-model/src/languages/spec.ts
@@ -146,11 +146,7 @@ function docCommentFor(node: Node, spec: LanguageSpec): string | undefined {
   // up through transparent wrappers is the difference between 16% and 80% of
   // TypeScript's symbols being documented — and nothing failed at 16%.
   let anchor: Node = node
-  while (
-    !anchor.previousNamedSibling &&
-    anchor.parent &&
-    spec.transparent?.includes(anchor.parent.type)
-  ) {
+  while (!anchor.previousNamedSibling && anchor.parent && spec.transparent?.includes(anchor.parent.type)) {
     anchor = anchor.parent
   }
   let cursor: Node | null = anchor.previousNamedSibling
@@ -217,8 +213,10 @@ function paramsOf(node: Node | null, spec: LanguageSpec): Param[] {
     }
     const name = child.childForFieldName('name') ?? child.childForFieldName('pattern')
     const type = child.childForFieldName('type')
-    const value = child.childForFieldName('value') ?? child.childForFieldName('default_value')
-      ?? child.namedChildren.find((node) => node?.type === 'equals_value_clause')?.namedChild(0)
+    const value =
+      child.childForFieldName('value') ??
+      child.childForFieldName('default_value') ??
+      child.namedChildren.find((node) => node?.type === 'equals_value_clause')?.namedChild(0)
     // Go groups parameters — `a, b string` is one node with two names — and a
     // receiver has no name at all. Falling back to the node's own text keeps
     // both readable instead of emitting an empty row.
@@ -226,7 +224,7 @@ function paramsOf(node: Node | null, spec: LanguageSpec): Param[] {
     if (!label) continue
     out.push({
       name: label.replace(/^[&*]+/, ''),
-      type: type ? spec.typeText?.(type) ?? type.text.replace(/\s+/g, ' ') : undefined,
+      type: type ? (spec.typeText?.(type) ?? type.text.replace(/\s+/g, ' ')) : undefined,
       default: value?.text,
     })
   }
@@ -236,16 +234,16 @@ function paramsOf(node: Node | null, spec: LanguageSpec): Param[] {
 function signatureOf(node: Node, spec: LanguageSpec): Signature {
   const f = { ...DEFAULT_FIELDS, ...spec.fields }
   const returns =
-    node.childForFieldName(f.returns) ??
-    node.childForFieldName('result') ??
-    node.childForFieldName('type')
+    node.childForFieldName(f.returns) ?? node.childForFieldName('result') ?? node.childForFieldName('type')
   return {
     params: paramsOf(node.childForFieldName(f.params), spec),
     // A grammar's return-type node often includes the syntax that introduces
     // it: TypeScript's `type_annotation` is `: string`, and all 240 of its
     // signatures rendered as `foo() → : string`. The arrow or colon is the
     // renderer's to draw.
-    returns: returns ? spec.typeText?.(returns) ?? returns.text.replace(/\s+/g, ' ').replace(/^\s*(?:->|:)\s*/, '') : undefined,
+    returns: returns
+      ? (spec.typeText?.(returns) ?? returns.text.replace(/\s+/g, ' ').replace(/^\s*(?:->|:)\s*/, ''))
+      : undefined,
     typeParams: node
       .childForFieldName('type_parameters')
       ?.namedChildren.map((n) => n?.text ?? '')
@@ -346,8 +344,13 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
           if (ctx.byId.has(propertyId)) continue
           const declaration = parameters.find((node) => node?.childForFieldName('name')?.text === parameter.name)
           emit(ctx, {
-            id: propertyId, name: parameter.name, kind: 'property', parent: id,
-            type: parameter.type, modifiers: [], signatures: [],
+            id: propertyId,
+            name: parameter.name,
+            kind: 'property',
+            parent: id,
+            type: parameter.type,
+            modifiers: [],
+            signatures: [],
             doc: parameter.doc ? { summary: parameter.doc } : undefined,
             source: { file: ctx.file, line: (declaration ?? child).startPosition.row + 1 },
           })
@@ -366,8 +369,7 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
     // `function_item`, so the spec cannot tell them apart — only the presence
     // of an enclosing `impl` or `trait` can, and that is known here. 85 Rust
     // functions in `mod` blocks were reported as ownerless methods.
-    const resolvedKind: SymbolKind =
-      memberKind === 'method' && !owner ? 'function' : memberKind
+    const resolvedKind: SymbolKind = memberKind === 'method' && !owner ? 'function' : memberKind
     // Built before the doc so C#'s `<param>` and `<exception>` can be lifted
     // onto it: the comment carries them, and nothing else does.
     const memberSignatures = hasParams ? [signatureOf(child, spec)] : []
@@ -378,9 +380,11 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
       modifiers,
       parent: owner,
       signatures: memberSignatures,
-      type: hasParams ? undefined : child.childForFieldName('type') && spec.typeText
-        ? spec.typeText(child.childForFieldName('type')!)
-        : (child.childForFieldName('type')?.text ?? spec.implicitType?.(child))?.replace(/\s+/g, ' '),
+      type: hasParams
+        ? undefined
+        : child.childForFieldName('type') && spec.typeText
+          ? spec.typeText(child.childForFieldName('type')!)
+          : (child.childForFieldName('type')?.text ?? spec.implicitType?.(child))?.replace(/\s+/g, ' '),
       value: hasParams
         ? undefined
         : child.childForFieldName('declarator')?.childForFieldName('value')?.text.replace(/\s+/g, ' '),
@@ -401,11 +405,7 @@ function walk(node: Node, ctx: Ctx, parent: string | undefined): void {
  * The dialect is declared on the spec rather than tested for by grammar name,
  * so adding a port that documents in markup is a field rather than a branch.
  */
-function docFor(
-  raw: string | undefined,
-  spec: LanguageSpec,
-  signatures: Signature[],
-): DocBlock | undefined {
+function docFor(raw: string | undefined, spec: LanguageSpec, signatures: Signature[]): DocBlock | undefined {
   if (!raw) return undefined
   const parse =
     spec.docDialect === 'xml'
@@ -437,18 +437,25 @@ export async function extractWithSpec(
   const parser = await parserFor(spec.grammar)
   const tree = parser.parse(readFileSync(file, 'utf8'))
   if (!tree) return []
-  const packageName = spec.grammar === 'java'
-    ? tree.rootNode.namedChildren.find((node) => node?.type === 'package_declaration')
-      ?.namedChildren.find((node) => node?.type === 'scoped_identifier' || node?.type === 'identifier')
-    : undefined
+  const packageName =
+    spec.grammar === 'java'
+      ? tree.rootNode.namedChildren
+          .find((node) => node?.type === 'package_declaration')
+          ?.namedChildren.find((node) => node?.type === 'scoped_identifier' || node?.type === 'identifier')
+      : undefined
   const ctx: Ctx = {
     file,
     module,
     // Java packages come from declarations, not source paths or file names.
-    namespace: spec.grammar === 'java'
-      ? packageName?.type === 'identifier' ? packageName.text
-        : packageName?.descendantsOfType('identifier').flatMap((node) => node ? [node.text] : []).join('.') ?? ''
-      : undefined,
+    namespace:
+      spec.grammar === 'java'
+        ? packageName?.type === 'identifier'
+          ? packageName.text
+          : (packageName
+              ?.descendantsOfType('identifier')
+              .flatMap((node) => (node ? [node.text] : []))
+              .join('.') ?? '')
+        : undefined,
     symbols: [],
     byId: new Map(),
     spec,
diff --git a/packages/api-model/src/languages/specs.ts b/packages/api-model/src/languages/specs.ts
index 8b9f7fdff..d06ce5179 100644
--- a/packages/api-model/src/languages/specs.ts
+++ b/packages/api-model/src/languages/specs.ts
@@ -38,7 +38,8 @@ const stripSlashDoc = (raw: string): string | undefined => {
 
 /** Remove syntax nodes, not comment-looking text inside string literal types. */
 function typescriptType(node: Node): string {
-  const type = node.firstChild?.type === ':' ? node.namedChildren.find((child) => child?.type !== 'comment') ?? node : node
+  const type =
+    node.firstChild?.type === ':' ? (node.namedChildren.find((child) => child?.type !== 'comment') ?? node) : node
   let text = type.text
   const comments = type.descendantsOfType('comment').filter((node): node is Node => node !== null)
   for (const comment of comments.sort((a, b) => b.startIndex - a.startIndex)) {
@@ -50,7 +51,9 @@ function typescriptType(node: Node): string {
   const rest = lines.slice(1).filter((line) => line.trim())
   const indent = rest.length ? Math.min(...rest.map((line) => /^\s*/.exec(line)![0].length)) : 0
   return [lines[0], ...lines.slice(1).map((line) => line.slice(Math.min(indent, /^\s*/.exec(line)![0].length)))]
-    .filter((line) => line.trim()).join('\n').trim()
+    .filter((line) => line.trim())
+    .join('\n')
+    .trim()
 }
 
 /** Inline option descriptions belong to the parameter, with their field paths. */
@@ -67,8 +70,10 @@ function typescriptParameter(node: Node) {
         if (!field) continue
         const names = [...path, field]
         const previous = child.previousNamedSibling
-        const doc = previous?.type === 'comment' && previous.endPosition.row >= child.startPosition.row - 1
-          ? stripBlockDoc(previous.text) : undefined
+        const doc =
+          previous?.type === 'comment' && previous.endPosition.row >= child.startPosition.row - 1
+            ? stripBlockDoc(previous.text)
+            : undefined
         if (doc) descriptions.push(`- \`${names.join('.')}\`: ${doc.replaceAll('\n', '\n  ')}`)
         const nested = child.childForFieldName('type')
         if (nested) visit(nested, names)
@@ -126,8 +131,7 @@ export const TYPESCRIPT: LanguageSpec = {
   // carrying a page for a shape a caller cannot import. Exporting them is the
   // port's decision to make. A private function is named by nothing.
   isExported: (node) =>
-    node.parent?.type !== 'program' ||
-    (node.type !== 'function_declaration' && node.type !== 'function_signature'),
+    node.parent?.type !== 'program' || (node.type !== 'function_declaration' && node.type !== 'function_signature'),
   fields: { returns: 'return_type' },
   typeText: typescriptType,
   parameter: typescriptParameter,
@@ -140,11 +144,18 @@ function rustDocHidden(node: Node): boolean {
       const attribute = sibling.namedChildren.find((child) => child?.type === 'attribute')
       if (attribute?.namedChildren[0]?.text !== 'doc') continue
       const args = attribute.namedChildren.find((child) => child?.type === 'token_tree')
-      const tokens = args?.children.filter((child) => child &&
-        child.type !== 'line_comment' && child.type !== 'block_comment') ?? []
-      if (tokens.some((token, index) => token?.type === 'identifier' && token.text === 'hidden' &&
-        ['(', ','].includes(tokens[index - 1]?.type ?? '') &&
-        [')', ','].includes(tokens[index + 1]?.type ?? ''))) return true
+      const tokens =
+        args?.children.filter((child) => child && child.type !== 'line_comment' && child.type !== 'block_comment') ?? []
+      if (
+        tokens.some(
+          (token, index) =>
+            token?.type === 'identifier' &&
+            token.text === 'hidden' &&
+            ['(', ','].includes(tokens[index - 1]?.type ?? '') &&
+            [')', ','].includes(tokens[index + 1]?.type ?? ''),
+        )
+      )
+        return true
     } else if (sibling.type !== 'line_comment' && sibling.type !== 'block_comment') break
   }
   return false
@@ -177,13 +188,7 @@ export const RUST: LanguageSpec = {
     // `variant` kind, and a named member of an enum is what a constant is.
     enum_variant: 'constant',
   },
-  transparent: [
-    'declaration_list',
-    'field_declaration_list',
-    'source_file',
-    'mod_item',
-    'enum_variant_list',
-  ],
+  transparent: ['declaration_list', 'field_declaration_list', 'source_file', 'mod_item', 'enum_variant_list'],
   commentTypes: ['line_comment', 'block_comment'],
   attributeTypes: ['attribute_item'],
   // A module compiled only for tests is not API. Rust keeps its unit tests
@@ -211,7 +216,7 @@ export const RUST: LanguageSpec = {
       .replace(/\bdyn\s+/g, '')
       .trim(),
   // Receivers have no name field: splitting `mut self` would name it `mut`.
-  parameter: (node) => node.type === 'self_parameter' ? { name: node.text } : undefined,
+  parameter: (node) => (node.type === 'self_parameter' ? { name: node.text } : undefined),
   // Trait methods and enum variants inherit their owner's visibility; the
   // walker rejects private owners before visiting their members. Impl blocks
   // have no visibility keyword, but inherent methods still require `pub`.
@@ -219,8 +224,11 @@ export const RUST: LanguageSpec = {
   isExported: (node) => {
     if (node.type === 'trait_item' && rustDocHidden(node)) return false
     if (node.type === 'impl_item' || node.type === 'enum_variant') return true
-    if ((node.type === 'function_item' || node.type === 'function_signature_item') &&
-      node.parent?.type === 'declaration_list' && node.parent.parent?.type === 'trait_item') {
+    if (
+      (node.type === 'function_item' || node.type === 'function_signature_item') &&
+      node.parent?.type === 'declaration_list' &&
+      node.parent.parent?.type === 'trait_item'
+    ) {
       return !rustDocHidden(node)
     }
     return node.children.some((c) => c?.type === 'visibility_modifier' && c.text.trim() === 'pub')
@@ -238,12 +246,18 @@ export const GO: LanguageSpec = {
     const_spec: 'constant',
     var_spec: 'attribute',
   },
-  transparent: ['type_declaration', 'const_declaration', 'var_declaration', 'struct_type', 'interface_type', 'field_declaration_list'],
+  transparent: [
+    'type_declaration',
+    'const_declaration',
+    'var_declaration',
+    'struct_type',
+    'interface_type',
+    'field_declaration_list',
+  ],
   commentTypes: ['comment'],
   // godoc has no marker: a `//` comment directly above a declaration is the
   // documentation. `//go:` directives are build metadata and are not.
-  stripDoc: (raw) =>
-    raw.startsWith('//') && !raw.startsWith('//go:') ? raw.replace(/^\/\/\s?/, '') : undefined,
+  stripDoc: (raw) => (raw.startsWith('//') && !raw.startsWith('//go:') ? raw.replace(/^\/\/\s?/, '') : undefined),
   // `func (w Window) Panes()` — the owning type is in the `receiver` field,
   // not in any enclosing node. Pointers and aliases both appear; the type name
   // is what matters, so `*Window` and `Window` resolve to the same owner.
@@ -251,7 +265,12 @@ export const GO: LanguageSpec = {
     if (node.type !== 'method_declaration') return undefined
     const decl = node.childForFieldName('receiver')?.namedChildren[0]
     const type = decl?.childForFieldName('type')?.text
-    return type?.replace(/^[*&]+/, '').replace(/\[.*$/, '').trim() || undefined
+    return (
+      type
+        ?.replace(/^[*&]+/, '')
+        .replace(/\[.*$/, '')
+        .trim() || undefined
+    )
   },
   // `TreeSortIndex` under `TreeSortDefault TreeSortOrder = iota` repeats the
   // spec above it, type included. Without this only the first value of each
@@ -299,9 +318,11 @@ export const JAVA: LanguageSpec = {
       // Keep existing internal records, but do not merge their signatures into
       // an advertised overload set. Interface methods are implicitly public.
       const name = node.childForFieldName('name')?.text
-      return !node.parent?.namedChildren.some((sibling) =>
-        sibling?.type === node.type && sibling.childForFieldName('name')?.text === name &&
-        sibling.children.some((child) => child?.type === 'modifiers' && /\b(public|protected)\b/.test(child.text)),
+      return !node.parent?.namedChildren.some(
+        (sibling) =>
+          sibling?.type === node.type &&
+          sibling.childForFieldName('name')?.text === name &&
+          sibling.children.some((child) => child?.type === 'modifiers' && /\b(public|protected)\b/.test(child.text)),
       )
     }
     return true
@@ -311,8 +332,9 @@ export const JAVA: LanguageSpec = {
 export const CSHARP: LanguageSpec = {
   grammar: 'csharp',
   docDialect: 'xml',
-  positionalProperties: (node) => ['record_declaration', 'record_struct_declaration'].includes(node.type)
-    && Boolean(node.childForFieldName('parameters')),
+  positionalProperties: (node) =>
+    ['record_declaration', 'record_struct_declaration'].includes(node.type) &&
+    Boolean(node.childForFieldName('parameters')),
   containers: {
     class_declaration: 'class',
     interface_declaration: 'interface',
diff --git a/packages/api-model/src/languages/swift-examples.test.ts b/packages/api-model/src/languages/swift-examples.test.ts
index 64b3e12a4..b9ff64c06 100644
--- a/packages/api-model/src/languages/swift-examples.test.ts
+++ b/packages/api-model/src/languages/swift-examples.test.ts
@@ -4,16 +4,29 @@ import { attachCompleteSwiftExamples } from './swift-examples.ts'
 
 const source = { repo: 'libtmux/libtmux-swift', revision: 'a'.repeat(40) }
 const symbol = (): ApiSymbol => ({
-  id: 'Server', name: 'Server', slug: 'server', kind: 'struct', signatures: [], modifiers: [],
+  id: 'Server',
+  name: 'Server',
+  slug: 'server',
+  kind: 'struct',
+  signatures: [],
+  modifiers: [],
   source: { file: 'Sources/LibTmux/Server.swift' },
   doc: { summary: 'A tmux server address.', examples: [{ lang: 'swift', code: 'let old = true\n' }] },
 })
 const fixture = () => {
   const manifest = {
-    schemaVersion: 1, packageFile: 'Examples/Standalone/Package.swift',
-    examples: [{ name: 'ApiServer', symbols: ['Server'], title: 'List sessions',
-      description: 'Read the server listing.', expectedOutput: ['bootstrap'],
-      file: 'Examples/Sources/ApiServer/ApiServer.swift' }],
+    schemaVersion: 1,
+    packageFile: 'Examples/Standalone/Package.swift',
+    examples: [
+      {
+        name: 'ApiServer',
+        symbols: ['Server'],
+        title: 'List sessions',
+        description: 'Read the server listing.',
+        expectedOutput: ['bootstrap'],
+        file: 'Examples/Sources/ApiServer/ApiServer.swift',
+      },
+    ],
   }
   const packageCode = '// swift-tools-version: 6.2\nimport PackageDescription\n'
   const programCode = 'import LibTmux\n@main struct ApiServer { static func main() {} }\n'
@@ -21,8 +34,7 @@ const fixture = () => {
     'Examples/Standalone/Package.swift': packageCode,
     'Examples/Sources/ApiServer/ApiServer.swift': programCode,
   }
-  const read = (path: string) => path === 'Examples/api-examples.json'
-    ? JSON.stringify(manifest) : files[path]
+  const read = (path: string) => (path === 'Examples/api-examples.json' ? JSON.stringify(manifest) : files[path])
   return { manifest, files, read, packageCode, programCode }
 }
 
@@ -35,12 +47,17 @@ describe('complete Swift API examples', () => {
     expect(target.doc?.examples?.[0].code).toBe('let old = true\n')
     expect(target.doc?.examples?.slice(1).map((block) => block.code)).toEqual([
       `$ git clone https://github.com/${source.repo}.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`,
-      packageCode, programCode, '$ swift run --jobs 5 ApiExample\n', 'bootstrap\n',
+      packageCode,
+      programCode,
+      '$ swift run --jobs 5 ApiExample\n',
+      'bootstrap\n',
     ])
     expect(target.doc?.examples?.[2].sourceUrl).toBe(
-      `https://github.com/${source.repo}/blob/${source.revision}/Examples/Standalone/Package.swift`)
+      `https://github.com/${source.repo}/blob/${source.revision}/Examples/Standalone/Package.swift`,
+    )
     expect(target.doc?.examples?.[3].sourceUrl).toBe(
-      `https://github.com/${source.repo}/blob/${source.revision}/Examples/Sources/ApiServer/ApiServer.swift`)
+      `https://github.com/${source.repo}/blob/${source.revision}/Examples/Sources/ApiServer/ApiServer.swift`,
+    )
   })
 
   it('leaves older source revisions without a manifest unchanged', () => {
@@ -51,18 +68,78 @@ describe('complete Swift API examples', () => {
   })
 
   it.each([
-    ['unknown target', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].symbols = ['Unknown'] }],
-    ['duplicate target', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].symbols.push('Server') }],
-    ['duplicate program', (f: ReturnType<typeof fixture>) => { f.manifest.examples.push(f.manifest.examples[0]) }],
-    ['missing program', (f: ReturnType<typeof fixture>) => { delete f.files[f.manifest.examples[0].file] }],
-    ['missing package', (f: ReturnType<typeof fixture>) => { delete f.files[f.manifest.packageFile] }],
-    ['partial file', (f: ReturnType<typeof fixture>) => { f.files[f.manifest.examples[0].file] = 'import LibTmux' }],
-    ['unsafe path', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].file = '../Example.swift' }],
-    ['unexpected package', (f: ReturnType<typeof fixture>) => { f.manifest.packageFile = 'Package.swift' }],
-    ['empty output', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].expectedOutput = [] }],
-    ['multiline output item', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].expectedOutput = ['x\ny'] }],
-    ['missing description', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].description = ' ' }],
-    ['unsupported schema', (f: ReturnType<typeof fixture>) => { f.manifest.schemaVersion = 2 }],
+    [
+      'unknown target',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].symbols = ['Unknown']
+      },
+    ],
+    [
+      'duplicate target',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].symbols.push('Server')
+      },
+    ],
+    [
+      'duplicate program',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples.push(f.manifest.examples[0])
+      },
+    ],
+    [
+      'missing program',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files[f.manifest.examples[0].file]
+      },
+    ],
+    [
+      'missing package',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files[f.manifest.packageFile]
+      },
+    ],
+    [
+      'partial file',
+      (f: ReturnType<typeof fixture>) => {
+        f.files[f.manifest.examples[0].file] = 'import LibTmux'
+      },
+    ],
+    [
+      'unsafe path',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].file = '../Example.swift'
+      },
+    ],
+    [
+      'unexpected package',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.packageFile = 'Package.swift'
+      },
+    ],
+    [
+      'empty output',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].expectedOutput = []
+      },
+    ],
+    [
+      'multiline output item',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].expectedOutput = ['x\ny']
+      },
+    ],
+    [
+      'missing description',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].description = ' '
+      },
+    ],
+    [
+      'unsupported schema',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.schemaVersion = 2
+      },
+    ],
   ])('rejects %s', (_name, change) => {
     const f = fixture()
     change(f)
@@ -72,7 +149,11 @@ describe('complete Swift API examples', () => {
   it('rejects ambiguous identities, unpinned revisions and unexpected repositories', () => {
     const { read } = fixture()
     expect(() => attachCompleteSwiftExamples([symbol(), symbol()], read, source)).toThrow('resolve once')
-    expect(() => attachCompleteSwiftExamples([symbol()], read, { ...source, revision: 'master' })).toThrow('full revision')
-    expect(() => attachCompleteSwiftExamples([symbol()], read, { ...source, repo: 'other/repo' })).toThrow('Swift repository')
+    expect(() => attachCompleteSwiftExamples([symbol()], read, { ...source, revision: 'master' })).toThrow(
+      'full revision',
+    )
+    expect(() => attachCompleteSwiftExamples([symbol()], read, { ...source, repo: 'other/repo' })).toThrow(
+      'Swift repository',
+    )
   })
 })
diff --git a/packages/api-model/src/languages/swift-examples.ts b/packages/api-model/src/languages/swift-examples.ts
index 46b1ad494..9767b739a 100644
--- a/packages/api-model/src/languages/swift-examples.ts
+++ b/packages/api-model/src/languages/swift-examples.ts
@@ -27,10 +27,11 @@ export function attachCompleteSwiftExamples(
   const require = (condition: unknown, message: string): void => {
     if (!condition) throw new Error(`Invalid complete Swift examples: ${message}`)
   }
-  require(source.repo === 'libtmux/libtmux-swift' && /^[a-f0-9]{40}$/.test(source.revision),
-    'source must name the Swift repository and a full revision')
-  require(manifest?.schemaVersion === 1 && Array.isArray(manifest.examples) && manifest.examples.length,
-    'unsupported or empty manifest')
+  require(source.repo === 'libtmux/libtmux-swift' &&
+    /^[a-f0-9]{40}$/.test(source.revision), 'source must name the Swift repository and a full revision')
+  require(manifest?.schemaVersion === 1 &&
+    Array.isArray(manifest.examples) &&
+    manifest.examples.length, 'unsupported or empty manifest')
   require(manifest.packageFile === 'Examples/Standalone/Package.swift', 'unexpected consumer package')
   const codeFor = (path: string): string => {
     const code = read(path)
@@ -44,19 +45,21 @@ export function attachCompleteSwiftExamples(
   const names = new Set<string>()
   const targets = new Set<string>()
   for (const example of manifest.examples) {
-    require(/^Api[A-Z][A-Za-z0-9]*$/.test(example.name) && !names.has(example.name),
-      'invalid or duplicate program name')
+    require(/^Api[A-Z][A-Za-z0-9]*$/.test(example.name) &&
+      !names.has(example.name), 'invalid or duplicate program name')
     names.add(example.name)
-    require(example.file === `Examples/Sources/${example.name}/${example.name}.swift`,
-      'unexpected program path')
-    require(typeof example.title === 'string' && example.title.trim() &&
-      typeof example.description === 'string' && example.description.trim(), 'task description is missing')
-    require(Array.isArray(example.expectedOutput) && example.expectedOutput.length &&
+    require(example.file === `Examples/Sources/${example.name}/${example.name}.swift`, 'unexpected program path')
+    require(typeof example.title === 'string' &&
+      example.title.trim() &&
+      typeof example.description === 'string' &&
+      example.description.trim(), 'task description is missing')
+    require(Array.isArray(example.expectedOutput) &&
+      example.expectedOutput.length &&
       example.expectedOutput.every((line) => typeof line === 'string' && !/[\r\n]/.test(line)) &&
       example.expectedOutput.some((line) => line.trim()), 'expected output is missing')
-    require(Array.isArray(example.symbols) && example.symbols.length &&
-      example.symbols.every((id) => typeof id === 'string' && id && !/\s/.test(id)),
-      'API targets are missing')
+    require(Array.isArray(example.symbols) &&
+      example.symbols.length &&
+      example.symbols.every((id) => typeof id === 'string' && id && !/\s/.test(id)), 'API targets are missing')
     const programCode = codeFor(example.file)
     const blocks: NonNullable<DocBlock['examples']> = [
       {
@@ -72,13 +75,15 @@ export function attachCompleteSwiftExamples(
       },
       {
         lang: 'swift',
-        intro: 'Create a Sources directory and save this complete program as Sources/Example.swift. The `withTmuxServer` fixture owns a private tmux server and stops it after success or failure. Ordinary application code uses `Server` for its own socket; these examples use the fixture until their setup moves to ordinary server objects.',
+        intro:
+          'Create a Sources directory and save this complete program as Sources/Example.swift. The `withTmuxServer` fixture owns a private tmux server and stops it after success or failure. Ordinary application code uses `Server` for its own socket; these examples use the fixture until their setup moves to ordinary server objects.',
         sourceUrl: urlFor(example.file),
         code: programCode,
       },
       {
         lang: 'console',
-        intro: 'Build and run the saved program. An operation or cleanup error produces a failing exit status. Set LIBTMUX_TMUX_BIN to an absolute executable path to select a tmux version:',
+        intro:
+          'Build and run the saved program. An operation or cleanup error produces a failing exit status. Set LIBTMUX_TMUX_BIN to an absolute executable path to select a tmux version:',
         code: '$ swift run --jobs 5 ApiExample\n',
       },
       { lang: 'text', intro: 'Expected output:', code: `${example.expectedOutput.join('\n')}\n` },
diff --git a/packages/api-model/src/languages/symbolgraph.ts b/packages/api-model/src/languages/symbolgraph.ts
index 5cda217f5..793b12239 100644
--- a/packages/api-model/src/languages/symbolgraph.ts
+++ b/packages/api-model/src/languages/symbolgraph.ts
@@ -41,8 +41,7 @@ const PUBLIC_IDS: Record<string, Record<string, string>> = {
   LibTmux: {
     'Server.newSession(named:startDirectory:windowName:width:height:environment:shell:)':
       'Server.newSession(named:startDirectory:windowName:width:height:)',
-    'Server.newWindow(in:named:startDirectory:at:environment:shell:)':
-      'Server.newWindow(in:named:startDirectory:)',
+    'Server.newWindow(in:named:startDirectory:at:environment:shell:)': 'Server.newWindow(in:named:startDirectory:)',
     'Server.split(_:direction:size:startDirectory:environment:shell:)':
       'Server.split(_:direction:size:startDirectory:)',
     'Server.splitWindow(_:direction:size:startDirectory:environment:shell:)':
@@ -79,7 +78,11 @@ interface RawSymbol {
 }
 
 const fragmentText = (fragments: Fragment[] | undefined): string | undefined =>
-  fragments?.map((f) => f.spelling).join('').replace(/\s+/g, ' ').trim() || undefined
+  fragments
+    ?.map((f) => f.spelling)
+    .join('')
+    .replace(/\s+/g, ' ')
+    .trim() || undefined
 
 function modifiersOf(raw: RawSymbol): Modifier[] {
   const out: Modifier[] = []
@@ -152,10 +155,7 @@ function signatureOf(raw: RawSymbol): Signature | undefined {
  * protocol conformance.
  */
 /** Conformance display names in stable order across compiler graph emissions. */
-function conformedNames(
-  conformances: Map<string, Map<string, string>>,
-  usr: string,
-): string[] | undefined {
+function conformedNames(conformances: Map<string, Map<string, string>>, usr: string): string[] | undefined {
   const found = conformances.get(usr)
   return found?.size ? [...found.values()].sort() : undefined
 }
@@ -189,9 +189,11 @@ export function extractSymbolGraph(files: string[]): ApiSymbol[] {
     const selectors = new Set(graph.symbols.map((symbol) => symbol.pathComponents.join('.')))
 
     const titleOf = new Map(graph.symbols.map((s) => [s.identifier.precise, s.pathComponents]))
-    const origins = new Map((graph.relationships ?? [])
-      .filter((relationship) => relationship.kind === 'memberOf' && relationship.sourceOrigin)
-      .map((relationship) => [relationship.source, relationship.sourceOrigin!.displayName]))
+    const origins = new Map(
+      (graph.relationships ?? [])
+        .filter((relationship) => relationship.kind === 'memberOf' && relationship.sourceOrigin)
+        .map((relationship) => [relationship.source, relationship.sourceOrigin!.displayName]),
+    )
     for (const rel of graph.relationships ?? []) {
       if (rel.kind !== 'conformsTo') continue
       // A target outside this graph — every standard library protocol — is
@@ -204,9 +206,7 @@ export function extractSymbolGraph(files: string[]): ApiSymbol[] {
       // for a local symbol — the form `BUILTINS.swift` and the symbol index
       // are both keyed on.
       const name =
-        titleOf.get(rel.target)?.join('.') ??
-        rel.targetFallback?.replace(/^[A-Za-z_][A-Za-z0-9_]*\./, '') ??
-        rel.target
+        titleOf.get(rel.target)?.join('.') ?? rel.targetFallback?.replace(/^[A-Za-z_][A-Za-z0-9_]*\./, '') ?? rel.target
       // The graph lists some conformances twice — `Sendable` and
       // `SendableMetatype` arrive once directly and once through another
       // protocol. Two distinct USRs never share a name, so the USR is the
@@ -228,7 +228,10 @@ export function extractSymbolGraph(files: string[]): ApiSymbol[] {
       const previous = PUBLIC_IDS[graph.module?.name ?? '']?.[id]
       // An explicitly retained overload owns its URL; never merge distinct declarations.
       const publicId = previous && !selectors.has(previous) ? previous : id
-      const doc = raw.docComment?.lines.map((l) => l.text).join('\n').trim()
+      const doc = raw.docComment?.lines
+        .map((l) => l.text)
+        .join('\n')
+        .trim()
       const signature = signatureOf(raw)
       // Swift doc comments are Markdown, and this used to split on the first
       // blank line and keep the rest as one string — the same thing the spec
@@ -239,7 +242,8 @@ export function extractSymbolGraph(files: string[]): ApiSymbol[] {
       const source: ApiSymbol['source'] = {
         file: (raw.location?.uri ?? '').replace(/^file:\/\//, ''),
         ...(raw.location?.uri && raw.location.position?.line !== undefined
-          ? { line: raw.location.position.line + 1 } : {}),
+          ? { line: raw.location.position.line + 1 }
+          : {}),
       }
       const inheritedFrom = source.file ? undefined : origins.get(raw.identifier.precise)
 
diff --git a/packages/api-model/src/link.ts b/packages/api-model/src/link.ts
index 51d92f6b4..d3b411d99 100644
--- a/packages/api-model/src/link.ts
+++ b/packages/api-model/src/link.ts
@@ -67,15 +67,20 @@ const PY_INTERSPHINX: Record<string, string> = {
 const PY_DOCS = 'https://docs.python.org/3/'
 
 /** Syntax words in the native declarations rendered as complete signatures. */
-const SIGNATURE_KEYWORDS: Record<string, Set<string>> = Object.fromEntries(Object.entries({
-  kotlin: 'public private protected internal class interface object fun val var suspend override abstract open final data sealed enum inline reified crossinline noinline vararg in out where companion constructor operator infix tailrec external expect actual by',
-  scala: 'def extension val var class trait object type given using implicit inline transparent opaque override abstract final sealed case lazy private protected open infix export derives end',
-  fsharp: 'module namespace type member static abstract override interface inherit let rec mutable inline internal private public of with get set new val and when',
-  ts: 'readonly keyof typeof infer extends unique',
-  swift: 'any',
-  julia: 'where struct mutable abstract primitive type function end',
-  cxx: 'alignas alignof auto class concept const consteval constexpr constinit decltype default delete enum explicit extern final friend inline mutable namespace noexcept operator override register requires static struct template thread_local typedef typename union using virtual volatile',
-}).map(([port, words]) => [port, new Set(words.split(' '))]))
+const SIGNATURE_KEYWORDS: Record<string, Set<string>> = Object.fromEntries(
+  Object.entries({
+    kotlin:
+      'public private protected internal class interface object fun val var suspend override abstract open final data sealed enum inline reified crossinline noinline vararg in out where companion constructor operator infix tailrec external expect actual by',
+    scala:
+      'def extension val var class trait object type given using implicit inline transparent opaque override abstract final sealed case lazy private protected open infix export derives end',
+    fsharp:
+      'module namespace type member static abstract override interface inherit let rec mutable inline internal private public of with get set new val and when',
+    ts: 'readonly keyof typeof infer extends unique',
+    swift: 'any',
+    julia: 'where struct mutable abstract primitive type function end',
+    cxx: 'alignas alignof auto class concept const consteval constexpr constinit decltype default delete enum explicit extern final friend inline mutable namespace noexcept operator override register requires static struct template thread_local typedef typename union using virtual volatile',
+  }).map(([port, words]) => [port, new Set(words.split(' '))]),
+)
 
 /** Language help stays separate from links to API declarations. */
 export interface KeywordHelp {
@@ -88,14 +93,16 @@ const KEYWORD_HELP: Record<string, Record<string, KeywordHelp>> = {
   cxx: {
     nodiscard: {
       title: 'C++ nodiscard attribute',
-      description: 'Asks the compiler to warn when a result is discarded. An explicit cast to void acknowledges that the result is intentionally ignored.',
+      description:
+        'Asks the compiler to warn when a result is discarded. An explicit cast to void acknowledges that the result is intentionally ignored.',
       href: 'https://eel.is/c++draft/dcl.attr.nodiscard',
     },
   },
   kotlin: {
     suspend: {
       title: 'Kotlin suspending functions',
-      description: 'Allows a function to call suspending operations and pause without blocking a thread. It does not start a coroutine by itself.',
+      description:
+        'Allows a function to call suspending operations and pause without blocking a thread. It does not start a coroutine by itself.',
       href: builtinHref('kotlin', 'suspend')!,
     },
   },
@@ -133,17 +140,50 @@ interface TypeSpan {
  * on one page.
  */
 const PY_EXCEPTIONS = new Set([
-  'ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException',
-  'BlockingIOError', 'BrokenPipeError', 'BufferError', 'ChildProcessError',
-  'ConnectionError', 'EOFError', 'FileExistsError', 'FileNotFoundError',
-  'GeneratorExit', 'ImportError', 'IndentationError', 'IndexError',
-  'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt',
-  'LookupError', 'MemoryError', 'NameError', 'NotADirectoryError',
-  'NotImplementedError', 'OSError', 'OverflowError', 'PermissionError',
-  'ProcessLookupError', 'RecursionError', 'ReferenceError', 'RuntimeError',
-  'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SystemError',
-  'SystemExit', 'TimeoutError', 'TypeError', 'UnboundLocalError',
-  'UnicodeDecodeError', 'UnicodeError', 'ValueError', 'ZeroDivisionError',
+  'ArithmeticError',
+  'AssertionError',
+  'AttributeError',
+  'BaseException',
+  'BlockingIOError',
+  'BrokenPipeError',
+  'BufferError',
+  'ChildProcessError',
+  'ConnectionError',
+  'EOFError',
+  'FileExistsError',
+  'FileNotFoundError',
+  'GeneratorExit',
+  'ImportError',
+  'IndentationError',
+  'IndexError',
+  'InterruptedError',
+  'IsADirectoryError',
+  'KeyError',
+  'KeyboardInterrupt',
+  'LookupError',
+  'MemoryError',
+  'NameError',
+  'NotADirectoryError',
+  'NotImplementedError',
+  'OSError',
+  'OverflowError',
+  'PermissionError',
+  'ProcessLookupError',
+  'RecursionError',
+  'ReferenceError',
+  'RuntimeError',
+  'StopAsyncIteration',
+  'StopIteration',
+  'SyntaxError',
+  'SystemError',
+  'SystemExit',
+  'TimeoutError',
+  'TypeError',
+  'UnboundLocalError',
+  'UnicodeDecodeError',
+  'UnicodeError',
+  'ValueError',
+  'ZeroDivisionError',
 ])
 
 /**
@@ -156,10 +196,33 @@ const PY_EXCEPTIONS = new Set([
  * where intersphinx sends it.
  */
 const PY_STDLIB_MODULES = new Set([
-  'subprocess', 'dataclasses', 'pathlib', 'typing', 'logging', 'os', 'sys',
-  'shutil', 'enum', 'abc', 'collections', 'functools', 'itertools', 'json',
-  'time', 'datetime', 'warnings', 'contextlib', 'traceback', 're', 'io',
-  'threading', 'asyncio', 'unittest', 'tempfile', 'textwrap', 'random',
+  'subprocess',
+  'dataclasses',
+  'pathlib',
+  'typing',
+  'logging',
+  'os',
+  'sys',
+  'shutil',
+  'enum',
+  'abc',
+  'collections',
+  'functools',
+  'itertools',
+  'json',
+  'time',
+  'datetime',
+  'warnings',
+  'contextlib',
+  'traceback',
+  're',
+  'io',
+  'threading',
+  'asyncio',
+  'unittest',
+  'tempfile',
+  'textwrap',
+  'random',
 ])
 
 export interface LinkTarget {
@@ -242,10 +305,12 @@ export class SymbolIndex {
       aliases.push(s)
       this.byQualified.set(qualified, aliases)
 
-      const suffixes = new Set([pub, qualified].flatMap((name) => {
-        const parts = name.split('.')
-        return parts.slice(1).map((_, i) => parts.slice(i + 1).join('.'))
-      }))
+      const suffixes = new Set(
+        [pub, qualified].flatMap((name) => {
+          const parts = name.split('.')
+          return parts.slice(1).map((_, i) => parts.slice(i + 1).join('.'))
+        }),
+      )
       for (const suffix of suffixes) {
         const list = this.bySuffix.get(suffix) ?? []
         list.push(s)
@@ -298,22 +363,13 @@ export class SymbolIndex {
    * from Go, Java and Rust pages: 1,889 links that sent a reader of one
    * language to another language's manual.
    */
-  addInventory(
-    baseUrl: string,
-    entries: InventoryEntry[],
-    langs?: string[],
-    project?: string,
-  ): void {
+  addInventory(baseUrl: string, entries: InventoryEntry[], langs?: string[], project?: string): void {
     const byName = new Map<string, InventoryEntry>()
     for (const entry of entries) if (!byName.has(entry.name)) byName.set(entry.name, entry)
     this.external.push({ baseUrl: baseUrl.replace(/\/*$/, '/'), byName, langs, project })
   }
 
-  private pick(
-    candidates: ApiSymbol[] | undefined,
-    role: string,
-    context?: ApiSymbol,
-  ): ApiSymbol | undefined {
+  private pick(candidates: ApiSymbol[] | undefined, role: string, context?: ApiSymbol): ApiSymbol | undefined {
     if (!candidates?.length) return undefined
     const kinds = ROLE_KINDS[role] ?? []
     const filtered = kinds.length ? candidates.filter((c) => kinds.includes(c.kind)) : candidates
@@ -378,26 +434,41 @@ export class SymbolIndex {
     let clean = target.replace(/^[~.]/, '').replace(/\(\)$/, '')
     if (this.lang === 'powershell' && context) {
       const prefixed = /^[$-]/.test(clean)
-      const parameter = context.signatures.flatMap((signature) => signature.params)
-        .find((param) => param.name.toLowerCase() === (prefixed ? clean.slice(1) : clean).toLowerCase()
-          && (prefixed || param.binding?.common || ['WhatIf', 'Confirm'].includes(param.name)))
-      if (parameter) return { href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, parameter.name))}`, external: false }
+      const parameter = context.signatures
+        .flatMap((signature) => signature.params)
+        .find(
+          (param) =>
+            param.name.toLowerCase() === (prefixed ? clean.slice(1) : clean).toLowerCase() &&
+            (prefixed || param.binding?.common || ['WhatIf', 'Confirm'].includes(param.name)),
+        )
+      if (parameter)
+        return {
+          href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, parameter.name))}`,
+          external: false,
+        }
       // These are ErrorRecord identifiers, not exception classes. Native help
       // owns their meaning; keep the destination pinned to the extracted help.
       if (/^Tmux\.[A-Za-z_]\w*$/.test(clean) && context.doc?.body) {
         const notes = context.doc.body.split(/^### Notes\s*$/m)[1] ?? ''
         const documented = [...notes.matchAll(/\bTmux\.[A-Za-z_]\w*/g)].some((match) => match[0] === clean)
         const revision = context.source.extractedRevision ?? context.source.revision
-        const help = context.doc.examples?.map((example) => example.sourceUrl).find((href) =>
-          revision && href?.startsWith(`https://github.com/${context.source.repo}/blob/${revision}/docs/reference/`)
-            && href.endsWith(`/${context.name}.md`))
+        const help = context.doc.examples
+          ?.map((example) => example.sourceUrl)
+          .find(
+            (href) =>
+              revision &&
+              href?.startsWith(`https://github.com/${context.source.repo}/blob/${revision}/docs/reference/`) &&
+              href.endsWith(`/${context.name}.md`),
+          )
         if (documented && help) return { href: `${help}#notes`, external: true, project: 'PowerShell command help' }
       }
     }
-    if (this.lang === 'powershell' && role === 'variable') return {
-      href: 'https://learn.microsoft.com/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-7.4',
-      external: true, project: 'PowerShell variables',
-    }
+    if (this.lang === 'powershell' && role === 'variable')
+      return {
+        href: 'https://learn.microsoft.com/powershell/module/microsoft.powershell.core/about/about_variables?view=powershell-7.4',
+        external: true,
+        project: 'PowerShell variables',
+      }
     if (this.lang === 'scala') clean = clean.replace(/^_root_\./, '').replace(/#/g, '.')
     if (this.lang === 'fsharp' || this.lang === 'csharp') clean = clean.replace(/`\d+/g, '')
     const [importHead, ...tail] = clean.split('.')
@@ -405,12 +476,23 @@ export class SymbolIndex {
     if (imported) clean = [imported, ...tail].join('.')
     if (this.lang === 'scala') clean = clean.replace(/^_root_\./, '')
 
-    if (context && ['kotlin', 'scala', 'fsharp'].includes(this.lang ?? '') && !relative &&
-        context.signatures.some((sig) => sig.params.some((param) => param.name === clean))) {
-      return { href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, clean))}`, external: false }
+    if (
+      context &&
+      ['kotlin', 'scala', 'fsharp'].includes(this.lang ?? '') &&
+      !relative &&
+      context.signatures.some((sig) => sig.params.some((param) => param.name === clean))
+    ) {
+      return {
+        href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, clean))}`,
+        external: false,
+      }
     }
     if (context && ['kotlin', 'scala'].includes(this.lang ?? '')) {
-      for (let scope: ApiSymbol | undefined = context; scope; scope = scope.parent ? this.byDeclared.get(scope.parent) : undefined) {
+      for (
+        let scope: ApiSymbol | undefined = context;
+        scope;
+        scope = scope.parent ? this.byDeclared.get(scope.parent) : undefined
+      ) {
         if (scope.signatures.some((sig) => sig.typeParams?.includes(clean))) {
           return { href: this.hrefFor(scope), external: false, symbol: scope }
         }
@@ -489,10 +571,15 @@ export class SymbolIndex {
     // built-in table rather than after.
     for (const inv of this.external) {
       if (inv.langs && (!this.lang || !inv.langs.includes(this.lang))) continue
-      const hit = inv.byName.get(clean) ?? context?.namespaceImports?.toReversed()
-        .map((namespace) => inv.byName.get(`${namespace}.${clean}`)).find(Boolean) ??
+      const hit =
+        inv.byName.get(clean) ??
+        context?.namespaceImports
+          ?.toReversed()
+          .map((namespace) => inv.byName.get(`${namespace}.${clean}`))
+          .find(Boolean) ??
         (this.lang === 'julia' && !clean.includes('.')
-          ? inv.byName.get(`Core.${clean}`) ?? inv.byName.get(`Base.${clean}`) : undefined)
+          ? (inv.byName.get(`Core.${clean}`) ?? inv.byName.get(`Base.${clean}`))
+          : undefined)
       if (hit) return { href: inv.baseUrl + hit.uri, external: true, project: inv.project }
     }
 
@@ -554,9 +641,7 @@ export class SymbolIndex {
 
   linkDoc(spans: DocSpan[], context?: ApiSymbol): (DocSpan & { link?: LinkTarget })[] {
     return spans.map((span) =>
-      span.kind === 'ref'
-        ? { ...span, link: this.resolve(span.target, span.role, context) }
-        : span,
+      span.kind === 'ref' ? { ...span, link: this.resolve(span.target, span.role, context) } : span,
     )
   }
 
@@ -576,17 +661,24 @@ export class SymbolIndex {
     // `::` is part of a name, not punctuation between two. Splitting there
     // turned `std::vector` into `std` and `vector`, so neither half matched
     // anything and C++ annotations rendered almost entirely plain.
-    const identifier = this.lang === 'julia'
-      ? String.raw`[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*!?`
-      : this.lang === 'powershell' ? String.raw`(?:[A-Za-z_][A-Za-z0-9_.]*\\)?[A-Za-z_][A-Za-z0-9_.-]*`
-      : String.raw`[A-Za-z_][A-Za-z0-9_.]*(?:::[A-Za-z_][A-Za-z0-9_.]*)*`
-    const rawString = this.lang === 'cxx'
-      ? String.raw`(?:u8|u|U|L)?R"(?<rawDelimiter>[^ ()\\\t\v\f\r\n]{0,16})\([\s\S]*?\)\k<rawDelimiter>"|` : ''
+    const identifier =
+      this.lang === 'julia'
+        ? String.raw`[A-Za-z_][A-Za-z0-9_]*(?:\.[A-Za-z_][A-Za-z0-9_]*)*!?`
+        : this.lang === 'powershell'
+          ? String.raw`(?:[A-Za-z_][A-Za-z0-9_.]*\\)?[A-Za-z_][A-Za-z0-9_.-]*`
+          : String.raw`[A-Za-z_][A-Za-z0-9_.]*(?:::[A-Za-z_][A-Za-z0-9_.]*)*`
+    const rawString =
+      this.lang === 'cxx'
+        ? String.raw`(?:u8|u|U|L)?R"(?<rawDelimiter>[^ ()\\\t\v\f\r\n]{0,16})\([\s\S]*?\)\k<rawDelimiter>"|`
+        : ''
     const pattern = String.raw`(?<ident>${rawString}\/\*[\s\S]*?\*\/|\/\/[^\n]*|"(?:\\[\s\S]|[^"\\])*"|'(?:\\[\s\S]|[^'\\])*'|${identifier})|(?<other>[^A-Za-z_"'/]+|["'/])`
     // F# type variables start with an apostrophe but do not close like strings.
-    const re = new RegExp(this.lang === 'fsharp'
-      ? pattern.replace('(?<ident>', String.raw`(?<ident>'[A-Za-z_][A-Za-z0-9_]*(?![A-Za-z0-9_'])|`)
-      : pattern, 'g')
+    const re = new RegExp(
+      this.lang === 'fsharp'
+        ? pattern.replace('(?<ident>', String.raw`(?<ident>'[A-Za-z_][A-Za-z0-9_]*(?![A-Za-z0-9_'])|`)
+        : pattern,
+      'g',
+    )
     for (const m of annotation.matchAll(re)) {
       const whole = m[0]
       const { ident, other } = m.groups!
@@ -598,9 +690,12 @@ export class SymbolIndex {
         out.push({ text: ident })
         continue
       }
-      if (this.lang === 'cxx' && ident === 'nodiscard' &&
-          /\[\[\s*$/.test(annotation.slice(0, m.index)) &&
-          /^\s*(?:\]\]|\()/.test(annotation.slice(m.index! + ident.length))) {
+      if (
+        this.lang === 'cxx' &&
+        ident === 'nodiscard' &&
+        /\[\[\s*$/.test(annotation.slice(0, m.index)) &&
+        /^\s*(?:\]\]|\()/.test(annotation.slice(m.index! + ident.length))
+      ) {
         out.push({ text: ident, keyword: true, help: KEYWORD_HELP.cxx.nodiscard })
         continue
       }
@@ -611,9 +706,14 @@ export class SymbolIndex {
         }
         const parameter = annotation[m.index! - 1] === '-' && signature.params.find((param) => param.name === ident)
         if (parameter) {
-          out.push({ text: ident, declaration: true, link: {
-            href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, parameter.name))}`, external: false,
-          } })
+          out.push({
+            text: ident,
+            declaration: true,
+            link: {
+              href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, parameter.name))}`,
+              external: false,
+            },
+          })
           continue
         }
       }
@@ -622,10 +722,18 @@ export class SymbolIndex {
           out.push({ text: ident, declaration: true })
           continue
         }
-        if (signature.params.some((param) => param.name === ident) && /^\s*(?:[,)=]|\[)/.test(annotation.slice(m.index! + ident.length))) {
-          out.push({ text: ident, declaration: true, link: {
-            href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, ident))}`, external: false,
-          } })
+        if (
+          signature.params.some((param) => param.name === ident) &&
+          /^\s*(?:[,)=]|\[)/.test(annotation.slice(m.index! + ident.length))
+        ) {
+          out.push({
+            text: ident,
+            declaration: true,
+            link: {
+              href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, ident))}`,
+              external: false,
+            },
+          })
           continue
         }
       }
@@ -644,31 +752,53 @@ export class SymbolIndex {
         out.push({ text: ident, keyword: true, ...(help ? { help } : {}) })
         continue
       }
-      if (signature && context && (ident === context.name || ident.endsWith(`.${context.name}`)) &&
-          (/\b(?:def|fun|class|interface|trait|object|type|val|var|member|let)\s+$/.test(annotation.slice(0, m.index)) ||
-            (this.lang === 'julia' && annotation.slice(0, m.index).trim() === '' && /^[{(]/.test(annotation.slice(m.index! + ident.length))))) {
+      if (
+        signature &&
+        context &&
+        (ident === context.name || ident.endsWith(`.${context.name}`)) &&
+        (/\b(?:def|fun|class|interface|trait|object|type|val|var|member|let)\s+$/.test(annotation.slice(0, m.index)) ||
+          (this.lang === 'julia' &&
+            annotation.slice(0, m.index).trim() === '' &&
+            /^[{(]/.test(annotation.slice(m.index! + ident.length))))
+      ) {
         const receiver = ident.slice(0, -context.name.length).replace(/\.$/, '')
         if (receiver) out.push(...this.linkType(receiver, context), { text: '.' })
         out.push({ text: context.name, declaration: true })
         continue
       }
-      if (signature && (
-        ((signature.params.some((param) => param.name === ident) || signature.receiver?.name === ident) &&
+      if (
+        signature &&
+        (((signature.params.some((param) => param.name === ident) || signature.receiver?.name === ident) &&
           (/^\s*\??\s*:(?!:)/.test(annotation.slice(m.index! + ident.length)) ||
-            (this.lang === 'julia' && /(?:^|[(,;])\s*$/.test(annotation.slice(0, m.index)) &&
+            (this.lang === 'julia' &&
+              /(?:^|[(,;])\s*$/.test(annotation.slice(0, m.index)) &&
               /^\s*(?:::|[=,;)]|\.\.\.)/.test(annotation.slice(m.index! + ident.length))))) ||
-        signature.typeParams?.includes(ident)
-      )) {
+          signature.typeParams?.includes(ident))
+      ) {
         const parameter = this.lang === 'julia' && context && signature.params.some((param) => param.name === ident)
-        out.push({ text: ident, declaration: true, ...(parameter ? { link: {
-          href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, ident))}`, external: false,
-        } } : {}) })
+        out.push({
+          text: ident,
+          declaration: true,
+          ...(parameter
+            ? {
+                link: {
+                  href: `${this.hrefFor(context).split('#')[0]}#${encodeURIComponent(parameterId(context, ident))}`,
+                  external: false,
+                },
+              }
+            : {}),
+        })
         continue
       }
       // Object fields, callback parameters and tuple labels declare names;
       // the types after their colons still use ordinary reference resolution.
-      if (this.lang === 'ts' && /^\s*\??\s*:(?!:)/.test(annotation.slice(m.index! + ident.length)) &&
-          /(?:^|[{[(;,])(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*)*(?:readonly\s+)?(?:\.\.\.)?$/.test(annotation.slice(0, m.index))) {
+      if (
+        this.lang === 'ts' &&
+        /^\s*\??\s*:(?!:)/.test(annotation.slice(m.index! + ident.length)) &&
+        /(?:^|[{[(;,])(?:\s|\/\*[\s\S]*?\*\/|\/\/[^\n]*)*(?:readonly\s+)?(?:\.\.\.)?$/.test(
+          annotation.slice(0, m.index),
+        )
+      ) {
         out.push({ text: ident, declaration: true })
         continue
       }
diff --git a/packages/api-model/src/member-order.ts b/packages/api-model/src/member-order.ts
index eacce986b..346cbe626 100644
--- a/packages/api-model/src/member-order.ts
+++ b/packages/api-model/src/member-order.ts
@@ -71,9 +71,11 @@ export function memberSignals(
     // A member can realise several concepts; the broadest one speaks for it.
     for (const [variant, target] of [symbol, ...(concept.variants?.[port] ?? [])].entries()) {
       if (id.startsWith('list-') && !listingConcepts.has(target)) listingConcepts.set(target, id)
-      if (concept.parentObject) parentObjects.set(target, {
-        level: ['window', 'session', 'server'].indexOf(concept.parentObject), variant,
-      })
+      if (concept.parentObject)
+        parentObjects.set(target, {
+          level: ['window', 'session', 'server'].indexOf(concept.parentObject),
+          variant,
+        })
       if ((conceptPorts.get(target) ?? 0) < ports) {
         conceptPorts.set(target, ports)
         conceptIds.set(target, id)
@@ -89,7 +91,11 @@ export function memberSignals(
 const idOf = (s: ApiSymbol) => s.publicId ?? s.id
 
 /** Include explicit public re-exports without inferring access from private bases. */
-export function membersOf(model: ApiModelBase & { port?: string }, owner: ApiSymbol, signals = memberSignals(model.port ?? '')): ApiSymbol[] {
+export function membersOf(
+  model: ApiModelBase & { port?: string },
+  owner: ApiSymbol,
+  signals = memberSignals(model.port ?? ''),
+): ApiSymbol[] {
   const members = model.symbols.filter((symbol) => symbol.parent === owner.id)
   for (const id of signals.inheritedParents.get(idOf(owner)) ?? []) {
     const source = model.symbols.find((symbol) => idOf(symbol) === id)
@@ -165,7 +171,8 @@ export function compareMembers(signals: MemberSignals): (a: ApiSymbol, b: ApiSym
     rank(a) - rank(b) ||
     (memberTier(a, signals) === 'parent'
       ? signals.parentObjects.get(idOf(a))!.level - signals.parentObjects.get(idOf(b))!.level ||
-        signals.parentObjects.get(idOf(a))!.variant - signals.parentObjects.get(idOf(b))!.variant : 0) ||
+        signals.parentObjects.get(idOf(a))!.variant - signals.parentObjects.get(idOf(b))!.variant
+      : 0) ||
     Number(Boolean(a.inheritedFrom)) - Number(Boolean(b.inheritedFrom)) ||
     (signals.conceptPorts.get(idOf(b)) ?? 0) - (signals.conceptPorts.get(idOf(a)) ?? 0) ||
     (signals.conceptOrder.get(idOf(a)) ?? Infinity) - (signals.conceptOrder.get(idOf(b)) ?? Infinity) ||
diff --git a/packages/api-model/src/mentions.ts b/packages/api-model/src/mentions.ts
index 9ab2ee0c6..3a043ef16 100644
--- a/packages/api-model/src/mentions.ts
+++ b/packages/api-model/src/mentions.ts
@@ -47,10 +47,7 @@ function splitRow(line: string): string[] {
   return cells
 }
 
-export function tableMentions(
-  markdown: string,
-  portByLabel: Record<string, string>,
-): TableMention[] {
+export function tableMentions(markdown: string, portByLabel: Record<string, string>): TableMention[] {
   const out: TableMention[] = []
   const lines = markdown.split('\n')
 
@@ -87,14 +84,33 @@ export interface ProseMention {
 }
 
 const FENCE_PORT: Record<string, string> = {
-  python: 'py', py: 'py', typescript: 'ts', ts: 'ts', javascript: 'ts', js: 'ts',
-  rust: 'rs', rs: 'rs', go: 'go', java: 'java', csharp: 'csharp', cs: 'csharp',
-  cpp: 'cxx', 'c++': 'cxx', swift: 'swift',
-  powershell: 'powershell', pwsh: 'powershell', ps1: 'powershell', julia: 'julia',
+  python: 'py',
+  py: 'py',
+  typescript: 'ts',
+  ts: 'ts',
+  javascript: 'ts',
+  js: 'ts',
+  rust: 'rs',
+  rs: 'rs',
+  go: 'go',
+  java: 'java',
+  csharp: 'csharp',
+  cs: 'csharp',
+  cpp: 'cxx',
+  'c++': 'cxx',
+  swift: 'swift',
+  powershell: 'powershell',
+  pwsh: 'powershell',
+  ps1: 'powershell',
+  julia: 'julia',
 }
 
 /** Inline references in prose, including port sections, tables, and existing links. */
-export function proseMentions(markdown: string, portByLabel: Record<string, string>, portAt?: (offset: number) => string | undefined): ProseMention[] {
+export function proseMentions(
+  markdown: string,
+  portByLabel: Record<string, string>,
+  portAt?: (offset: number) => string | undefined,
+): ProseMention[] {
   const out: ProseMention[] = []
   const lines = markdown.split('\n')
   const context: { port?: string; before: string }[] = []
@@ -107,7 +123,10 @@ export function proseMentions(markdown: string, portByLabel: Record<string, stri
   let frontmatter = false
 
   for (const [i, line] of lines.entries()) {
-    if (i === 0 && line.trim() === '---') { frontmatter = true; continue }
+    if (i === 0 && line.trim() === '---') {
+      frontmatter = true
+      continue
+    }
     if (frontmatter) {
       if (line.trim() === '---') frontmatter = false
       continue
@@ -132,7 +151,10 @@ export function proseMentions(markdown: string, portByLabel: Record<string, stri
       paragraph = ''
       continue
     }
-    if (!line.trim()) { paragraph = ''; continue }
+    if (!line.trim()) {
+      paragraph = ''
+      continue
+    }
     const row = line.trim().startsWith('|') ? splitRow(line.trim()) : undefined
     const port = (row && portByLabel[row[0]]) ?? fencePort ?? sections.at(-1)?.port
     context[i] = { port, before: paragraph }
@@ -180,9 +202,15 @@ export function proseMentions(markdown: string, portByLabel: Record<string, stri
     const ctx = context[line - 1]
     if (!ctx) continue
     const before = ctx.before + beforeMatch.slice(beforeMatch.lastIndexOf('\n') + 1)
-    out.push({ text, port: portAt?.(span.start) ?? ctx.port, before, line,
-      start: span.start, end: span.end,
-      ...(span.href !== undefined ? { linked: true, href: span.href } : {}) })
+    out.push({
+      text,
+      port: portAt?.(span.start) ?? ctx.port,
+      before,
+      line,
+      start: span.start,
+      end: span.end,
+      ...(span.href !== undefined ? { linked: true, href: span.href } : {}),
+    })
   }
   return out
 }
diff --git a/packages/api-model/src/model.ts b/packages/api-model/src/model.ts
index 3a3667101..46a597bc5 100644
--- a/packages/api-model/src/model.ts
+++ b/packages/api-model/src/model.ts
@@ -14,7 +14,22 @@
  */
 
 /** Language libraries, by the slug the site uses. */
-export type PortSlug = 'py' | 'ruby' | 'lua' | 'ts' | 'rs' | 'go' | 'java' | 'csharp' | 'cxx' | 'swift' | 'kotlin' | 'scala' | 'fsharp' | 'powershell' | 'julia'
+export type PortSlug =
+  | 'py'
+  | 'ruby'
+  | 'lua'
+  | 'ts'
+  | 'rs'
+  | 'go'
+  | 'java'
+  | 'csharp'
+  | 'cxx'
+  | 'swift'
+  | 'kotlin'
+  | 'scala'
+  | 'fsharp'
+  | 'powershell'
+  | 'julia'
 
 export type ApiProduct = 'core' | 'workspace' | 'mcp'
 
diff --git a/packages/api-model/src/modules.ts b/packages/api-model/src/modules.ts
index 0474693ee..a53c18766 100644
--- a/packages/api-model/src/modules.ts
+++ b/packages/api-model/src/modules.ts
@@ -50,9 +50,5 @@ export function modulesIn(model: ApiModelBase): { name: string; symbols: ApiSymb
       name,
       symbols: symbols.sort((a, b) => a.kind.localeCompare(b.kind) || a.name.localeCompare(b.name)),
     }))
-    .sort(
-      (a, b) =>
-        a.name.split(/[.:]+/).length - b.name.split(/[.:]+/).length ||
-        a.name.localeCompare(b.name),
-    )
+    .sort((a, b) => a.name.split(/[.:]+/).length - b.name.split(/[.:]+/).length || a.name.localeCompare(b.name))
 }
diff --git a/packages/api-model/src/nav-config.ts b/packages/api-model/src/nav-config.ts
index fb784f67c..d775e2063 100644
--- a/packages/api-model/src/nav-config.ts
+++ b/packages/api-model/src/nav-config.ts
@@ -16,7 +16,6 @@ import type { Bucket, Match, PortNav } from './nav.ts'
  * that hang off them, then the machinery, then the auxiliary trees.
  */
 
-
 const nameRe = (re: string): Match => ({ kind: 'name', re })
 
 /**
@@ -44,7 +43,10 @@ const words = (...is: string[]): Match => ({
     {
       kind: 'anyOf',
       // `libtmux::pane::id` is a pane field whose own name says nothing.
-      of: [{ kind: 'word', is }, { kind: 'module', re: `(^|[.:/])(${is.join('|')})$` }],
+      of: [
+        { kind: 'word', is },
+        { kind: 'module', re: `(^|[.:/])(${is.join('|')})$` },
+      ],
     },
   ],
 })
@@ -83,7 +85,10 @@ const hierarchy = (re: string, pathRe: string, ...vocabulary: string[]): Match =
     nameRe(re),
     {
       kind: 'allOf',
-      of: [{ kind: 'path', re: pathRe }, { kind: 'not', of: nameRe(Object.values(ATTACHED_NAMES).join('|')) }],
+      of: [
+        { kind: 'path', re: pathRe },
+        { kind: 'not', of: nameRe(Object.values(ATTACHED_NAMES).join('|')) },
+      ],
     },
     words(...vocabulary),
   ],
@@ -175,7 +180,16 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
     match: {
       kind: 'allOf',
       of: [
-        nameOrPath('Test|Fixture|Mock|Fake', 'test|fixture|mock|junit', 'test', 'tests', 'testing', 'fixture', 'mock', 'fake'),
+        nameOrPath(
+          'Test|Fixture|Mock|Fake',
+          'test|fixture|mock|junit',
+          'test',
+          'tests',
+          'testing',
+          'fixture',
+          'mock',
+          'fake',
+        ),
         { kind: 'not', of: { kind: 'allOf', of: [FREE, nameRe('^logger$')] } },
       ],
     },
@@ -226,9 +240,10 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
       of: [
         {
           kind: 'anyOf',
-          of: ['Kind', 'Mode', 'Style', 'Action', 'Options', 'Result', 'Event'].map(
-            (suffix): Match => ({ kind: 'name', suffix }),
-          ),
+          of: ['Kind', 'Mode', 'Style', 'Action', 'Options', 'Result', 'Event'].map((suffix): Match => ({
+            kind: 'name',
+            suffix,
+          })),
         },
         // Suffixes that name a type. `normalizePlanWorkspaceOptions` is a
         // function that takes one.
@@ -247,7 +262,11 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
         nameOrPath(
           'Control|Notification|Subscribe',
           '(^|/)control',
-          'control', 'notification', 'notifications', 'subscribe', 'subscription',
+          'control',
+          'notification',
+          'notifications',
+          'subscribe',
+          'subscription',
         ),
         freePath('(^|/)notification\\.hpp$'),
       ],
@@ -287,7 +306,16 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
         nameOrPath(
           'Query|Filter|Predicate|Matcher|Criteria|Operator|Quantifier|Expr|Node$|Field$|^(Server|Session|Window|Pane|Client)Fields$',
           '(^|/)quer(y|ies)[./]|(^|/)matching|(^|/)filter',
-          'query', 'queries', 'filter', 'predicate', 'matcher', 'criteria', 'where', 'relation', 'field', 'fields',
+          'query',
+          'queries',
+          'filter',
+          'predicate',
+          'matcher',
+          'criteria',
+          'where',
+          'relation',
+          'field',
+          'fields',
         ),
         // The query language's own files, whose helpers are `any_of`,
         // `children_of` and `WhereOf`.
@@ -321,7 +349,13 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
         // TypeScript's `paneStartDirectory` reads a workspace file's pane.
         {
           kind: 'allOf',
-          of: [FREE, { kind: 'path', re: '(^|/)(packages/|crates/tmux-)?workspace/|libtmux_consumers/|(^|/)packages/LibTmuxWorkspace/' }],
+          of: [
+            FREE,
+            {
+              kind: 'path',
+              re: '(^|/)(packages/|crates/tmux-)?workspace/|libtmux_consumers/|(^|/)packages/LibTmuxWorkspace/',
+            },
+          ],
         },
       ],
     },
@@ -343,14 +377,23 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
     label: 'Keys and bindings',
     match: nameOrPath(ATTACHED_NAMES.keys, '(^|/)(keys?|binding)', 'key', 'keys', 'binding'),
   },
-  { id: 'buffers', label: 'Buffers', match: nameOrPath(ATTACHED_NAMES.buffers, '(^|/)buffers?[./]', 'buffer', 'buffers') },
+  {
+    id: 'buffers',
+    label: 'Buffers',
+    match: nameOrPath(ATTACHED_NAMES.buffers, '(^|/)buffers?[./]', 'buffer', 'buffers'),
+  },
   {
     id: 'layout',
     label: 'Layout and geometry',
     match: nameOrPath(
       ATTACHED_NAMES.layout,
       '(^|/)layouts?[./]',
-      'layout', 'split', 'resize', 'direction', 'dimension', 'rotation',
+      'layout',
+      'split',
+      'resize',
+      'direction',
+      'dimension',
+      'rotation',
     ),
   },
   {
@@ -366,7 +409,12 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
   {
     id: 'version',
     label: 'Versions',
-    match: nameOrPath(ATTACHED_NAMES.version, '(^|/)versions?[./]|(^|/)__about__\\.|(^|/)build_info\\.go$', 'version', 'release'),
+    match: nameOrPath(
+      ATTACHED_NAMES.version,
+      '(^|/)versions?[./]|(^|/)__about__\\.|(^|/)build_info\\.go$',
+      'version',
+      'release',
+    ),
   },
   {
     id: 'commands',
@@ -374,7 +422,14 @@ const CHAIN: { id: string; label: string; match: Match }[] = [
     match: nameOrPath(
       ATTACHED_NAMES.commands,
       '(^|/)(commands?|dispatch|transport|connection|process)|(^|/)libtmux/endpoint\\.rb$',
-      'command', 'commands', 'cmd', 'dispatch', 'transport', 'connection', 'process', 'engine',
+      'command',
+      'commands',
+      'cmd',
+      'dispatch',
+      'transport',
+      'connection',
+      'process',
+      'engine',
     ),
   },
 ]
@@ -433,9 +488,7 @@ const COLLAPSED = new Set(['requests', 'errors', 'constants', 'mcp', 'testing',
 /** "Matches mine, and none of the rules that outrank mine." */
 function disjoint(index: number): Match {
   const above = CHAIN.slice(0, index).map((c): Match => ({ kind: 'not', of: c.match }))
-  return above.length === 0
-    ? CHAIN[index]!.match
-    : { kind: 'allOf', of: [CHAIN[index]!.match, ...above] }
+  return above.length === 0 ? CHAIN[index]!.match : { kind: 'allOf', of: [CHAIN[index]!.match, ...above] }
 }
 
 /**
@@ -574,19 +627,23 @@ const OVERRIDES: Record<string, { unsettled?: Record<string, string> }> = {
   julia: {
     unsettled: {
       LibTmux: 'package module spanning all task buckets; its exported declarations have their own placements',
-      'LibTmux.EntityRef': 'target identity shared by every entity, owned by none; concrete references sit with their entity',
+      'LibTmux.EntityRef':
+        'target identity shared by every entity, owned by none; concrete references sit with their entity',
       'LibTmux.TmuxID': 'typed tmux IDs shared by every entity; concrete ID aliases sit with their entity',
       'LibTmux.entitykey': 'identity keys shared by references, captured entities, window links and pane occurrences',
       'LibTmux.Base.==': 'one equality extension page for server identities and several entity ID and reference types',
       'LibTmux.Base.hash': 'one hashing extension page for server identities and several entity ID and reference types',
-      'LibTmux.Base.isequal': 'one equality extension page for server identities and several entity ID and reference types',
+      'LibTmux.Base.isequal':
+        'one equality extension page for server identities and several entity ID and reference types',
       'LibTmux.Base.string': 'one string conversion extension page for several entity ID types',
-      'LibTmux.Base.show': 'one display extension page shared by IDs, servers, snapshots, control connections and observation streams',
+      'LibTmux.Base.show':
+        'one display extension page shared by IDs, servers, snapshots, control connections and observation streams',
     },
   },
   lua: {
     unsettled: {
-      'libtmux.Configurable': 'options and hooks shared by sessions, windows and panes; the concrete handle is the subclass',
+      'libtmux.Configurable':
+        'options and hooks shared by sessions, windows and panes; the concrete handle is the subclass',
       'libtmux.Creation': 'creation receipt shared by several tmux objects',
       'libtmux.Entity': 'base of the tmux entity hierarchy; the concrete entity is the subclass',
       'libtmux.LinkDestination': 'window-link target shared by sessions and windows',
@@ -606,8 +663,7 @@ const OVERRIDES: Record<string, { unsettled?: Record<string, string> }> = {
   py: {
     unsettled: {
       'libtmux._vendor._structures.InfinityType': 'vendored from packaging; version comparison, not tmux',
-      'libtmux._vendor._structures.NegativeInfinityType':
-        'vendored from packaging; version comparison, not tmux',
+      'libtmux._vendor._structures.NegativeInfinityType': 'vendored from packaging; version comparison, not tmux',
       'libtmux.constants._DefaultOptionScope': 'private sentinel for an option scope left unset',
       'libtmux.neo.Obj': 'base of the neo object layer; the tmux entity is the subclass',
       'libtmux.__all__': 'the package export list, not an API of its own',
@@ -649,8 +705,7 @@ const OVERRIDES: Record<string, { unsettled?: Record<string, string> }> = {
       'config.Entry': 'workspace config entry; Workspaces covers the plan, not the file it parses',
       'target.EndpointInputs': 'socket endpoint resolution; sits below Server rather than inside it',
       'target.ResolvedEndpoint': 'socket endpoint resolution; sits below Server rather than inside it',
-      'target.ResolvedSocketSelector':
-        'socket endpoint resolution; sits below Server rather than inside it',
+      'target.ResolvedSocketSelector': 'socket endpoint resolution; sits below Server rather than inside it',
       'target.OsString': 'extractor leak: std::ffi::OsString is not declared by this crate',
       'src.DesignNotes': 'extractor leak: a doc-only module surfaced as a struct',
       'src.Findings': 'extractor leak: a doc-only module surfaced as a struct',
@@ -681,10 +736,8 @@ const OVERRIDES: Record<string, { unsettled?: Record<string, string> }> = {
       'io.github.libtmux.FindSpec.FindSpec': 'target addressing; used by every entity, owned by none',
       'io.github.libtmux.TargetIds.TargetIds': 'target addressing; used by every entity, owned by none',
       'io.github.libtmux.batch.Batch.Batch': 'batch execution; no tmux object of its own',
-      'io.github.libtmux.batch.OperationOutcome.OperationOutcome':
-        'batch execution; no tmux object of its own',
-      'io.github.libtmux.jackson.LibTmuxModels.LibTmuxModels':
-        'Jackson serialisation registration, not tmux API',
+      'io.github.libtmux.batch.OperationOutcome.OperationOutcome': 'batch execution; no tmux object of its own',
+      'io.github.libtmux.jackson.LibTmuxModels.LibTmuxModels': 'Jackson serialisation registration, not tmux API',
     },
   },
   csharp: {
@@ -716,8 +769,7 @@ const OVERRIDES: Record<string, { unsettled?: Record<string, string> }> = {
       OutputWait: 'wait and watch plumbing',
       SubscriptionChange: 'wait and watch plumbing',
       RegexPattern: 'regex translation for query matching; below Queries rather than inside it',
-      RegexUnsupportedConstruct:
-        'regex translation for query matching; below Queries rather than inside it',
+      RegexUnsupportedConstruct: 'regex translation for query matching; below Queries rather than inside it',
     },
   },
 }
@@ -747,29 +799,51 @@ const LANGUAGE_PLACEMENTS: Record<string, Record<string, string[]>> = {
     snapshots: ['hascoverage', 'snapshotof', 'Base.getproperty', 'Base.propertynames'].map((name) => `LibTmux.${name}`),
     // Generic Base methods here belong only to ObservationStream. Keep its
     // pane and format event payloads in their existing domain buckets.
-    control: ['ObservationCursor', 'ObservationStream', 'observation_cursor', 'observe_output',
-      'Base.IteratorSize', 'Base.eltype', 'Base.iterate', 'Base.take!'].map((name) => `LibTmux.${name}`),
-    pane: ['paneoccurrences', 'occurrencekey', 'paste_bytes', 'paste_text', 'TextDecoder', 'decode!', 'decode_text']
-      .map((name) => `LibTmux.${name}`),
+    control: [
+      'ObservationCursor',
+      'ObservationStream',
+      'observation_cursor',
+      'observe_output',
+      'Base.IteratorSize',
+      'Base.eltype',
+      'Base.iterate',
+      'Base.take!',
+    ].map((name) => `LibTmux.${name}`),
+    pane: [
+      'paneoccurrences',
+      'occurrencekey',
+      'paste_bytes',
+      'paste_text',
+      'TextDecoder',
+      'decode!',
+      'decode_text',
+    ].map((name) => `LibTmux.${name}`),
     window: ['LibTmux.windowlinks'],
     commands: ['run_batch', 'run_group'].map((name) => `LibTmux.${name}`),
     workspace: ['LibTmuxWorkspace.ConfigLimits'],
     // Native subtyping establishes these exceptions despite their names.
     errors: ['CrossServerReference', 'StaleReference', 'ObservationLost', 'UnsupportedCriterion', 'Base.showerror']
-      .map((name) => `LibTmux.${name}`).concat('LibTmuxWorkspace.Base.showerror'),
+      .map((name) => `LibTmux.${name}`)
+      .concat('LibTmuxWorkspace.Base.showerror'),
   },
   java: {
     commands: ['MessageLog', 'PrintedText', 'Prompt', 'Shell'].map((name) => `io.github.libtmux.${name}.${name}`),
     server: ['io.github.libtmux.IncarnationFence.IncarnationFence'],
   },
   kotlin: {
-    commands: ['Batch', 'ExecutionPolicy', 'MessageLog', 'Prompt', 'Shell', 'retryIfSafe'].map((name) => `io.github.libtmux.kotlin.${name}`),
+    commands: ['Batch', 'ExecutionPolicy', 'MessageLog', 'Prompt', 'Shell', 'retryIfSafe'].map(
+      (name) => `io.github.libtmux.kotlin.${name}`,
+    ),
     server: ['io.github.libtmux.kotlin.LibTmuxDsl'],
     control: ['io.github.libtmux.Channel.await', 'io.github.libtmux.Channel.awaitReservingCapacity'],
   },
   scala: {
-    snapshots: ['io.github.libtmux.scaladsl.live.LiveView', 'io.github.libtmux.scaladsl.streaming.Observation',
-      'io.github.libtmux.scaladsl.cats.Instances', 'io.github.libtmux.scaladsl.cats.Observation'],
+    snapshots: [
+      'io.github.libtmux.scaladsl.live.LiveView',
+      'io.github.libtmux.scaladsl.streaming.Observation',
+      'io.github.libtmux.scaladsl.cats.Instances',
+      'io.github.libtmux.scaladsl.cats.Observation',
+    ],
     commands: ['Batch', 'Shell', 'MessageLog', 'Prompt'].map((name) => `io.github.libtmux.scaladsl.cats.${name}`),
     control: ['io.github.libtmux.scaladsl.cats.Channel', 'io.github.libtmux.scaladsl.ox.Flows'],
   },
@@ -785,33 +859,146 @@ const LANGUAGE_PLACEMENTS: Record<string, Record<string, string[]>> = {
 
 /** Free functions and cmdlets need the same discovery-first order as object members. */
 const LANGUAGE_ORDER: Record<string, Record<string, string[]>> = {
-  julia: Object.fromEntries(Object.entries({
-    server: ['Server', 'open_server', 'with_server', 'from_env', 'OwnedServer', 'ServerIdentity'],
-    session: ['sessions', 'session', 'new_session', 'rename_session', 'kill_session', 'SessionRef', 'SessionID', 'SessionWhere'],
-    window: ['windows', 'window', 'new_window', 'split_window', 'select_window', 'rename_window', 'resize_window', 'link_window', 'unlink_window', 'move_window', 'swap_window', 'respawn_window', 'kill_window', 'WindowRef', 'WindowLinkRef', 'WindowID', 'WindowLink', 'WindowWhere', 'WindowLinkWhere'],
-    pane: ['panes', 'select_pane', 'resize_pane', 'move_pane', 'swap_pane', 'respawn_pane', 'kill_pane', 'PaneRef', 'PaneID', 'PaneOccurrence', 'PaneOutput', 'PaneWhere'],
-    client: ['clients', 'switch_client', 'detach_client', 'ClientRef', 'ClientID', 'ClientWhere'],
-    hooks: ['get_hook', 'set_hook', 'unset_hook', 'HookCommand'],
-    'options-functions': ['get_option', 'set_option', 'unset_option'],
-    buffers: ['load_buffer', 'save_buffer', 'delete_buffer', 'BufferRef', 'BufferID'],
-    environment: ['get_environment', 'set_environment', 'unset_environment', 'remove_environment', 'EnvironmentValue'],
-    snapshots: ['snapshot', 'Snapshot', 'capture_pane', 'capture_bytes', 'SessionSnapshot', 'WindowSnapshot', 'PaneSnapshot', 'ClientSnapshot', 'InconsistentSnapshot'],
-    control: ['open_control', 'ControlConnection', 'notifications', 'capture_baseline', 'subscribe_format', 'control_signal', 'Base.isopen', 'Base.wait', 'Base.notify', 'ObservationBaseline', 'ControlSignal'],
-    commands: ['TmuxCommand', 'run_command', 'CancellationToken', 'cancel!', 'iscancelled', 'on_cancel', 'Base.close', 'CancellationSubscription', 'RequestCancelled', 'DeadlineExceeded', 'OutputLimitExceeded', 'TmuxNotFound'],
-  }).map(([bucket, names]) => [bucket, names.map((name) => `LibTmux.${name}`)])),
-  powershell: Object.fromEntries(Object.entries({
-    server: ['New-TmuxServer', 'Get-TmuxServer', 'Connect-TmuxServer'],
-    session: ['Get-TmuxSession', 'Select-TmuxSession', 'New-TmuxSession', 'Enter-TmuxSession', 'Remove-TmuxSession'],
-    window: ['Get-TmuxWindow', 'Select-TmuxWindow', 'New-TmuxWindow', 'New-TmuxWindowLink', 'Set-TmuxWindowSize', 'Move-TmuxWindow', 'Remove-TmuxWindowLink', 'Remove-TmuxWindow'],
-    pane: ['Get-TmuxPane', 'Select-TmuxPane', 'Get-TmuxPaneContent', 'Split-TmuxPane', 'Send-TmuxText', 'Invoke-TmuxPaneCommand', 'Wait-TmuxPaneText', 'Update-TmuxPane', 'Set-TmuxPaneSize', 'Remove-TmuxPane'],
-    client: ['Get-TmuxClient', 'Get-TmuxClientAttachment', 'Update-TmuxClient'],
-    hooks: ['Get-TmuxHook', 'Set-TmuxHook', 'Invoke-TmuxHook', 'Remove-TmuxHook'],
-    'options-functions': ['Get-TmuxOption', 'Set-TmuxOption', 'Remove-TmuxOption'],
-    environment: ['Get-TmuxEnvironment', 'Set-TmuxEnvironment', 'Remove-TmuxEnvironment'],
-    commands: ['New-TmuxCommand', 'Invoke-TmuxCommand'],
-    control: ['Connect-TmuxControl', 'Watch-TmuxEvent', 'Wait-TmuxChannel', 'Invoke-TmuxControlCommand', 'Disconnect-TmuxControl'],
-    queries: ['New-TmuxQuery', 'Get-TmuxQueryPlan', 'Invoke-TmuxQuery', 'ConvertTo-TmuxQueryJson'],
-  }).map(([bucket, names]) => [bucket, names.map((name) => `LibTmux\\${name}`)])),
+  julia: Object.fromEntries(
+    Object.entries({
+      server: ['Server', 'open_server', 'with_server', 'from_env', 'OwnedServer', 'ServerIdentity'],
+      session: [
+        'sessions',
+        'session',
+        'new_session',
+        'rename_session',
+        'kill_session',
+        'SessionRef',
+        'SessionID',
+        'SessionWhere',
+      ],
+      window: [
+        'windows',
+        'window',
+        'new_window',
+        'split_window',
+        'select_window',
+        'rename_window',
+        'resize_window',
+        'link_window',
+        'unlink_window',
+        'move_window',
+        'swap_window',
+        'respawn_window',
+        'kill_window',
+        'WindowRef',
+        'WindowLinkRef',
+        'WindowID',
+        'WindowLink',
+        'WindowWhere',
+        'WindowLinkWhere',
+      ],
+      pane: [
+        'panes',
+        'select_pane',
+        'resize_pane',
+        'move_pane',
+        'swap_pane',
+        'respawn_pane',
+        'kill_pane',
+        'PaneRef',
+        'PaneID',
+        'PaneOccurrence',
+        'PaneOutput',
+        'PaneWhere',
+      ],
+      client: ['clients', 'switch_client', 'detach_client', 'ClientRef', 'ClientID', 'ClientWhere'],
+      hooks: ['get_hook', 'set_hook', 'unset_hook', 'HookCommand'],
+      'options-functions': ['get_option', 'set_option', 'unset_option'],
+      buffers: ['load_buffer', 'save_buffer', 'delete_buffer', 'BufferRef', 'BufferID'],
+      environment: [
+        'get_environment',
+        'set_environment',
+        'unset_environment',
+        'remove_environment',
+        'EnvironmentValue',
+      ],
+      snapshots: [
+        'snapshot',
+        'Snapshot',
+        'capture_pane',
+        'capture_bytes',
+        'SessionSnapshot',
+        'WindowSnapshot',
+        'PaneSnapshot',
+        'ClientSnapshot',
+        'InconsistentSnapshot',
+      ],
+      control: [
+        'open_control',
+        'ControlConnection',
+        'notifications',
+        'capture_baseline',
+        'subscribe_format',
+        'control_signal',
+        'Base.isopen',
+        'Base.wait',
+        'Base.notify',
+        'ObservationBaseline',
+        'ControlSignal',
+      ],
+      commands: [
+        'TmuxCommand',
+        'run_command',
+        'CancellationToken',
+        'cancel!',
+        'iscancelled',
+        'on_cancel',
+        'Base.close',
+        'CancellationSubscription',
+        'RequestCancelled',
+        'DeadlineExceeded',
+        'OutputLimitExceeded',
+        'TmuxNotFound',
+      ],
+    }).map(([bucket, names]) => [bucket, names.map((name) => `LibTmux.${name}`)]),
+  ),
+  powershell: Object.fromEntries(
+    Object.entries({
+      server: ['New-TmuxServer', 'Get-TmuxServer', 'Connect-TmuxServer'],
+      session: ['Get-TmuxSession', 'Select-TmuxSession', 'New-TmuxSession', 'Enter-TmuxSession', 'Remove-TmuxSession'],
+      window: [
+        'Get-TmuxWindow',
+        'Select-TmuxWindow',
+        'New-TmuxWindow',
+        'New-TmuxWindowLink',
+        'Set-TmuxWindowSize',
+        'Move-TmuxWindow',
+        'Remove-TmuxWindowLink',
+        'Remove-TmuxWindow',
+      ],
+      pane: [
+        'Get-TmuxPane',
+        'Select-TmuxPane',
+        'Get-TmuxPaneContent',
+        'Split-TmuxPane',
+        'Send-TmuxText',
+        'Invoke-TmuxPaneCommand',
+        'Wait-TmuxPaneText',
+        'Update-TmuxPane',
+        'Set-TmuxPaneSize',
+        'Remove-TmuxPane',
+      ],
+      client: ['Get-TmuxClient', 'Get-TmuxClientAttachment', 'Update-TmuxClient'],
+      hooks: ['Get-TmuxHook', 'Set-TmuxHook', 'Invoke-TmuxHook', 'Remove-TmuxHook'],
+      'options-functions': ['Get-TmuxOption', 'Set-TmuxOption', 'Remove-TmuxOption'],
+      environment: ['Get-TmuxEnvironment', 'Set-TmuxEnvironment', 'Remove-TmuxEnvironment'],
+      commands: ['New-TmuxCommand', 'Invoke-TmuxCommand'],
+      control: [
+        'Connect-TmuxControl',
+        'Watch-TmuxEvent',
+        'Wait-TmuxChannel',
+        'Invoke-TmuxControlCommand',
+        'Disconnect-TmuxControl',
+      ],
+      queries: ['New-TmuxQuery', 'Get-TmuxQueryPlan', 'Invoke-TmuxQuery', 'ConvertTo-TmuxQueryJson'],
+    }).map(([bucket, names]) => [bucket, names.map((name) => `LibTmux\\${name}`)]),
+  ),
 }
 
 /** Julia reads collections from an explicit snapshot, not from Server methods. */
@@ -823,8 +1010,7 @@ const LANGUAGE_SHORTCUTS: Record<string, Record<string, string[]>> = {
 function languageBucket(bucket: Bucket, port: string, root = bucket.id): Bucket {
   const placements = LANGUAGE_PLACEMENTS[port] ?? {}
   const ids = bucket.id === root ? placements[root] : undefined
-  const elsewhere = Object.entries(placements)
-    .flatMap(([id, symbols]) => id === root ? [] : symbols)
+  const elsewhere = Object.entries(placements).flatMap(([id, symbols]) => (id === root ? [] : symbols))
   const match: Match = elsewhere.length
     ? { kind: 'allOf', of: [bucket.match, { kind: 'not', of: { kind: 'id', is: elsewhere } }] }
     : bucket.match
@@ -838,7 +1024,23 @@ function languageBucket(bucket: Bucket, port: string, root = bucket.id): Bucket
 }
 
 export const NAV: Record<string, PortNav> = Object.fromEntries(
-  ['powershell', 'julia', 'py', 'ruby', 'lua', 'ts', 'rs', 'go', 'java', 'kotlin', 'scala', 'fsharp', 'csharp', 'cxx', 'swift'].map((port) => [
+  [
+    'powershell',
+    'julia',
+    'py',
+    'ruby',
+    'lua',
+    'ts',
+    'rs',
+    'go',
+    'java',
+    'kotlin',
+    'scala',
+    'fsharp',
+    'csharp',
+    'cxx',
+    'swift',
+  ].map((port) => [
     port,
     {
       port,
diff --git a/packages/api-model/src/nav-sidecar.ts b/packages/api-model/src/nav-sidecar.ts
index 3cb42f7fe..5af20b076 100644
--- a/packages/api-model/src/nav-sidecar.ts
+++ b/packages/api-model/src/nav-sidecar.ts
@@ -49,7 +49,9 @@ export function navSidecarFor(scope: string, model: ApiModelBase, nav: NavConfig
   // type alias has a page, and a sidebar that placed only types gave 1,282 of
   // those pages no row.
   const moduleIds = new Set(model.symbols.filter((symbol) => symbol.kind === 'module').map((symbol) => symbol.id))
-  const topLevel = model.symbols.filter((s) => !s.parent || (['powershell', 'julia'].includes(scope) && moduleIds.has(s.parent)))
+  const topLevel = model.symbols.filter(
+    (s) => !s.parent || (['powershell', 'julia'].includes(scope) && moduleIds.has(s.parent)),
+  )
   const conceptIds = Object.fromEntries(
     Object.entries(CONCEPTS)
       .map(([k, c]) => [k, c.symbols[scope]] as const)
@@ -74,7 +76,8 @@ export function navSidecarFor(scope: string, model: ApiModelBase, nav: NavConfig
   const entries = (ids: string[], order: string[] = []) => {
     const symbols = [...new Set(ids)].map((id) => byId.get(id)).filter((sym): sym is ApiSymbol => sym !== undefined)
     const ranks = new Map([...new Set(order)].map((id, rank) => [id, rank]))
-    const ordered = symbols.filter((sym) => ranks.has(sym.publicId ?? sym.id))
+    const ordered = symbols
+      .filter((sym) => ranks.has(sym.publicId ?? sym.id))
       .sort((a, b) => ranks.get(a.publicId ?? a.id)! - ranks.get(b.publicId ?? b.id)!)
     const remaining = symbols.filter((sym) => !ranks.has(sym.publicId ?? sym.id))
     const free = remaining
@@ -93,8 +96,8 @@ export function navSidecarFor(scope: string, model: ApiModelBase, nav: NavConfig
       if (shortcuts.length !== new Set(b.shortcuts ?? []).size) {
         throw new Error(`${scope}: ${b.id} contains an unknown navigation shortcut`)
       }
-      const target = b.order && entries(compiled.assignments[b.id] ?? [], b.order)
-        .find((entry) => b.order!.includes(entry.id))
+      const target =
+        b.order && entries(compiled.assignments[b.id] ?? [], b.order).find((entry) => b.order!.includes(entry.id))
       return {
         id: b.id,
         label: b.label,
diff --git a/packages/api-model/src/nav.ts b/packages/api-model/src/nav.ts
index 4adbea80a..5f4c69948 100644
--- a/packages/api-model/src/nav.ts
+++ b/packages/api-model/src/nav.ts
@@ -301,7 +301,9 @@ export function compileNav(nav: PortNav, symbols: ApiSymbol[], ctx: MatchContext
     if (id in unsettled) diagnostics.staleUnsettled.push(id)
     // A parent and its own child both claiming is nesting working, not
     // ambiguity; two unrelated buckets claiming is the CapturePaneRequest case.
-    const roots = claimed.filter((n) => !claimed.some((o) => o !== n && n.path.join('/').startsWith(`${o.path.join('/')}/`)))
+    const roots = claimed.filter(
+      (n) => !claimed.some((o) => o !== n && n.path.join('/').startsWith(`${o.path.join('/')}/`)),
+    )
     if (roots.length > 1) {
       diagnostics.ambiguous.push({ id, buckets: roots.map((r) => r.bucket.id) })
     }
diff --git a/packages/api-model/src/parent-inventory.ts b/packages/api-model/src/parent-inventory.ts
index 90e3b639d..14ef18169 100644
--- a/packages/api-model/src/parent-inventory.ts
+++ b/packages/api-model/src/parent-inventory.ts
@@ -26,4 +26,3 @@ export function parentInventory(model: ApiModel, hrefFor: (symbol: ApiSymbol) =>
     return best.length === 1 ? [best[0].entry] : []
   })
 }
-
diff --git a/packages/api-model/src/parser.ts b/packages/api-model/src/parser.ts
index 753537f43..9a00a33f0 100644
--- a/packages/api-model/src/parser.ts
+++ b/packages/api-model/src/parser.ts
@@ -43,9 +43,11 @@ export async function loadLanguage(name: GrammarName): Promise<Language> {
   const hit = cache.get(name)
   if (hit) return hit
   // The older bundle predates Scala 3 opaque types, givens, and extensions.
-  const wasm = require.resolve(name === 'scala'
-    ? 'tree-sitter-scala/tree-sitter-scala.wasm'
-    : `tree-sitter-wasms/out/tree-sitter-${GRAMMAR[name]}.wasm`)
+  const wasm = require.resolve(
+    name === 'scala'
+      ? 'tree-sitter-scala/tree-sitter-scala.wasm'
+      : `tree-sitter-wasms/out/tree-sitter-${GRAMMAR[name]}.wasm`,
+  )
   const lang = await Language.load(wasm)
   cache.set(name, lang)
   return lang
diff --git a/packages/api-model/src/product-exports.ts b/packages/api-model/src/product-exports.ts
index a66caf236..8ff274c2a 100644
--- a/packages/api-model/src/product-exports.ts
+++ b/packages/api-model/src/product-exports.ts
@@ -20,7 +20,13 @@ export function scopeProductSymbols(symbols: ApiSymbol[], context: ExportContext
     if (visited.has(file)) return
     visited.add(file)
     const text = context.readSource(file)
-    const names = new Set([...text.matchAll(/^export\s+(?:(?:async|declare|abstract|default)\s+)*(?:function|class|interface|type|const|let|enum)\s+(\w+)/gm)].map((match) => match[1]))
+    const names = new Set(
+      [
+        ...text.matchAll(
+          /^export\s+(?:(?:async|declare|abstract|default)\s+)*(?:function|class|interface|type|const|let|enum)\s+(\w+)/gm,
+        ),
+      ].map((match) => match[1]),
+    )
     exports.set(file, names)
     for (const match of text.matchAll(/^export\s+(?:type\s+)?(\*|\{[^}]+\})\s+from\s+['"]([^'"]+)['"]/gm)) {
       if (!match[2].startsWith('.')) continue
@@ -30,7 +36,10 @@ export function scopeProductSymbols(symbols: ApiSymbol[], context: ExportContext
         const existing = exports.get(target)
         const named = existing instanceof Set ? existing : new Set<string>()
         for (const part of match[1].slice(1, -1).split(',')) {
-          const name = part.trim().replace(/^type\s+/, '').split(/\s+as\s+/)[0]
+          const name = part
+            .trim()
+            .replace(/^type\s+/, '')
+            .split(/\s+as\s+/)[0]
           if (name) named.add(name)
         }
         exports.set(target, named)
@@ -42,10 +51,22 @@ export function scopeProductSymbols(symbols: ApiSymbol[], context: ExportContext
     for (const entry of context.entries) {
       exports.set(entry, '*')
       const text = context.readSource(entry)
-      for (const match of text.matchAll(/^pub mod (\w+)\s*;/gm)) exports.set(resolve(dirname(entry), `${match[1]}.rs`), '*')
+      for (const match of text.matchAll(/^pub mod (\w+)\s*;/gm))
+        exports.set(resolve(dirname(entry), `${match[1]}.rs`), '*')
       for (const match of text.matchAll(/^pub use (\w+)::(\*|\{[^}]+\}|\w+)\s*;/gm)) {
         const target = resolve(dirname(entry), `${match[1]}.rs`)
-        exports.set(target, match[2] === '*' ? '*' : new Set(match[2].replace(/[{}]/g, '').split(',').map((name) => name.trim().split(/\s+as\s+/)[0]).filter(Boolean)))
+        exports.set(
+          target,
+          match[2] === '*'
+            ? '*'
+            : new Set(
+                match[2]
+                  .replace(/[{}]/g, '')
+                  .split(',')
+                  .map((name) => name.trim().split(/\s+as\s+/)[0])
+                  .filter(Boolean),
+              ),
+        )
       }
     }
   }
@@ -58,12 +79,30 @@ export function scopeProductSymbols(symbols: ApiSymbol[], context: ExportContext
     if (context.port === 'ts' || context.port === 'rs') {
       const exported = exports.get(file)
       publicImport = exported === '*' || Boolean(exported?.has(symbol.name))
-      if (context.port === 'rs' && context.entries.some((entry) => new RegExp(`^pub\\s+(?:struct|enum|trait|type|const|(?:async\\s+)?fn)\\s+${escape(symbol.name)}\\b`, 'm').test(context.readSource(entry)))) publicImport = true
-      if (context.port === 'rs' && new RegExp(`#\\[cfg\\(doctest\\)\\][\\s\\S]*?pub struct ${escape(symbol.name)}\\b`).test(source)) publicImport = false
+      if (
+        context.port === 'rs' &&
+        context.entries.some((entry) =>
+          new RegExp(
+            `^pub\\s+(?:struct|enum|trait|type|const|(?:async\\s+)?fn)\\s+${escape(symbol.name)}\\b`,
+            'm',
+          ).test(context.readSource(entry)),
+        )
+      )
+        publicImport = true
+      if (
+        context.port === 'rs' &&
+        new RegExp(`#\\[cfg\\(doctest\\)\\][\\s\\S]*?pub struct ${escape(symbol.name)}\\b`).test(source)
+      )
+        publicImport = false
     } else if (context.port === 'java') {
-      publicImport = new RegExp(`\\bpublic\\s+(?:(?:final|abstract|sealed|static)\\s+)*(?:class|record|interface|enum)\\s+${escape(symbol.name)}\\b`).test(source)
+      publicImport = new RegExp(
+        `\\bpublic\\s+(?:(?:final|abstract|sealed|static)\\s+)*(?:class|record|interface|enum)\\s+${escape(symbol.name)}\\b`,
+      ).test(source)
     } else if (context.port === 'py') {
-      publicImport = !symbol.name.startsWith('_') && !/^(?:logger|log)$/.test(symbol.name) && !/(?:^|\/)(?!__init__\.py$)_(?:[^/]+)(?:\/|\.py$)/.test(file)
+      publicImport =
+        !symbol.name.startsWith('_') &&
+        !/^(?:logger|log)$/.test(symbol.name) &&
+        !/(?:^|\/)(?!__init__\.py$)_(?:[^/]+)(?:\/|\.py$)/.test(file)
     } else if (context.port === 'cxx') {
       publicImport = !/(?:^|::)detail(?:::|$)/.test(symbol.id)
     }
@@ -85,7 +124,17 @@ export function scopeProductSymbols(symbols: ApiSymbol[], context: ExportContext
     let changed = true
     while (changed) {
       changed = false
-      const signatures = symbols.filter((symbol) => symbol.apiScope !== 'internal').map((symbol) => JSON.stringify({ type: symbol.type, signatures: symbol.signatures, extends: symbol.extends, value: symbol.kind === 'typealias' ? symbol.value : undefined })).join('\n')
+      const signatures = symbols
+        .filter((symbol) => symbol.apiScope !== 'internal')
+        .map((symbol) =>
+          JSON.stringify({
+            type: symbol.type,
+            signatures: symbol.signatures,
+            extends: symbol.extends,
+            value: symbol.kind === 'typealias' ? symbol.value : undefined,
+          }),
+        )
+        .join('\n')
       for (const symbol of roots) {
         if (symbol.apiScope !== 'internal' || !TYPES.has(symbol.kind)) continue
         if (!new RegExp(`\\b${escape(symbol.name)}\\b`).test(signatures)) continue
diff --git a/packages/api-model/src/project.ts b/packages/api-model/src/project.ts
index e4073bba7..4f6ba7346 100644
--- a/packages/api-model/src/project.ts
+++ b/packages/api-model/src/project.ts
@@ -33,14 +33,7 @@ import {
  */
 
 /** Kinds an extension block can attach members to. */
-const EXTENDABLE: ReadonlySet<SymbolKind> = new Set([
-  'class',
-  'interface',
-  'struct',
-  'enum',
-  'trait',
-  'exception',
-])
+const EXTENDABLE: ReadonlySet<SymbolKind> = new Set(['class', 'interface', 'struct', 'enum', 'trait', 'exception'])
 
 /**
  * Fold an extension block onto the type it extends.
@@ -137,8 +130,7 @@ function mergePartials(symbols: ApiSymbol[]): ApiSymbol[] {
       out.push(s)
       continue
     }
-    const union = (a?: string[], b?: string[]) =>
-      a || b ? [...new Set([...(a ?? []), ...(b ?? [])])] : undefined
+    const union = (a?: string[], b?: string[]) => (a || b ? [...new Set([...(a ?? []), ...(b ?? [])])] : undefined)
     seen.extends = union(seen.extends, s.extends)
     seen.modifiers = union(seen.modifiers, s.modifiers) as ApiSymbol['modifiers']
 
@@ -147,8 +139,10 @@ function mergePartials(symbols: ApiSymbol[]): ApiSymbol[] {
     // a `partial class` is one scope however many files it is written across.
     // Keeping only the first signature would drop the others invisibly.
     const fresh = s.signatures.filter(
-      (sig) => !seen.signatures.some((k) => k.params.length === sig.params.length &&
-        k.params.every((p, i) => p.type === sig.params[i]?.type)),
+      (sig) =>
+        !seen.signatures.some(
+          (k) => k.params.length === sig.params.length && k.params.every((p, i) => p.type === sig.params[i]?.type),
+        ),
     )
     if (fresh.length) {
       seen.signatures.push(...fresh)
@@ -173,10 +167,7 @@ function mergePartials(symbols: ApiSymbol[]): ApiSymbol[] {
  * eight ports put them in four different places — `_test.go` beside the
  * source, `src/test/java`, `*.test.ts`, and a sibling `Tests/` project.
  */
-const LAYOUT: Record<
-  string,
-  { ext: string; skip: RegExp; moduleFrom?: 'file' | 'dir' | 'namespace' }
-> = {
+const LAYOUT: Record<string, { ext: string; skip: RegExp; moduleFrom?: 'file' | 'dir' | 'namespace' }> = {
   py: { ext: 'py', skip: /(^|\/)(tests?|conftest)\b|_test\.py$|^test_/ },
   ts: { ext: 'ts', skip: /\.test\.ts$|\.spec\.ts$|(^|\/)__tests__\// },
   rs: { ext: 'rs', skip: /(^|\/)tests?\// },
@@ -270,7 +261,7 @@ function sourceFiles(root: string, port: string): { file: string; module: string
  * its own docstring, not its parent's.
  */
 function resolveInheritance(symbols: ApiSymbol[], stopList: string[]): ApiSymbol[] {
-  const byId = new Map(symbols.map((s) => [s.id, s]));
+  const byId = new Map(symbols.map((s) => [s.id, s]))
   // Classes are addressable by bare name as well as by id: a base is written
   // `class Pane(Obj)`, not `class Pane(libtmux.neo.Obj)`.
   const byName = new Map<string, ApiSymbol>()
@@ -315,10 +306,12 @@ function resolveInheritance(symbols: ApiSymbol[], stopList: string[]): ApiSymbol
           ...member,
           id: `${cls.id}.${member.name}`,
           parent: cls.id,
-          ...(cls.qualifiedName === undefined ? {} : {
-            qualifiedName: `${cls.qualifiedName}.${member.name}`,
-            namespace: cls.namespace,
-          }),
+          ...(cls.qualifiedName === undefined
+            ? {}
+            : {
+                qualifiedName: `${cls.qualifiedName}.${member.name}`,
+                namespace: cls.namespace,
+              }),
           inheritedFrom: member.inheritedFrom ?? baseSym.id,
         })
       }
@@ -443,9 +436,7 @@ export async function extractProject(opts: {
   // Before inheritance, so a base class is one type rather than several.
   const merged = mergePartials(mergeExtensions(symbols, spec?.extensionKind))
 
-  const resolved = options.inheritedMembers
-    ? resolveInheritance(merged, options.inheritanceStopList)
-    : merged
+  const resolved = options.inheritedMembers ? resolveInheritance(merged, options.inheritanceStopList) : merged
   // Public paths last: inherited members need their owner to exist first, and
   // an inherited member's public path comes from the class it landed on, not
   // from the base it was declared in. Only Python re-exports through
@@ -458,9 +449,7 @@ export async function extractProject(opts: {
   // Pruning happens after public ids resolve: the rule names the path a
   // consumer would import by, which is `publicId`, not the declaration path.
   const rules = options.excludePaths
-  const kept = rules.length
-    ? withPublic.filter((s) => !rules.some((re) => re.test(s.publicId ?? s.id)))
-    : withPublic
+  const kept = rules.length ? withPublic.filter((s) => !rules.some((re) => re.test(s.publicId ?? s.id))) : withPublic
   const owned = rehomeOrphans(kept)
 
   return {
diff --git a/packages/api-model/src/prose.ts b/packages/api-model/src/prose.ts
index 974dbcc1f..065d50d5a 100644
--- a/packages/api-model/src/prose.ts
+++ b/packages/api-model/src/prose.ts
@@ -37,7 +37,8 @@ export const OWNER_KINDS: ReadonlySet<string> = new Set([
   'class',
   'exception',
   'interface',
-  'struct', 'union',
+  'struct',
+  'union',
   'trait',
   'enum',
   'module',
@@ -153,8 +154,12 @@ export function portFromSentence(before: string): string | undefined {
  */
 export function isLikelyReference(text: string): boolean {
   const t = text.trim()
-  return /\(/.test(t) || /[.:]|->/.test(t) || /^[A-Z][A-Za-z0-9_]*$/.test(t)
-    || /^(?:[\w.]+\\)?[A-Z][A-Za-z]+-[A-Za-z][\w]*$/.test(t)
+  return (
+    /\(/.test(t) ||
+    /[.:]|->/.test(t) ||
+    /^[A-Z][A-Za-z0-9_]*$/.test(t) ||
+    /^(?:[\w.]+\\)?[A-Z][A-Za-z]+-[A-Za-z][\w]*$/.test(t)
+  )
 }
 
 /**
@@ -270,9 +275,10 @@ export function decideMention(
     if (builtin) return { kind: 'link', port, href: builtin, title: `${text}: ${PORT_NAME[port]}`, external: true }
   }
   // A known language must never resolve a similarly named API in another port.
-  if (tried.length) return ambiguous
-    ? { kind: 'skip', why: 'ambiguous within the stated port; qualify the receiver to link it' }
-    : { kind: 'unresolved', why: 'not defined in the stated port', tried }
+  if (tried.length)
+    return ambiguous
+      ? { kind: 'skip', why: 'ambiguous within the stated port; qualify the receiver to link it' }
+      : { kind: 'unresolved', why: 'not defined in the stated port', tried }
 
   // Nothing said which language. One claimant is an answer; several are not.
   const claims: { port: string; decision: MentionDecision }[] = []
@@ -383,9 +389,10 @@ export function decideFilePath(
     if (hit?.ambiguous) return { kind: 'unresolved', why: `several files named this in ${port} — write the path out` }
     if (hit) return { kind: 'link', port, path: hit.path, dir: hit.dir }
   }
-  if (named || ctx.pagePort) return generic
-    ? { kind: 'skip', why: 'names a kind of file, not one path' }
-    : { kind: 'unresolved', why: 'not held by the stated port' }
+  if (named || ctx.pagePort)
+    return generic
+      ? { kind: 'skip', why: 'names a kind of file, not one path' }
+      : { kind: 'unresolved', why: 'not held by the stated port' }
   const all = Object.keys(trees).flatMap((port) => {
     const hit = claims(port)
     return hit && !hit.ambiguous ? [{ port, path: hit.path, dir: hit.dir }] : []
diff --git a/packages/api-model/src/resolver.ts b/packages/api-model/src/resolver.ts
index ad5bd41de..5a6e8586c 100644
--- a/packages/api-model/src/resolver.ts
+++ b/packages/api-model/src/resolver.ts
@@ -30,7 +30,17 @@ export type Resolution =
   | { how: 'not-a-symbol'; why: string }
 
 /** Kinds that can own members, and therefore act as a scope. */
-const TYPE_KINDS = new Set(['class', 'struct', 'union', 'interface', 'enum', 'trait', 'exception', 'module', 'typealias'])
+const TYPE_KINDS = new Set([
+  'class',
+  'struct',
+  'union',
+  'interface',
+  'enum',
+  'trait',
+  'exception',
+  'module',
+  'typealias',
+])
 
 /**
  * Ecosystems with no `objects.inv` to federate against.
@@ -90,8 +100,7 @@ export const DEFAULT_TEMPLATES: UrlTemplate[] = [
     project: 'Java SE',
     langs: ['java'],
     prefixes: ['Stream.', 'Optional.', 'List.', 'Map.', 'Set.', 'CompletableFuture.'],
-    href: (q) =>
-      'https://docs.oracle.com/en/java/javase/21/docs/api/index.html?q=' + encodeURIComponent(q),
+    href: (q) => 'https://docs.oracle.com/en/java/javase/21/docs/api/index.html?q=' + encodeURIComponent(q),
   },
 ]
 
@@ -107,7 +116,12 @@ export function notASymbol(text: string): string | undefined {
   if (/^(?:net|v)?\d+\.\d+(?:\.\d+)?(?:[a-z]|[-+][\w.-]+)?$/.test(text)) return 'a version'
   if (/^\w+(?:\.\w+)+:[\w.-]+(?::[\w.<>{}-]+)?$/.test(text)) return 'a dependency coordinate'
   if (/\.(?:tsv|html)$/.test(text)) return 'a filename'
-  if (/\.(py|ts|go|rs|java|kt|kts|scala|cs|fs|fsi|fsproj|properties|cpp|hpp|c|h|lua|rb|swift|jl|ps1|psm1|psd1|md|json|ya?ml|toml|sh)\b/.test(text)) return 'a filename'
+  if (
+    /\.(py|ts|go|rs|java|kt|kts|scala|cs|fs|fsi|fsproj|properties|cpp|hpp|c|h|lua|rb|swift|jl|ps1|psm1|psd1|md|json|ya?ml|toml|sh)\b/.test(
+      text,
+    )
+  )
+    return 'a filename'
   if (/(^|\s)--?[A-Za-z]/.test(text)) return 'a command-line flag'
   if (/[=<>!]=|\s[=<>]\s/.test(text)) return 'an expression, not a reference'
   if (/^new\s/.test(text)) return 'a constructor call'
@@ -118,19 +132,21 @@ export function notASymbol(text: string): string | undefined {
 
 /** Strip call syntax down to a dotted path. */
 export function toPath(text: string): string[] {
-  return text
-    .replace(/^(await|try|new)\s+/, '')
-    .replace(/\(.*$/, '')
-    .replace(/`\d+/g, '')
-    .replace(/->/g, '.')
-    .replace(/::/g, '.')
-    // Lua's method call, `Session:new_window`. Only between two names, so a
-    // Swift selector's labels (already cut with the argument list) and a
-    // `{ key: value }` literal (refused by `notASymbol`) never reach it.
-    .replace(/(\w):(?=[A-Za-z_])/g, '$1.')
-    .replace(/\s+/g, '')
-    .split('.')
-    .filter(Boolean)
+  return (
+    text
+      .replace(/^(await|try|new)\s+/, '')
+      .replace(/\(.*$/, '')
+      .replace(/`\d+/g, '')
+      .replace(/->/g, '.')
+      .replace(/::/g, '.')
+      // Lua's method call, `Session:new_window`. Only between two names, so a
+      // Swift selector's labels (already cut with the argument list) and a
+      // `{ key: value }` literal (refused by `notASymbol`) never reach it.
+      .replace(/(\w):(?=[A-Za-z_])/g, '$1.')
+      .replace(/\s+/g, '')
+      .split('.')
+      .filter(Boolean)
+  )
 }
 
 interface Row {
@@ -200,13 +216,14 @@ export class Resolver {
           this.byMember.set(key, list)
         }
         this.byQualified.set(model.port + ' ' + qualified, row)
-
       }
       // Old anchors remain accepted, including identities that overlap a
       // constructor's native qualified name.
       for (const symbol of model.symbols) {
         this.byQualified.set(model.port + ' ' + (symbol.publicId ?? symbol.id), {
-          port: model.port, symbol, qualified: qualifiedNameOf(symbol),
+          port: model.port,
+          symbol,
+          qualified: qualifiedNameOf(symbol),
         })
       }
     }
@@ -218,12 +235,7 @@ export class Resolver {
    * See `SymbolIndex.addInventory` for why the scope is mandatory in spirit:
    * an unscoped CPython inventory answered for all eight ports.
    */
-  addInventory(
-    project: string,
-    baseUrl: string,
-    entries: InventoryEntry[],
-    langs?: string[],
-  ): void {
+  addInventory(project: string, baseUrl: string, entries: InventoryEntry[], langs?: string[]): void {
     const map = new Map<string, InventoryEntry>()
     for (const e of entries) if (!map.has(e.name)) map.set(e.name, e)
     this.inventories.push({ project, baseUrl: baseUrl.replace(/\/*$/, '/'), entries: map, langs })
@@ -255,9 +267,7 @@ export class Resolver {
    * Rust's three `Error` types — still refuse.
    */
   private static preferTypeOverConstructor(rows: Row[]): Row[] {
-    const types = new Set(
-      rows.filter((r) => TYPE_KINDS.has(r.symbol.kind)).map((r) => r.symbol.id),
-    )
+    const types = new Set(rows.filter((r) => TYPE_KINDS.has(r.symbol.kind)).map((r) => r.symbol.id))
     if (!types.size) return rows
     const kept = rows.filter((r) => !r.symbol.parent || !types.has(r.symbol.parent))
     return kept.length ? kept : rows
@@ -284,8 +294,10 @@ export class Resolver {
     // Unqualified core prose uses the port's primary namespace. A nested
     // effect facade stays addressable through its explicit namespace.
     const primary = this.primary[port]
-    const primaryMember = primary && (!product || product === 'core')
-      ? this.byQualified.get(`${port} ${primary}.${parts.join('.')}`) : undefined
+    const primaryMember =
+      primary && (!product || product === 'core')
+        ? this.byQualified.get(`${port} ${primary}.${parts.join('.')}`)
+        : undefined
     if (primaryMember && primaryMember.symbol.apiScope !== 'internal') {
       return { how: 'scoped', symbol: primaryMember.symbol, port }
     }
@@ -311,7 +323,10 @@ export class Resolver {
       // Prose names a variable after its type; both spellings occur.
       for (const cand of [receiver, receiver[0].toUpperCase() + receiver.slice(1)]) {
         const owners = this.members(port, cand).filter((r) => TYPE_KINDS.has(r.symbol.kind))
-        const scoped = Resolver.preferProduct(candidates.filter((r) => owners.some((o) => r.symbol.parent === o.symbol.id)), product)
+        const scoped = Resolver.preferProduct(
+          candidates.filter((r) => owners.some((o) => r.symbol.parent === o.symbol.id)),
+          product,
+        )
         if (scoped.length === 1) return { how: 'scoped', symbol: scoped[0].symbol, port }
         if (scoped.length > 1) {
           const prefix = this.primary[port]
@@ -330,7 +345,9 @@ export class Resolver {
           .pop()
           ?.trim()
         if (!bare) continue
-        const owner = Resolver.preferProduct(this.members(port, bare), product).find((r) => TYPE_KINDS.has(r.symbol.kind))
+        const owner = Resolver.preferProduct(this.members(port, bare), product).find((r) =>
+          TYPE_KINDS.has(r.symbol.kind),
+        )
         if (!owner) continue
         const hit = local.filter((r) => r.symbol.parent === owner.symbol.id)
         if (hit.length === 1) return { how: 'chained', symbol: hit[0].symbol, port }
diff --git a/packages/api-model/test/builtins.test.ts b/packages/api-model/test/builtins.test.ts
index 9470a0016..68a6f78de 100644
--- a/packages/api-model/test/builtins.test.ts
+++ b/packages/api-model/test/builtins.test.ts
@@ -15,14 +15,18 @@ describe('standard types in product signatures', () => {
       'Set-Content': 'microsoft.powershell.management',
     }
     for (const [name, module] of Object.entries(commands)) {
-      expect(builtinHref('powershell', name)).toBe(`https://learn.microsoft.com/powershell/module/${module}/${name.toLowerCase()}?view=powershell-7.4`)
+      expect(builtinHref('powershell', name)).toBe(
+        `https://learn.microsoft.com/powershell/module/${module}/${name.toLowerCase()}?view=powershell-7.4`,
+      )
       expect(builtinHref('csharp', name)).toBeUndefined()
     }
     for (const name of ['Get-InventedCommand', 'Stop', 'Boolean', 'Name', 'CaptureResult']) {
       expect(builtinHref('powershell', name)).toBeUndefined()
     }
     expect(builtinHref('powershell', 'FileInfo')).toBe('https://learn.microsoft.com/dotnet/api/system.io.fileinfo')
-    expect(builtinHref('powershell', 'ApplicationInfo')).toBe('https://learn.microsoft.com/dotnet/api/system.management.automation.applicationinfo?view=powershellsdk-7.4.0')
+    expect(builtinHref('powershell', 'ApplicationInfo')).toBe(
+      'https://learn.microsoft.com/dotnet/api/system.management.automation.applicationinfo?view=powershellsdk-7.4.0',
+    )
   })
 
   it('resolves compiler utility types without claiming local declarations', () => {
@@ -34,8 +38,12 @@ describe('standard types in product signatures', () => {
       expect(builtinHref('go', name)).toBeUndefined()
     }
     const local: ApiSymbol = {
-      id: 'example.Record', name: 'Record', kind: 'typealias', modifiers: [],
-      signatures: [], source: { file: 'example.ts' },
+      id: 'example.Record',
+      name: 'Record',
+      kind: 'typealias',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'example.ts' },
     }
     const index = new SymbolIndex([local], () => '/reference/example-record/', 'ts')
     expect(index.resolve('Record')).toMatchObject({ href: '/reference/example-record/', external: false })
@@ -54,8 +62,10 @@ describe('standard types in product signatures', () => {
   })
 
   it('does not inherit object properties as keyword help', () => {
-    expect(new SymbolIndex([], () => '#', 'kotlin').linkType('constructor')[0])
-      .toEqual({ text: 'constructor', keyword: true })
+    expect(new SymbolIndex([], () => '#', 'kotlin').linkType('constructor')[0]).toEqual({
+      text: 'constructor',
+      keyword: true,
+    })
   })
 
   it('offers C++ nodiscard help only for the attribute', () => {
@@ -64,11 +74,15 @@ describe('standard types in product signatures', () => {
       const spans = index.linkType(declaration)
       expect(spans.map((span) => span.text).join('')).toBe(declaration)
       expect(spans.find((span) => span.text === 'nodiscard')).toMatchObject({
-        keyword: true, help: { href: 'https://eel.is/c++draft/dcl.attr.nodiscard' },
+        keyword: true,
+        help: { href: 'https://eel.is/c++draft/dcl.attr.nodiscard' },
       })
     }
     for (const declaration of [
-      'nodiscard', 'void nodiscard();', '/* [[nodiscard]] */', '"[[nodiscard]]"',
+      'nodiscard',
+      'void nodiscard();',
+      '/* [[nodiscard]] */',
+      '"[[nodiscard]]"',
       `void f(const char* value = "don't [[nodiscard]]");`,
       String.raw`void f(const char* value = "say \"[[nodiscard]]\"");`,
       'void f(const char* value = R"tag(say "[[nodiscard]]")tag");',
@@ -84,12 +98,32 @@ describe('standard types in product signatures', () => {
   it.each([
     ['kotlin', 'List<String>', 'List', 'https://kotlinlang.org/api/core/kotlin-stdlib/kotlin.collections/-list/'],
     ['scala', 'Option[String]', 'Option', 'https://www.scala-lang.org/api/3.x/scala/Option.html'],
-    ['fsharp', "Result<'T, 'Error>", 'Result', 'https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-fsharpresult-2.html'],
+    [
+      'fsharp',
+      "Result<'T, 'Error>",
+      'Result',
+      'https://fsharp.github.io/fsharp-core-docs/reference/fsharp-core-fsharpresult-2.html',
+    ],
     ['rs', 'Option<OsString>', 'OsString', 'https://doc.rust-lang.org/std/ffi/struct.OsString.html'],
     ['csharp', 'IProgress<T>?', 'IProgress', 'https://learn.microsoft.com/dotnet/api/system.iprogress-1'],
-    ['csharp', 'ReadOnlyMemory<byte>', 'ReadOnlyMemory', 'https://learn.microsoft.com/dotnet/api/system.readonlymemory-1'],
-    ['csharp', 'IEnumerator<T>', 'IEnumerator', 'https://learn.microsoft.com/dotnet/api/system.collections.generic.ienumerator-1'],
-    ['csharp', 'IReadOnlyCollection<Pane>', 'IReadOnlyCollection', 'https://learn.microsoft.com/dotnet/api/system.collections.generic.ireadonlycollection-1'],
+    [
+      'csharp',
+      'ReadOnlyMemory<byte>',
+      'ReadOnlyMemory',
+      'https://learn.microsoft.com/dotnet/api/system.readonlymemory-1',
+    ],
+    [
+      'csharp',
+      'IEnumerator<T>',
+      'IEnumerator',
+      'https://learn.microsoft.com/dotnet/api/system.collections.generic.ienumerator-1',
+    ],
+    [
+      'csharp',
+      'IReadOnlyCollection<Pane>',
+      'IReadOnlyCollection',
+      'https://learn.microsoft.com/dotnet/api/system.collections.generic.ireadonlycollection-1',
+    ],
     ['cxx', 'std::function<void(double)>', 'double', 'https://en.cppreference.com/w/cpp/language/types'],
     ['swift', 'Data', 'Data', 'https://developer.apple.com/documentation/foundation/data'],
     ['swift', 'AsyncStream<String>', 'AsyncStream', 'https://developer.apple.com/documentation/swift/asyncstream'],
@@ -116,10 +150,12 @@ describe('standard types in product signatures', () => {
     expect(spans.map((span) => span.text).join('')).toBe('any Error')
     expect(spans.find((span) => span.text === 'any')).toEqual({ text: 'any', keyword: true })
     expect(spans.find((span) => span.text === 'Error')?.link).toMatchObject({
-      href: 'https://developer.apple.com/documentation/swift/error', external: true,
+      href: 'https://developer.apple.com/documentation/swift/error',
+      external: true,
     })
     expect(swift.linkType('any MissingError').find((span) => span.text === 'MissingError')).toEqual({
-      text: 'MissingError', link: undefined,
+      text: 'MissingError',
+      link: undefined,
     })
     expect(builtinHref('swift', 'any')).toBeUndefined()
     expect(new SymbolIndex([], () => '#', 'go').linkType('any')[0].link?.href).toBe('https://pkg.go.dev/builtin#any')
@@ -138,10 +174,21 @@ describe('standard types in product signatures', () => {
 
   it('uses Scala collections before bare aliases from the JDK inventory', () => {
     const index = new SymbolIndex([], () => '#', 'scala')
-    index.addInventory('https://docs.oracle.com/', ['Vector', 'java.util.Vector'].map((name) => ({
-      name, type: 'class', priority: 1, uri: 'java/util/Vector.html', dispname: '-',
-    })), ['scala'], 'Java SE')
-    expect(index.resolve('Vector')?.href).toBe('https://www.scala-lang.org/api/3.x/scala/collection/immutable/Vector.html')
+    index.addInventory(
+      'https://docs.oracle.com/',
+      ['Vector', 'java.util.Vector'].map((name) => ({
+        name,
+        type: 'class',
+        priority: 1,
+        uri: 'java/util/Vector.html',
+        dispname: '-',
+      })),
+      ['scala'],
+      'Java SE',
+    )
+    expect(index.resolve('Vector')?.href).toBe(
+      'https://www.scala-lang.org/api/3.x/scala/collection/immutable/Vector.html',
+    )
     expect(index.resolve('java.util.Vector')?.href).toBe('https://docs.oracle.com/java/util/Vector.html')
     expect(index.resolve('def')).toBeUndefined()
     expect(index.resolve('extension')).toBeUndefined()
@@ -162,7 +209,10 @@ describe('.NET exception references in F# and C#', () => {
     ['System.OperationCanceledException', 'system.operationcanceledexception'],
     ['System.IO.InvalidDataException', 'system.io.invaliddataexception'],
     ['System.IO.IOException', 'system.io.ioexception'],
-    ['System.Text.RegularExpressions.RegexMatchTimeoutException', 'system.text.regularexpressions.regexmatchtimeoutexception'],
+    [
+      'System.Text.RegularExpressions.RegexMatchTimeoutException',
+      'system.text.regularexpressions.regexmatchtimeoutexception',
+    ],
     ['System.Text.Json.JsonException', 'system.text.json.jsonexception'],
     ['System.Threading.Tasks.TaskCanceledException', 'system.threading.tasks.taskcanceledexception'],
   ] as const
@@ -179,25 +229,36 @@ describe('.NET exception references in F# and C#', () => {
   })
 
   it('links the real F# tryFindClient Raises type without changing its spelling', () => {
-    const model = JSON.parse(readFileSync(new URL('../../../site/src/data/api/fsharp.json', import.meta.url), 'utf8')) as ApiModel
+    const model = JSON.parse(
+      readFileSync(new URL('../../../site/src/data/api/fsharp.json', import.meta.url), 'utf8'),
+    ) as ApiModel
     const symbol = model.symbols.find((entry) => entry.id === 'LibTmux.FSharp.Server.tryFindClient')!
     expect(symbol.signatures[0].raises).toEqual([
       { type: 'System.ArgumentException', doc: 'The client name is null, empty or whitespace.' },
     ])
     const index = new SymbolIndex(model.symbols, (entry) => `#${entry.id}`, model.port)
     expect(index.linkType(symbol.signatures[0].raises![0].type, symbol)).toEqual([
-      { text: 'System.ArgumentException', link: {
-        href: 'https://learn.microsoft.com/dotnet/api/system.argumentexception', external: true,
-      } },
+      {
+        text: 'System.ArgumentException',
+        link: {
+          href: 'https://learn.microsoft.com/dotnet/api/system.argumentexception',
+          external: true,
+        },
+      },
     ])
   })
 
   it('leaves unknown namespaces and exceptions plain without borrowing another language', () => {
     for (const port of ['fsharp', 'csharp']) {
       const index = new SymbolIndex([], () => '#', port)
-      for (const name of ['System.MissingException', 'System.IO.ArgumentException',
-        'Other.ArgumentException', 'System.Text.Json.OtherException', 'System.Exceptionish',
-        'Newtonsoft.Json.JsonException']) {
+      for (const name of [
+        'System.MissingException',
+        'System.IO.ArgumentException',
+        'Other.ArgumentException',
+        'System.Text.Json.OtherException',
+        'System.Exceptionish',
+        'Newtonsoft.Json.JsonException',
+      ]) {
         expect(builtinHref(port, name)).toBeUndefined()
         expect(index.linkType(name)).toEqual([{ text: name, link: undefined }])
       }
@@ -208,14 +269,24 @@ describe('.NET exception references in F# and C#', () => {
   })
 
   it.each(['fsharp', 'csharp'])('retains a local exception definition before a short builtin in %s', (port) => {
-    const symbol = { id: 'LibTmux.ArgumentException', name: 'ArgumentException', kind: 'class',
-      modifiers: [], signatures: [], source: { file: 'example' }, slug: 'argument-exception' } satisfies ApiSymbol
+    const symbol = {
+      id: 'LibTmux.ArgumentException',
+      name: 'ArgumentException',
+      kind: 'class',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'example' },
+      slug: 'argument-exception',
+    } satisfies ApiSymbol
     const index = new SymbolIndex([symbol], () => '/reference/argument-exception/', port)
     expect(index.resolve('ArgumentException')).toMatchObject({
-      href: '/reference/argument-exception/', external: false, symbol,
+      href: '/reference/argument-exception/',
+      external: false,
+      symbol,
     })
     expect(index.resolve('System.ArgumentException')).toMatchObject({
-      href: 'https://learn.microsoft.com/dotnet/api/system.argumentexception', external: true,
+      href: 'https://learn.microsoft.com/dotnet/api/system.argumentexception',
+      external: true,
     })
   })
 })
diff --git a/packages/api-model/test/concepts.test.ts b/packages/api-model/test/concepts.test.ts
index 666339552..4901a03bc 100644
--- a/packages/api-model/test/concepts.test.ts
+++ b/packages/api-model/test/concepts.test.ts
@@ -42,10 +42,15 @@ describe('concept map', () => {
     expect(concept.symbols.powershell).toBe(id)
     const symbol = models.get('powershell')!.symbols.find((entry) => entry.id === id)!
     expect(symbol.product).toBe('workspace')
-    expect(symbol.command).toMatchObject({ kind: 'cmdlet', supportsShouldProcess: true, confirmImpact: 'High',
-      outputTypes: ['LibTmux.Workspace.WorkspaceResult'] })
+    expect(symbol.command).toMatchObject({
+      kind: 'cmdlet',
+      supportsShouldProcess: true,
+      confirmImpact: 'High',
+      outputTypes: ['LibTmux.Workspace.WorkspaceResult'],
+    })
     expect(symbol.signatures[0].params.find((param) => param.name === 'Plan')).toMatchObject({
-      type: 'LibTmux.Workspace.WorkspacePlan', binding: { mandatory: true, pipeline: { byValue: true } },
+      type: 'LibTmux.Workspace.WorkspacePlan',
+      binding: { mandatory: true, pipeline: { byValue: true } },
     })
     expect(conceptsFor('powershell', id)).toContain(concept)
     expect(conceptsFor('powershell', 'LibTmux.Workspace\\Get-TmuxWorkspacePlan')).not.toContain(concept)
@@ -75,9 +80,12 @@ describe('concept map', () => {
       const model = models.get(port)
       if (!model) continue
       const symbol = model.symbols.find((entry) => (entry.publicId ?? entry.id) === publicId)
-      expect(symbol?.signatures.some((signature) =>
-        signature.params.some((parameter) => /\bSession\b/.test(parameter.type ?? '')),
-      ), `${port}: ${publicId}`).toBe(true)
+      expect(
+        symbol?.signatures.some((signature) =>
+          signature.params.some((parameter) => /\bSession\b/.test(parameter.type ?? '')),
+        ),
+        `${port}: ${publicId}`,
+      ).toBe(true)
     }
     expect(CONCEPTS['freeze-workspace'].symbols.swift).toBeUndefined()
   })
@@ -124,7 +132,9 @@ describe('concept map', () => {
       expect(conceptsFor('julia', `LibTmux.${name}Ref`)).toContain(concept)
     }
     const windows = model.symbols.find((symbol) => symbol.id === CONCEPTS['list-windows'].symbols.julia)!
-    expect(windows.signatures.some((signature) => signature.raw?.includes('parent::LibTmux.SessionSnapshot'))).toBe(true)
+    expect(windows.signatures.some((signature) => signature.raw?.includes('parent::LibTmux.SessionSnapshot'))).toBe(
+      true,
+    )
     expect(windows.signatures.some((signature) => signature.raw?.includes('snap::LibTmux.Snapshot'))).toBe(true)
     const panes = model.symbols.find((symbol) => symbol.id === CONCEPTS['list-panes'].symbols.julia)!
     expect(panes.signatures.some((signature) => signature.raw?.includes('win::LibTmux.WindowSnapshot'))).toBe(true)
@@ -137,12 +147,18 @@ describe('concept map', () => {
   it.runIf(models.size)('maps PowerShell listing scopes to declared parameter sets', () => {
     const model = models.get('powershell')!
     for (const [concept, receiver] of [
-      ['list-sessions', 'Server'], ['list-server-windows', 'Server'],
-      ['list-windows', 'Session'], ['list-server-panes', 'Server'],
-      ['list-session-panes', 'Session'], ['list-panes', 'Window'],
+      ['list-sessions', 'Server'],
+      ['list-server-windows', 'Server'],
+      ['list-windows', 'Session'],
+      ['list-server-panes', 'Server'],
+      ['list-session-panes', 'Session'],
+      ['list-panes', 'Window'],
     ]) {
       const symbol = model.symbols.find((symbol) => symbol.id === CONCEPTS[concept].symbols.powershell)!
-      expect(symbol.signatures.some((signature) => signature.raw?.includes(`[-${receiver}] <LibTmux.${receiver}>`)), concept).toBe(true)
+      expect(
+        symbol.signatures.some((signature) => signature.raw?.includes(`[-${receiver}] <LibTmux.${receiver}>`)),
+        concept,
+      ).toBe(true)
       expect(CONCEPTS[concept].notes?.powershell, concept).toContain(`\`-${receiver}\``)
     }
   })
@@ -174,11 +190,16 @@ describe('concept map', () => {
   it('preserves native handle scopes and recognises Cats Effect operations', () => {
     for (const port of ['kotlin', 'scala']) {
       for (const [concept, member] of Object.entries({
-        'split-pane': 'Pane.split', 'split-window': 'Window.split',
-        'list-windows': 'Session.windows', 'list-panes': 'Window.panes',
-        'list-server-windows': 'Server.windows', 'list-server-panes': 'Server.panes',
+        'split-pane': 'Pane.split',
+        'split-window': 'Window.split',
+        'list-windows': 'Session.windows',
+        'list-panes': 'Window.panes',
+        'list-server-windows': 'Server.windows',
+        'list-server-panes': 'Server.panes',
       })) {
-        expect(CONCEPTS[concept].symbols[port]).toBe(`io.github.libtmux.${port === 'scala' ? 'scaladsl' : port}.${member}`)
+        expect(CONCEPTS[concept].symbols[port]).toBe(
+          `io.github.libtmux.${port === 'scala' ? 'scaladsl' : port}.${member}`,
+        )
       }
     }
     expect(conceptsFor('scala', 'io.github.libtmux.scaladsl.cats.Server.newSession')).toContain(CONCEPTS['new-session'])
diff --git a/packages/api-model/test/coverage.test.ts b/packages/api-model/test/coverage.test.ts
index d17d871b6..43fedefca 100644
--- a/packages/api-model/test/coverage.test.ts
+++ b/packages/api-model/test/coverage.test.ts
@@ -49,18 +49,14 @@ describeIfSource('Python extraction against gp-sphinx', () => {
     const pane = model.symbols.find((s) => s.publicId === 'libtmux.Pane' && s.kind === 'class')
     expect(pane, 'Pane class').toBeDefined()
 
-    const found = new Set(
-      model.symbols.filter((s) => s.parent === pane?.id).map((s) => s.publicId ?? s.id),
-    )
+    const found = new Set(model.symbols.filter((s) => s.parent === pane?.id).map((s) => s.publicId ?? s.id))
     const missing = expected.filter((id) => !found.has(id))
     expect(missing, `missing ${missing.length} of ${expected.length}`).toEqual([])
   })
 
   it('resolves inherited dataclass fields from another module', () => {
     const pane = model.symbols.find((s) => s.publicId === 'libtmux.Pane')
-    const field = model.symbols.find(
-      (s) => s.parent === pane?.id && s.name === 'buffer_name',
-    )
+    const field = model.symbols.find((s) => s.parent === pane?.id && s.name === 'buffer_name')
     expect(field?.inheritedFrom).toBe('libtmux.neo.Obj')
     expect(field?.publicId).toBe('libtmux.Pane.buffer_name')
   })
@@ -173,7 +169,10 @@ describeIfSource('id stability', () => {
       options: { privateMembers: true, specialMembers: true },
     })
     const key = (m: ApiModel) =>
-      m.symbols.map((s) => `${s.id}\t${s.publicId}`).sort().join('\n')
+      m.symbols
+        .map((s) => `${s.id}\t${s.publicId}`)
+        .sort()
+        .join('\n')
     expect(key(twice)).toBe(key(once))
   }, 120_000)
 
@@ -185,9 +184,7 @@ describeIfSource('id stability', () => {
     })
     // An inherited member is keyed on the class it lands on, so it stays put
     // even if the base it came from is renamed or re-homed.
-    const field = model.symbols.find(
-      (s) => s.publicId === 'libtmux.Pane.buffer_name',
-    )
+    const field = model.symbols.find((s) => s.publicId === 'libtmux.Pane.buffer_name')
     expect(field?.id).toBe('libtmux.pane.Pane.buffer_name')
     expect(field?.inheritedFrom).toBe('libtmux.neo.Obj')
   }, 120_000)
@@ -269,8 +266,13 @@ describe('methods belong to their types', () => {
     if (!methods.length) return
     const orphans = methods.filter((s) => !s.parent)
     const rate = 1 - orphans.length / methods.length
-    expect(rate, `${orphans.length} ownerless: ${orphans.slice(0, 3).map((s) => s.id).join(', ')}`)
-      .toBeGreaterThanOrEqual(0.95)
+    expect(
+      rate,
+      `${orphans.length} ownerless: ${orphans
+        .slice(0, 3)
+        .map((s) => s.id)
+        .join(', ')}`,
+    ).toBeGreaterThanOrEqual(0.95)
   })
 
   it('attaches a Go method to its receiver type', () => {
@@ -293,10 +295,11 @@ describe('the reference is pruned but not gutted', () => {
       const path = join(here, `../../site/src/data/api/${port}.json`)
       if (!existsSync(path)) continue
       const model = JSON.parse(readFileSync(path, 'utf8')) as ApiModel
-      const leaked = model.symbols.filter((s) =>
-        /^_?(internal|_generated)\./.test(s.publicId ?? s.id),
-      )
-      expect(leaked.map((s) => s.publicId), `${port} leaked internals`).toEqual([])
+      const leaked = model.symbols.filter((s) => /^_?(internal|_generated)\./.test(s.publicId ?? s.id))
+      expect(
+        leaked.map((s) => s.publicId),
+        `${port} leaked internals`,
+      ).toEqual([])
     }
   })
 
diff --git a/packages/api-model/test/csharp-examples.test.ts b/packages/api-model/test/csharp-examples.test.ts
index d82303b93..c42268efe 100644
--- a/packages/api-model/test/csharp-examples.test.ts
+++ b/packages/api-model/test/csharp-examples.test.ts
@@ -5,35 +5,66 @@ import type { ApiSymbol } from '../src/model.ts'
 const source = { repo: 'libtmux/libtmux-dotnet', revision: 'a'.repeat(40) }
 const fixture = () => {
   const program = {
-    id: 'csharp-ServerConstruction', profile: 'csharp', title: 'Connect to a server',
+    id: 'csharp-ServerConstruction',
+    profile: 'csharp',
+    title: 'Connect to a server',
     description: 'Discover a live server through a configured endpoint.',
     sourceFile: 'examples/LibTmux.Examples/Programs/ServerConstruction.cs',
-    targets: ['M:LibTmux.Server.ConnectAsync(LibTmux.ServerConnectionOptions,System.Threading.CancellationToken)',
-      'M:LibTmux.Server.ConnectAsync(System.Threading.CancellationToken)', 'T:LibTmux.Server'],
+    targets: [
+      'M:LibTmux.Server.ConnectAsync(LibTmux.ServerConnectionOptions,System.Threading.CancellationToken)',
+      'M:LibTmux.Server.ConnectAsync(System.Threading.CancellationToken)',
+      'T:LibTmux.Server',
+    ],
     output: 'connected\n',
   }
   const manifest = {
     schemaVersion: 1,
-    profiles: { csharp: { package: 'LibTmux', projectFile: 'examples/api/csharp/Example.csproj', entrypoint: 'Program.cs' } },
-    setupFiles: ['global.json', 'examples/api/NuGet.config'], examples: [program],
+    profiles: {
+      csharp: { package: 'LibTmux', projectFile: 'examples/api/csharp/Example.csproj', entrypoint: 'Program.cs' },
+    },
+    setupFiles: ['global.json', 'examples/api/NuGet.config'],
+    examples: [program],
   }
   const files = new Map([
     ['global.json', '{"sdk":{"version":"10.0.302"}}\n'],
     ['examples/api/NuGet.config', '<?xml version="1.0"?>\n<configuration />\n'],
     ['examples/api/csharp/Example.csproj', '<Project Sdk="Microsoft.NET.Sdk" />\n'],
-    [program.sourceFile, '\n// Complete file, including every blank line.\nusing System;\nConsole.WriteLine("connected");\n\n'],
+    [
+      program.sourceFile,
+      '\n// Complete file, including every blank line.\nusing System;\nConsole.WriteLine("connected");\n\n',
+    ],
   ])
   const symbols: ApiSymbol[] = [
-    { id: 'LibTmux.Server.ConnectAsync', name: 'ConnectAsync', kind: 'method', modifiers: ['overload'],
-      signatures: [{ params: [{ name: 'options', type: 'ServerConnectionOptions?' },
-        { name: 'cancellationToken', type: 'CancellationToken' }] },
-      { params: [{ name: 'cancellationToken', type: 'CancellationToken' }] }],
-      source: { file: 'Server.Identity.cs' }, slug: 'server-connectasync',
-      doc: { summary: 'Native method documentation.', examples: [{ lang: 'csharp', code: 'existing inline example' }] } },
-    { id: 'LibTmux.Server', name: 'Server', kind: 'class', modifiers: [], signatures: [],
-      source: { file: 'Server.cs' }, slug: 'server', doc: { summary: 'Native type documentation.' } },
+    {
+      id: 'LibTmux.Server.ConnectAsync',
+      name: 'ConnectAsync',
+      kind: 'method',
+      modifiers: ['overload'],
+      signatures: [
+        {
+          params: [
+            { name: 'options', type: 'ServerConnectionOptions?' },
+            { name: 'cancellationToken', type: 'CancellationToken' },
+          ],
+        },
+        { params: [{ name: 'cancellationToken', type: 'CancellationToken' }] },
+      ],
+      source: { file: 'Server.Identity.cs' },
+      slug: 'server-connectasync',
+      doc: { summary: 'Native method documentation.', examples: [{ lang: 'csharp', code: 'existing inline example' }] },
+    },
+    {
+      id: 'LibTmux.Server',
+      name: 'Server',
+      kind: 'class',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'Server.cs' },
+      slug: 'server',
+      doc: { summary: 'Native type documentation.' },
+    },
   ]
-  const read = (path: string) => path === 'examples/api/manifest.json' ? JSON.stringify(manifest) : files.get(path)
+  const read = (path: string) => (path === 'examples/api/manifest.json' ? JSON.stringify(manifest) : files.get(path))
   return { manifest, files, symbols, read }
 }
 
@@ -51,8 +82,12 @@ describe('complete C# API programs', () => {
       expect(blocks).toHaveLength(7)
       expect(blocks[0].code).toContain(`checkout --detach ${source.revision}`)
       expect(blocks[0].intro).toContain('.NET SDK 10.0.302')
-      for (const [i, path] of ['global.json', 'examples/api/NuGet.config',
-        'examples/api/csharp/Example.csproj', manifest.examples[0].sourceFile].entries()) {
+      for (const [i, path] of [
+        'global.json',
+        'examples/api/NuGet.config',
+        'examples/api/csharp/Example.csproj',
+        manifest.examples[0].sourceFile,
+      ].entries()) {
         expect(blocks[i + 1].code).toBe(files.get(path))
         expect(blocks[i + 1].sourceUrl).toBe(`https://github.com/${source.repo}/blob/${source.revision}/${path}`)
       }
@@ -71,8 +106,13 @@ describe('complete C# API programs', () => {
   it('retains separate complete programs sharing a page', () => {
     const { manifest, files, symbols, read } = fixture()
     const first = manifest.examples[0]
-    const second = { ...first, id: 'csharp-OtherConnection',
-      sourceFile: first.sourceFile.replace('ServerConstruction', 'OtherConnection'), targets: [first.targets[0]], output: 'second\n' }
+    const second = {
+      ...first,
+      id: 'csharp-OtherConnection',
+      sourceFile: first.sourceFile.replace('ServerConstruction', 'OtherConnection'),
+      targets: [first.targets[0]],
+      output: 'second\n',
+    }
     files.set(second.sourceFile, 'System.Console.WriteLine("second");\n')
     manifest.examples.push(second)
     attachCompleteCSharpExamples(symbols, read, source)
@@ -86,8 +126,10 @@ describe('complete C# API programs', () => {
 
   it('maps generic owner and method arities while retaining native property and method kinds', () => {
     const { manifest, symbols, read } = fixture()
-    manifest.examples[0].targets = ['P:LibTmux.CapturedRelation`1.IsCaptured',
-      'M:LibTmux.Query.QueryExtensions.Matching``1(System.Collections.Generic.IEnumerable{``0},LibTmux.Query.QueryDocument)']
+    manifest.examples[0].targets = [
+      'P:LibTmux.CapturedRelation`1.IsCaptured',
+      'M:LibTmux.Query.QueryExtensions.Matching``1(System.Collections.Generic.IEnumerable{``0},LibTmux.Query.QueryDocument)',
+    ]
     symbols[0].id = 'LibTmux.CapturedRelation.IsCaptured'
     symbols[0].kind = 'property'
     symbols[1].id = 'LibTmux.Query.QueryExtensions.Matching'
@@ -108,8 +150,12 @@ describe('complete C# API programs', () => {
   })
 
   it('rejects unknown source identities, ambiguity and wrong kinds without guessing a short name', () => {
-    for (const target of ['M:LibTmux.Other.ConnectAsync(System.Threading.CancellationToken)',
-      'P:LibTmux.Server.ConnectAsync', 'T:LibTmux.Server.ConnectAsync', 'F:LibTmux.Server']) {
+    for (const target of [
+      'M:LibTmux.Other.ConnectAsync(System.Threading.CancellationToken)',
+      'P:LibTmux.Server.ConnectAsync',
+      'T:LibTmux.Server.ConnectAsync',
+      'F:LibTmux.Server',
+    ]) {
       const { manifest, symbols, read } = fixture()
       manifest.examples[0].targets = [target]
       expect(() => attachCompleteCSharpExamples(symbols, read, source)).toThrow(/target/)
@@ -133,20 +179,27 @@ describe('complete C# API programs', () => {
     }
     const invalid = fixture()
     invalid.manifest.examples[0].sourceFile = 'examples/../private.cs'
-    expect(() => attachCompleteCSharpExamples(invalid.symbols, invalid.read, source)).toThrow('Invalid C# example metadata')
+    expect(() => attachCompleteCSharpExamples(invalid.symbols, invalid.read, source)).toThrow(
+      'Invalid C# example metadata',
+    )
   })
 
   it('requires the exact source revision, SDK, package and setup contract', () => {
     const invalid = fixture()
-    expect(() => attachCompleteCSharpExamples(invalid.symbols, invalid.read, { ...source, revision: 'main' }))
-      .toThrow('full source revision')
+    expect(() => attachCompleteCSharpExamples(invalid.symbols, invalid.read, { ...source, revision: 'main' })).toThrow(
+      'full source revision',
+    )
     invalid.manifest.setupFiles.pop()
-    expect(() => attachCompleteCSharpExamples(invalid.symbols, invalid.read, source)).toThrow('Invalid C# example manifest')
+    expect(() => attachCompleteCSharpExamples(invalid.symbols, invalid.read, source)).toThrow(
+      'Invalid C# example manifest',
+    )
     const sdk = fixture()
     sdk.files.set('global.json', '{"sdk":{"version":"latest"}}\n')
     expect(() => attachCompleteCSharpExamples(sdk.symbols, sdk.read, source)).toThrow('pinned SDK')
     const packageProfile = fixture()
     packageProfile.manifest.profiles.csharp.package = 'LibTmux.FSharp'
-    expect(() => attachCompleteCSharpExamples(packageProfile.symbols, packageProfile.read, source)).toThrow('Invalid C# example profile')
+    expect(() => attachCompleteCSharpExamples(packageProfile.symbols, packageProfile.read, source)).toThrow(
+      'Invalid C# example profile',
+    )
   })
 })
diff --git a/packages/api-model/test/csharp.test.ts b/packages/api-model/test/csharp.test.ts
index 34a9db1e1..d095a1a8c 100644
--- a/packages/api-model/test/csharp.test.ts
+++ b/packages/api-model/test/csharp.test.ts
@@ -19,8 +19,10 @@ async function extract(source: string) {
 }
 
 describe('C# positional records', () => {
-  it.each(['record', 'record class', 'record struct', 'readonly record struct'])('extracts %s properties, constructor and parameter documentation', async (declaration) => {
-    const symbols = await extract(`namespace LibTmux;
+  it.each(['record', 'record class', 'record struct', 'readonly record struct'])(
+    'extracts %s properties, constructor and parameter documentation',
+    async (declaration) => {
+      const symbols = await extract(`namespace LibTmux;
 /// <summary>A command result.</summary>
 /// <param name="ExitStatus">The exit status, or null before completion.</param>
 /// <param name="Output">Rendered lines, including <c>stderr</c>.</param>
@@ -28,19 +30,40 @@ public ${declaration} Result(
     int? ExitStatus,
     IReadOnlyList<string> Output);
 `)
-    const owner = symbols.find((symbol) => symbol.id === 'LibTmux.Result')!
-    expect(owner.doc?.summary).toBe('A command result.')
-    expect(owner.signatures[0]?.params).toEqual([
-      { name: 'ExitStatus', type: 'int?', doc: 'The exit status, or null before completion.' },
-      { name: 'Output', type: 'IReadOnlyList<string>', doc: 'Rendered lines, including <c>stderr</c>.' },
-    ])
-    expect(symbols.filter((symbol) => symbol.parent === owner.id).map((symbol) => ({
-      name: symbol.name, type: symbol.type, kind: symbol.kind, line: symbol.source.line, summary: symbol.doc?.summary,
-    }))).toEqual([
-      { name: 'ExitStatus', type: 'int?', kind: 'property', line: 6, summary: 'The exit status, or null before completion.' },
-      { name: 'Output', type: 'IReadOnlyList<string>', kind: 'property', line: 7, summary: 'Rendered lines, including <c>stderr</c>.' },
-    ])
-  })
+      const owner = symbols.find((symbol) => symbol.id === 'LibTmux.Result')!
+      expect(owner.doc?.summary).toBe('A command result.')
+      expect(owner.signatures[0]?.params).toEqual([
+        { name: 'ExitStatus', type: 'int?', doc: 'The exit status, or null before completion.' },
+        { name: 'Output', type: 'IReadOnlyList<string>', doc: 'Rendered lines, including <c>stderr</c>.' },
+      ])
+      expect(
+        symbols
+          .filter((symbol) => symbol.parent === owner.id)
+          .map((symbol) => ({
+            name: symbol.name,
+            type: symbol.type,
+            kind: symbol.kind,
+            line: symbol.source.line,
+            summary: symbol.doc?.summary,
+          })),
+      ).toEqual([
+        {
+          name: 'ExitStatus',
+          type: 'int?',
+          kind: 'property',
+          line: 6,
+          summary: 'The exit status, or null before completion.',
+        },
+        {
+          name: 'Output',
+          type: 'IReadOnlyList<string>',
+          kind: 'property',
+          line: 7,
+          summary: 'Rendered lines, including <c>stderr</c>.',
+        },
+      ])
+    },
+  )
 
   it('keeps explicitly declared properties and their documentation', async () => {
     const symbols = await extract(`public record Result(string Name) {
@@ -63,10 +86,12 @@ public ${declaration} Result(
     System.StringComparison Comparison = System.StringComparison.Ordinal) {
     public void Read(int count = 4, bool follow = false) {}
 }`)
-    expect(symbols.find((symbol) => symbol.id === 'LibTmux.Result')!.signatures[0].params.map((param) => param.default))
-      .toEqual(['null', 'false', 'true', '-1', '"pending"', 'System.StringComparison.Ordinal'])
-    expect(symbols.find((symbol) => symbol.id === 'LibTmux.Result.Read')!.signatures[0].params.map((param) => param.default))
-      .toEqual(['4', 'false'])
+    expect(
+      symbols.find((symbol) => symbol.id === 'LibTmux.Result')!.signatures[0].params.map((param) => param.default),
+    ).toEqual(['null', 'false', 'true', '-1', '"pending"', 'System.StringComparison.Ordinal'])
+    expect(
+      symbols.find((symbol) => symbol.id === 'LibTmux.Result.Read')!.signatures[0].params.map((param) => param.default),
+    ).toEqual(['4', 'false'])
   })
 
   it('does not turn ordinary class parameters or private records into public properties', async () => {
diff --git a/packages/api-model/test/doxygen.test.ts b/packages/api-model/test/doxygen.test.ts
index 8d08152a7..6768bced2 100644
--- a/packages/api-model/test/doxygen.test.ts
+++ b/packages/api-model/test/doxygen.test.ts
@@ -16,15 +16,20 @@ function extractCompound(xml: string) {
 
 describe('Doxygen public inheritance', () => {
   it('keeps native C++ overload spelling, defaulting, explicit conversion and trailing qualifiers', () => {
-    const symbols = extractCompound(`<compounddef kind="struct"><compoundname>sample::Arguments</compoundname><sectiondef>
+    const symbols =
+      extractCompound(`<compounddef kind="struct"><compoundname>sample::Arguments</compoundname><sectiondef>
       <memberdef kind="function" prot="public"><type/><definition>sample::Arguments::Arguments</definition><qualifiedname>sample::Arguments::Arguments</qualifiedname><name>Arguments</name><argsstring>()=default</argsstring></memberdef>
       <memberdef kind="function" prot="public" explicit="yes"><type/><definition>sample::Arguments::Arguments</definition><qualifiedname>sample::Arguments::Arguments</qualifiedname><name>Arguments</name><argsstring>(FlatArguments values)</argsstring><param><type>FlatArguments</type><declname>values</declname></param></memberdef>
       <memberdef kind="function" prot="public"><type>const Value &amp;</type><definition>const Value &amp; sample::Arguments::get</definition><qualifiedname>sample::Arguments::get</qualifiedname><name>get</name><argsstring>() const &amp; noexcept</argsstring></memberdef>
     </sectiondef><location file="arguments.hpp" line="1"/></compounddef>`)
-    expect(symbols.find((symbol) => symbol.name === 'Arguments' && symbol.kind === 'method')?.signatures.map((signature) => signature.raw)).toEqual([
-      'Arguments()=default;', 'explicit Arguments(FlatArguments values);',
-    ])
-    expect(symbols.find((symbol) => symbol.name === 'get')?.signatures[0].raw).toBe('const Value & get() const & noexcept;')
+    expect(
+      symbols
+        .find((symbol) => symbol.name === 'Arguments' && symbol.kind === 'method')
+        ?.signatures.map((signature) => signature.raw),
+    ).toEqual(['Arguments()=default;', 'explicit Arguments(FlatArguments values);'])
+    expect(symbols.find((symbol) => symbol.name === 'get')?.signatures[0].raw).toBe(
+      'const Value & get() const & noexcept;',
+    )
   })
 
   it('preserves template constraints and nodiscard in C++ declarations', () => {
@@ -38,11 +43,23 @@ describe('Doxygen public inheritance', () => {
       <memberdef kind="function" prot="public" nodiscard="yes"><type>bool</type><definition>bool sample::Value::cancelled</definition><qualifiedname>sample::Value::cancelled</qualifiedname><name>cancelled</name><argsstring>() const noexcept</argsstring></memberdef>
       <memberdef kind="function" prot="public"><type>bool</type><definition>bool sample::Value::valid</definition><qualifiedname>sample::Value::valid</qualifiedname><name>valid</name><argsstring>() const</argsstring><requiresclause>Enabled&lt;T&gt;</requiresclause></memberdef>
     </sectiondef><location file="value.hpp" line="1"/></compounddef>`)
-    expect(symbols.find((symbol) => symbol.kind === 'method' && symbol.name === 'Value')?.signatures[0].raw).toBe('template <std::integral Integer>\nrequires (!std::same_as<std::remove_cv_t<Integer>, bool>)\nValue(Integer item);')
-    expect(symbols.find((symbol) => symbol.kind === 'method' && symbol.name === 'Value')?.signatures[0]).toMatchObject({ typeParams: ['std::integral Integer'], params: [{ name: 'item', type: 'Integer' }], returns: undefined })
-    expect(symbols.find((symbol) => symbol.kind === 'method' && symbol.name === 'Value')?.signatures[0].params).toHaveLength(1)
-    expect(symbols.find((symbol) => symbol.name === 'cancelled')?.signatures[0].raw).toBe('[[nodiscard]] bool cancelled() const noexcept;')
-    expect(symbols.find((symbol) => symbol.name === 'valid')?.signatures[0].raw).toBe('bool valid() const requires Enabled<T>;')
+    expect(symbols.find((symbol) => symbol.kind === 'method' && symbol.name === 'Value')?.signatures[0].raw).toBe(
+      'template <std::integral Integer>\nrequires (!std::same_as<std::remove_cv_t<Integer>, bool>)\nValue(Integer item);',
+    )
+    expect(symbols.find((symbol) => symbol.kind === 'method' && symbol.name === 'Value')?.signatures[0]).toMatchObject({
+      typeParams: ['std::integral Integer'],
+      params: [{ name: 'item', type: 'Integer' }],
+      returns: undefined,
+    })
+    expect(
+      symbols.find((symbol) => symbol.kind === 'method' && symbol.name === 'Value')?.signatures[0].params,
+    ).toHaveLength(1)
+    expect(symbols.find((symbol) => symbol.name === 'cancelled')?.signatures[0].raw).toBe(
+      '[[nodiscard]] bool cancelled() const noexcept;',
+    )
+    expect(symbols.find((symbol) => symbol.name === 'valid')?.signatures[0].raw).toBe(
+      'bool valid() const requires Enabled<T>;',
+    )
   })
 
   it('keeps public bases without exposing private or protected implementation bases', () => {
@@ -102,23 +119,32 @@ describe('Doxygen C declarations', () => {
   }
 
   it('deduplicates external prototypes and definitions without inventing overloads', () => {
-    const symbols = extractC(`
+    const symbols = extractC(
+      `
       <compounddef id="tmux_8h" kind="file"><compoundname>tmux.h</compoundname>
         <sectiondef><memberdef kind="function" id="decl" prot="public" static="no">
           <type>int</type><definition>int server_start</definition><argsstring>(int)</argsstring>
           <name>server_start</name><param><type>int</type><defname>flags</defname></param>
           <location file="tmux.h" line="10" bodyfile="server.c" bodystart="30" declline="10"/>
-        </memberdef></sectiondef></compounddef>`, `
+        </memberdef></sectiondef></compounddef>`,
+      `
       <compounddef id="server_8c" kind="file"><compoundname>server.c</compoundname>
         <sectiondef><memberdef kind="function" id="def" prot="public" static="no">
           <type>int</type><definition>int server_start</definition><argsstring>(int flags)</argsstring>
           <name>server_start</name><param><type>int</type><declname>flags</declname></param>
           <location file="server.c" line="30" bodyfile="server.c" bodystart="30" declline="10"/>
-        </memberdef></sectiondef></compounddef>`)
+        </memberdef></sectiondef></compounddef>`,
+    )
     expect(symbols).toHaveLength(1)
-    expect(symbols[0]).toMatchObject({ id: 'c:function:server_start', qualifiedName: 'server_start', namespace: '',
-      kind: 'function', modifiers: [], source: { file: 'server.c', line: 30 },
-      signatures: [{ raw: 'int server_start(int flags)', params: [{ name: 'flags', type: 'int' }], returns: 'int' }] })
+    expect(symbols[0]).toMatchObject({
+      id: 'c:function:server_start',
+      qualifiedName: 'server_start',
+      namespace: '',
+      kind: 'function',
+      modifiers: [],
+      source: { file: 'server.c', line: 30 },
+      signatures: [{ raw: 'int server_start(int flags)', params: [{ name: 'flags', type: 'int' }], returns: 'int' }],
+    })
   })
 
   it('uses a same-file callback definition line without promoting extern declarations', () => {
@@ -139,20 +165,25 @@ describe('Doxygen C declarations', () => {
         </memberdef>
       </sectiondef></compounddef>`)
     expect(symbols.map((symbol) => symbol.source)).toEqual([
-      { file: 'tmux.h', line: 1928 }, { file: 'tmux.h', line: 20 },
-      { file: 'tmux.h', line: 30 }, { file: 'tmux.h', line: 40 },
+      { file: 'tmux.h', line: 1928 },
+      { file: 'tmux.h', line: 20 },
+      { file: 'tmux.h', line: 30 },
+      { file: 'tmux.h', line: 40 },
     ])
-    const definitions = extractC(`
+    const definitions = extractC(
+      `
       <compounddef id="header" kind="file"><compoundname>a.h</compoundname><sectiondef>
         <memberdef kind="variable" id="external" prot="public" extern="yes"><type>int</type><name>count</name>
           <location file="a.h" line="20" bodyfile="a.h" bodystart="20"/>
         </memberdef>
-      </sectiondef></compounddef>`, `
+      </sectiondef></compounddef>`,
+      `
       <compounddef id="source" kind="file"><compoundname>a.c</compoundname><sectiondef>
         <memberdef kind="variable" id="definition" prot="public"><type>int</type><name>count</name><initializer>= 1</initializer>
           <location file="a.c" line="3" bodyfile="a.c" bodystart="3"/>
         </memberdef>
-      </sectiondef></compounddef>`)
+      </sectiondef></compounddef>`,
+    )
     expect(definitions).toHaveLength(1)
     expect(definitions[0]).toMatchObject({ source: { file: 'a.c', line: 3 }, value: '1' })
   })
@@ -166,14 +197,17 @@ describe('Doxygen C declarations', () => {
         </memberdef>
       </sectiondef><location file="tmux.h" line="1940" bodyfile="tmux.h" bodystart="1940" bodyend="1957"/></compounddef>`)
     expect(symbols.map((symbol) => symbol.source)).toEqual([
-      { file: 'tmux.h', line: 1940 }, { file: 'tmux.h', line: 1956 },
+      { file: 'tmux.h', line: 1940 },
+      { file: 'tmux.h', line: 1956 },
     ])
   })
 
   it('projects only evidenced direct calls, preserving callbacks and file-local identities', () => {
     const ref = (id: string, name: string) => `<ref refid="${id}" kindref="member">${name}</ref>`
-    const row = (line: number, code: string) => `<codeline lineno="${line}"><highlight class="normal">${code}</highlight></codeline>`
-    const symbols = extractC(`
+    const row = (line: number, code: string) =>
+      `<codeline lineno="${line}"><highlight class="normal">${code}</highlight></codeline>`
+    const symbols = extractC(
+      `
       <compounddef id="a" kind="file"><compoundname>a.c</compoundname><sectiondef>
         <memberdef kind="function" id="tick-a" prot="public" static="yes"><type>int</type><name>tick</name>
           <location file="a.c" line="2" bodyfile="a.c" bodystart="2" bodyend="5"/></memberdef>
@@ -203,13 +237,15 @@ describe('Doxygen C declarations', () => {
         <codeline lineno="27"><highlight class="stringliteral">"${ref('tick-a', 'tick')}()"</highlight></codeline>
         ${row(28, `${ref('tick-a', 'EXPANDED_NAME')}();`)}
         ${row(29, `${ref('external', 'external')}();`)}${row(30, `${ref('tick-a', 'tick')};`)}${row(35, '}')}
-      </programlisting></compounddef>`, `
+      </programlisting></compounddef>`,
+      `
       <compounddef id="b" kind="file"><compoundname>b.c</compoundname><sectiondef>
         <memberdef kind="function" id="tick-b" prot="public" static="yes"><name>tick</name><references refid="tick-a">tick</references>
           <location file="b.c" line="2" bodyfile="b.c" bodystart="2" bodyend="5"/></memberdef>
       </sectiondef><programlisting>${row(2, `${ref('tick-b', 'tick')}(void)`)}
         ${row(3, `{ ${ref('tick-b', 'tick')}();`)}${row(4, `${ref('tick-a', 'tick')}();`)}${row(5, '}')}
-      </programlisting></compounddef>`)
+      </programlisting></compounddef>`,
+    )
     const worker = symbols.find((symbol) => symbol.id === 'c:function:worker')!
     expect(worker.references?.filter((edge) => edge.kind === 'call')).toEqual([
       { target: 'c:function:a.c:tick', kind: 'call', sites: [15, 17, 18, 19].map((line) => ({ file: 'a.c', line })) },
@@ -229,31 +265,49 @@ describe('Doxygen C declarations', () => {
     // Doxygen 1.18 gives both definitions the same line-only body span for:
     // int a(void) { return first(); } int b(void) { return second(); }
     const symbols = extractC(`<compounddef id="a_8c" kind="file"><compoundname>a.c</compoundname><sectiondef>
-      ${[['first', 1], ['second', 2], ['a', 3], ['b', 3], ['alone', 4]].map(([name, line]) => `
+      ${[
+        ['first', 1],
+        ['second', 2],
+        ['a', 3],
+        ['b', 3],
+        ['alone', 4],
+      ]
+        .map(
+          ([name, line]) => `
         <memberdef kind="function" id="${name}" prot="public"><type>int</type><name>${name}</name>
           ${name === 'a' ? '<references refid="first">first</references>' : name === 'b' ? '<references refid="second">second</references>' : ''}
           <location file="a.c" line="${line}" bodyfile="a.c" bodystart="${line}" bodyend="${line}"/>
-        </memberdef>`).join('')}
+        </memberdef>`,
+        )
+        .join('')}
       </sectiondef><programlisting>
         <codeline lineno="1"><highlight class="normal">int first(void) { return 1; }</highlight></codeline>
         <codeline lineno="2"><highlight class="normal">int second(void) { return 2; }</highlight></codeline>
         <codeline lineno="3"><highlight class="normal">int <ref refid="a">a</ref>(void) { return <ref refid="first">first</ref>(); } int <ref refid="b">b</ref>(void) { return <ref refid="second">second</ref>(); }</highlight></codeline>
         <codeline lineno="4"><highlight class="normal">int alone(void) { return <ref refid="second">second</ref>(); }</highlight></codeline>
       </programlisting></compounddef>`)
-    expect(symbols.find((symbol) => symbol.name === 'a')?.references).toEqual([{ kind: 'reference', target: 'c:function:first' }])
-    expect(symbols.find((symbol) => symbol.name === 'b')?.references).toEqual([{ kind: 'reference', target: 'c:function:second' }])
+    expect(symbols.find((symbol) => symbol.name === 'a')?.references).toEqual([
+      { kind: 'reference', target: 'c:function:first' },
+    ])
+    expect(symbols.find((symbol) => symbol.name === 'b')?.references).toEqual([
+      { kind: 'reference', target: 'c:function:second' },
+    ])
     expect(symbols.find((symbol) => symbol.name === 'alone')?.references).toEqual([
       { kind: 'call', target: 'c:function:second', sites: [{ file: 'a.c', line: 4 }] },
     ])
   })
 
   it('keeps same-named static functions in different files distinct and treats void as no parameters', () => {
-    const symbols = extractC(...['a.c', 'b.c'].map((file) => `
+    const symbols = extractC(
+      ...['a.c', 'b.c'].map(
+        (file) => `
       <compounddef id="${file}" kind="file"><compoundname>${file}</compoundname><sectiondef>
         <memberdef kind="function" id="${file}_f" prot="public" static="yes">
           <type>void</type><name>tick</name><definition>static void tick</definition><argsstring>(void)</argsstring>
           <param><type>void</type></param><location file="${file}" line="3"/>
-        </memberdef></sectiondef></compounddef>`))
+        </memberdef></sectiondef></compounddef>`,
+      ),
+    )
     expect(symbols.map((symbol) => symbol.id)).toEqual(['c:function:a.c:tick', 'c:function:b.c:tick'])
     expect(symbols.every((symbol) => symbol.signatures[0].params.length === 0)).toBe(true)
   })
@@ -264,27 +318,42 @@ describe('Doxygen C declarations', () => {
         <param><type>struct pane *</type></param><param><type>...</type></param>
         <location file="a.h" line="3"/>
       </memberdef></sectiondef></compounddef>`)
-    expect(symbols[0].signatures[0].params).toEqual([{ name: '', type: 'struct pane *', default: undefined, doc: undefined },
-      { name: '', type: '...', default: undefined, doc: undefined }])
+    expect(symbols[0].signatures[0].params).toEqual([
+      { name: '', type: 'struct pane *', default: undefined, doc: undefined },
+      { name: '', type: '...', default: undefined, doc: undefined },
+    ])
   })
 
   it('retains tag namespaces, nested unions, fields and native type references', () => {
-    const symbols = extractC(`
+    const symbols = extractC(
+      `
       <compounddef id="record" kind="struct"><compoundname>args_value</compoundname>
         <innerclass refid="data">args_value::data</innerclass><location file="tmux.h" line="8"/>
-      </compounddef>`, `
+      </compounddef>`,
+      `
       <compounddef id="data" kind="union"><compoundname>args_value::data</compoundname><sectiondef>
         <memberdef kind="variable" id="field" prot="public"><type>char *</type><name>string</name>
           <location file="tmux.h" line="10"/></memberdef>
-      </sectiondef><location file="tmux.h" line="9"/></compounddef>`, `
+      </sectiondef><location file="tmux.h" line="9"/></compounddef>`,
+      `
       <compounddef id="header" kind="file"><compoundname>tmux.h</compoundname><sectiondef>
         <memberdef kind="function" id="function" prot="public"><type>struct <ref refid="record">args_value</ref> *</type>
           <name>args_value</name><location file="tmux.h" line="20"/></memberdef>
-      </sectiondef></compounddef>`)
-    expect(symbols.find((symbol) => symbol.id === 'c:union:args_value::data')).toMatchObject({ kind: 'union', parent: 'c:struct:args_value' })
-    expect(symbols.find((symbol) => symbol.name === 'string')).toMatchObject({ parent: 'c:union:args_value::data', kind: 'attribute' })
-    expect(symbols.find((symbol) => symbol.kind === 'function')).toMatchObject({ id: 'c:function:args_value',
-      imports: { args_value: 'c:struct:args_value' }, references: [{ target: 'c:struct:args_value', kind: 'type' }] })
+      </sectiondef></compounddef>`,
+    )
+    expect(symbols.find((symbol) => symbol.id === 'c:union:args_value::data')).toMatchObject({
+      kind: 'union',
+      parent: 'c:struct:args_value',
+    })
+    expect(symbols.find((symbol) => symbol.name === 'string')).toMatchObject({
+      parent: 'c:union:args_value::data',
+      kind: 'attribute',
+    })
+    expect(symbols.find((symbol) => symbol.kind === 'function')).toMatchObject({
+      id: 'c:function:args_value',
+      imports: { args_value: 'c:struct:args_value' },
+      references: [{ target: 'c:struct:args_value', kind: 'type' }],
+    })
     expect(symbols.every((symbol) => !symbol.parent || symbols.some((owner) => owner.id === symbol.parent))).toBe(true)
   })
 
@@ -310,7 +379,9 @@ describe('Doxygen C declarations', () => {
         <location file="a.h" line="5"/></memberdef>
     </sectiondef></compounddef>`)
     expect(symbols.find((symbol) => symbol.name === 'OK')).toMatchObject({ parent: 'c:enum:status', value: '2' })
-    expect(symbols.find((symbol) => symbol.name === 'read')?.references).toEqual([{ target: 'c:enum:status::OK', kind: 'reference' }])
+    expect(symbols.find((symbol) => symbol.name === 'read')?.references).toEqual([
+      { target: 'c:enum:status::OK', kind: 'reference' },
+    ])
   })
 })
 
@@ -318,19 +389,34 @@ describe('Doxygen C declaration spelling', () => {
   it('keeps function pointers, array extents, tag links and initializer literal bytes', () => {
     const dir = mkdtempSync(join(tmpdir(), 'libtmux-doxygen-c-spelling-'))
     try {
-      writeFileSync(join(dir, 'native.xml'), `<doxygen><compounddef id="structitem" kind="struct"><compoundname>item</compoundname><sectiondef>
+      writeFileSync(
+        join(dir, 'native.xml'),
+        `<doxygen><compounddef id="structitem" kind="struct"><compoundname>item</compoundname><sectiondef>
         <memberdef id="field" kind="variable" prot="public"><type>void(*)</type><name>callback</name><argsstring>(struct item *)</argsstring><location file="a.h" line="4"/></memberdef>
         <memberdef id="bits" kind="variable" prot="public"><type>unsigned int</type><name>flag</name><bitfield>1</bitfield><location file="a.h" line="4"/></memberdef>
         <memberdef id="array" kind="variable" prot="public"><type>char</type><name>label</name><argsstring>[32]</argsstring><initializer>= &quot;two  spaces &amp;quot;&quot;</initializer><location file="a.h" line="5"/></memberdef>
-      </sectiondef><location file="a.h" line="3"/></compounddef></doxygen>`)
-      writeFileSync(join(dir, 'function.xml'), `<doxygen><compounddef id="f" kind="file"><compoundname>a.c</compoundname><sectiondef>
+      </sectiondef><location file="a.h" line="3"/></compounddef></doxygen>`,
+      )
+      writeFileSync(
+        join(dir, 'function.xml'),
+        `<doxygen><compounddef id="f" kind="file"><compoundname>a.c</compoundname><sectiondef>
         <memberdef id="function" kind="function" prot="public"><type>struct item *</type><name>item</name><location file="a.c" line="10"/></memberdef>
-      </sectiondef></compounddef></doxygen>`)
+      </sectiondef></compounddef></doxygen>`,
+      )
       const symbols = extractDoxygen(dir, '', { language: 'c' })
-      expect(symbols.find((symbol) => symbol.name === 'callback')).toMatchObject({ qualifiedName: 'item.callback', signatures: [{ raw: 'void(*callback)(struct item *);', params: [] }] })
+      expect(symbols.find((symbol) => symbol.name === 'callback')).toMatchObject({
+        qualifiedName: 'item.callback',
+        signatures: [{ raw: 'void(*callback)(struct item *);', params: [] }],
+      })
       expect(symbols.find((symbol) => symbol.name === 'flag')?.signatures[0].raw).toBe('unsigned int flag : 1;')
-      expect(symbols.find((symbol) => symbol.name === 'label')).toMatchObject({ signatures: [{ raw: 'char label[32] = "two  spaces &quot;";', params: [] }], value: '"two  spaces &quot;"' })
-      expect(symbols.find((symbol) => symbol.kind === 'function')).toMatchObject({ imports: { item: 'c:struct:item' }, references: [{ kind: 'type', target: 'c:struct:item' }] })
+      expect(symbols.find((symbol) => symbol.name === 'label')).toMatchObject({
+        signatures: [{ raw: 'char label[32] = "two  spaces &quot;";', params: [] }],
+        value: '"two  spaces &quot;"',
+      })
+      expect(symbols.find((symbol) => symbol.kind === 'function')).toMatchObject({
+        imports: { item: 'c:struct:item' },
+        references: [{ kind: 'type', target: 'c:struct:item' }],
+      })
       expect(symbols.find((symbol) => symbol.kind === 'struct')?.signatures[0].raw).toBe('struct item;')
     } finally {
       rmSync(dir, { recursive: true, force: true })
@@ -342,10 +428,20 @@ describe('Doxygen C macro identity', () => {
   it('keeps macros distinct from enum values and native callable symbols', () => {
     const dir = mkdtempSync(join(tmpdir(), 'libtmux-doxygen-macro-'))
     try {
-      writeFileSync(join(dir, 'a.xml'), `<doxygen><compounddef id="a" kind="file"><compoundname>a.h</compoundname><sectiondef>
+      writeFileSync(
+        join(dir, 'a.xml'),
+        `<doxygen><compounddef id="a" kind="file"><compoundname>a.h</compoundname><sectiondef>
         <memberdef id="macro" kind="define" prot="public"><name>CHECK</name><param><defname>x</defname></param><initializer>((x) != 0)</initializer><location file="a.h" line="3"/></memberdef>
-      </sectiondef></compounddef></doxygen>`)
-      expect(extractDoxygen(dir, '', { language: 'c' })).toMatchObject([{ id: 'c:define:a.h:CHECK', kind: 'constant', modifiers: ['macro'], signatures: [{ raw: '#define CHECK(x) ((x) != 0)', params: [] }] }])
+      </sectiondef></compounddef></doxygen>`,
+      )
+      expect(extractDoxygen(dir, '', { language: 'c' })).toMatchObject([
+        {
+          id: 'c:define:a.h:CHECK',
+          kind: 'constant',
+          modifiers: ['macro'],
+          signatures: [{ raw: '#define CHECK(x) ((x) != 0)', params: [] }],
+        },
+      ])
     } finally {
       rmSync(dir, { recursive: true, force: true })
     }
@@ -356,16 +452,41 @@ describe('Doxygen anonymous C display', () => {
   it('keeps native identities while excluding synthetic names from source syntax', () => {
     const dir = mkdtempSync(join(tmpdir(), 'libtmux-doxygen-anonymous-'))
     try {
-      writeFileSync(join(dir, 'a.xml'), `<doxygen><compounddef id="anon" kind="struct"><compoundname>client::[struct].entry</compoundname><location file="a.h" line="3"/></compounddef></doxygen>`)
-      writeFileSync(join(dir, 'b.xml'), `<doxygen><compounddef id="global" kind="struct"><compoundname>[struct].table</compoundname><location file="a.h" line="4"/></compounddef></doxygen>`)
-      writeFileSync(join(dir, 'c.xml'), `<doxygen><compounddef id="owner" kind="struct"><compoundname>client</compoundname><innerclass refid="anon">client::[struct].entry</innerclass><sectiondef>
+      writeFileSync(
+        join(dir, 'a.xml'),
+        `<doxygen><compounddef id="anon" kind="struct"><compoundname>client::[struct].entry</compoundname><location file="a.h" line="3"/></compounddef></doxygen>`,
+      )
+      writeFileSync(
+        join(dir, 'b.xml'),
+        `<doxygen><compounddef id="global" kind="struct"><compoundname>[struct].table</compoundname><location file="a.h" line="4"/></compounddef></doxygen>`,
+      )
+      writeFileSync(
+        join(dir, 'c.xml'),
+        `<doxygen><compounddef id="owner" kind="struct"><compoundname>client</compoundname><innerclass refid="anon">client::[struct].entry</innerclass><sectiondef>
         <memberdef id="field" kind="variable" prot="public"><type>struct client::@123456</type><name>entry</name><location file="a.h" line="3"/></memberdef>
-      </sectiondef><location file="a.h" line="2"/></compounddef></doxygen>`)
+      </sectiondef><location file="a.h" line="2"/></compounddef></doxygen>`,
+      )
       const symbols = extractDoxygen(dir, '', { language: 'c' })
-      expect(symbols[0]).toMatchObject({ id: 'c:struct:client::[struct].entry', name: 'entry (anonymous struct)', qualifiedName: 'client.entry (anonymous struct)', signatures: [] })
-      expect(symbols[1]).toMatchObject({ id: 'c:struct:[struct].table', name: 'table (anonymous struct)', signatures: [] })
-      expect(symbols.find((symbol) => symbol.id === 'c:struct:client::entry')).toMatchObject({ type: 'anonymous struct', signatures: [{ raw: undefined, params: [] }] })
-      expect(symbols.every((symbol) => !symbol.signatures.some((signature) => /@123456|\[struct\]/.test(signature.raw ?? '')))).toBe(true)
+      expect(symbols[0]).toMatchObject({
+        id: 'c:struct:client::[struct].entry',
+        name: 'entry (anonymous struct)',
+        qualifiedName: 'client.entry (anonymous struct)',
+        signatures: [],
+      })
+      expect(symbols[1]).toMatchObject({
+        id: 'c:struct:[struct].table',
+        name: 'table (anonymous struct)',
+        signatures: [],
+      })
+      expect(symbols.find((symbol) => symbol.id === 'c:struct:client::entry')).toMatchObject({
+        type: 'anonymous struct',
+        signatures: [{ raw: undefined, params: [] }],
+      })
+      expect(
+        symbols.every(
+          (symbol) => !symbol.signatures.some((signature) => /@123456|\[struct\]/.test(signature.raw ?? '')),
+        ),
+      ).toBe(true)
     } finally {
       rmSync(dir, { recursive: true, force: true })
     }
diff --git a/packages/api-model/test/extensions.test.ts b/packages/api-model/test/extensions.test.ts
index 04612006f..cc941e18a 100644
--- a/packages/api-model/test/extensions.test.ts
+++ b/packages/api-model/test/extensions.test.ts
@@ -51,12 +51,7 @@ describe('an extension block belongs to the type it extends', () => {
   it('leaves a block alone when the name is ambiguous', () => {
     // Rust lets two modules declare different types called `Error`. Attaching
     // the block to either would be a guess.
-    const symbols = [
-      sym('a.Error', 'enum'),
-      sym('b.Error', 'struct'),
-      sym('c.Error', 'class'),
-      member('c.Error.code'),
-    ]
+    const symbols = [sym('a.Error', 'enum'), sym('b.Error', 'struct'), sym('c.Error', 'class'), member('c.Error.code')]
     expect(mergeExtensions(symbols, 'class').map((s) => s.id)).toEqual(symbols.map((s) => s.id))
   })
 
@@ -71,12 +66,7 @@ describe('an extension block belongs to the type it extends', () => {
   it('still leaves one alone when the name is ambiguous rather than absent', () => {
     // Absent and ambiguous are different: nothing to attach to versus more
     // than one candidate. Dropping the second would lose real members.
-    const symbols = [
-      sym('a.Error', 'enum'),
-      sym('b.Error', 'struct'),
-      sym('c.Error', 'class'),
-      member('c.Error.code'),
-    ]
+    const symbols = [sym('a.Error', 'enum'), sym('b.Error', 'struct'), sym('c.Error', 'class'), member('c.Error.code')]
     expect(mergeExtensions(symbols, 'class').map((s) => s.id)).toEqual(symbols.map((s) => s.id))
   })
 
diff --git a/packages/api-model/test/federation.test.ts b/packages/api-model/test/federation.test.ts
index e032dc13a..8391015d6 100644
--- a/packages/api-model/test/federation.test.ts
+++ b/packages/api-model/test/federation.test.ts
@@ -79,10 +79,7 @@ describe('inventories are scoped to their own language', () => {
     for (const port of OTHER_PORTS) {
       for (const name of [...POACHED, 'Stream.filter()']) {
         const res = r.resolve(port, name)
-        expect(
-          res.how === 'federated' ? res.project : '',
-          `${port} resolved ${name}`,
-        ).not.toBe('Python')
+        expect(res.how === 'federated' ? res.project : '', `${port} resolved ${name}`).not.toBe('Python')
       }
     }
   })
@@ -152,9 +149,7 @@ describe('constructors do not contest their own type', () => {
     // The symbol graph names a method `unsetEnvironment(_:in:)`; prose writes
     // `unsetEnvironment`. Both must find it.
     const r = new Resolver([
-      model('swift', [
-        { id: 'TmuxServer.unsetEnvironment(_:in:)', name: 'unsetEnvironment(_:in:)', kind: 'method' },
-      ]),
+      model('swift', [{ id: 'TmuxServer.unsetEnvironment(_:in:)', name: 'unsetEnvironment(_:in:)', kind: 'method' }]),
     ] as never)
     expect(r.resolve('swift', 'unsetEnvironment').how).toBe('unique')
   })
@@ -170,8 +165,7 @@ describe('constructors do not contest their own type', () => {
  * two characters.
  */
 describe('module names', () => {
-  const sym = (id: string, name: string) =>
-    ({ id, name, kind: 'class', signatures: [], docs: [] }) as never
+  const sym = (id: string, name: string) => ({ id, name, kind: 'class', signatures: [], docs: [] }) as never
 
   it('reads a module off a public id in every separator style', () => {
     expect(moduleOf(sym('libtmux.neo.Obj', 'Obj'))).toBe('libtmux.neo')
@@ -222,8 +216,7 @@ describe('module names', () => {
  * uses for its anchor.
  */
 describe('modules resolve as destinations', () => {
-  const sym = (id: string, name: string) =>
-    ({ id, name, kind: 'class', signatures: [], docs: [] }) as never
+  const sym = (id: string, name: string) => ({ id, name, kind: 'class', signatures: [], docs: [] }) as never
   const r = new Resolver([
     {
       port: 'py',
@@ -353,9 +346,9 @@ describe('enum variants reach the model', () => {
   it.runIf(existsSync(join(here, '../../../site/src/data/api/rs.json')))(
     'every enum with variants has them attached, not floating',
     () => {
-      const model = JSON.parse(
-        readFileSync(join(here, '../../../site/src/data/api/rs.json'), 'utf8'),
-      ) as { symbols: { id: string; kind: string; parent?: string }[] }
+      const model = JSON.parse(readFileSync(join(here, '../../../site/src/data/api/rs.json'), 'utf8')) as {
+        symbols: { id: string; kind: string; parent?: string }[]
+      }
       const enumIds = new Set(model.symbols.filter((s) => s.kind === 'enum').map((s) => s.id))
       const attached = model.symbols.filter((s) => s.parent && enumIds.has(s.parent))
       expect(attached.length).toBeGreaterThan(100)
@@ -389,12 +382,7 @@ describe('JDK and DOM federation', () => {
   const resolver = () => {
     const r = new Resolver([])
     if (jdk) {
-      r.addInventory(
-        'Java SE',
-        'https://docs.oracle.com/en/java/javase/21/docs/api/',
-        jdk.entries,
-        ['java'],
-      )
+      r.addInventory('Java SE', 'https://docs.oracle.com/en/java/javase/21/docs/api/', jdk.entries, ['java'])
     }
     if (dom) r.addInventory('MDN', 'https://developer.mozilla.org/', dom.entries, ['ts'])
     return r
@@ -417,9 +405,7 @@ describe('JDK and DOM federation', () => {
     expect(res.how).toBe('federated')
     // A language builtin, not a DOM interface. MDN files the two apart and so
     // must the inventory: `Web/API/Promise` is a page that does not exist.
-    expect(res.how === 'federated' && res.href).toContain(
-      'Web/JavaScript/Reference/Global_Objects/Promise',
-    )
+    expect(res.how === 'federated' && res.href).toContain('Web/JavaScript/Reference/Global_Objects/Promise')
   })
 
   it.runIf(dom)('keeps DOM interfaces under Web/API', () => {
diff --git a/packages/api-model/test/fsharp-examples.test.ts b/packages/api-model/test/fsharp-examples.test.ts
index f820037c0..18279f478 100644
--- a/packages/api-model/test/fsharp-examples.test.ts
+++ b/packages/api-model/test/fsharp-examples.test.ts
@@ -5,16 +5,28 @@ import type { ApiSymbol } from '../src/model.ts'
 const source = { repo: 'libtmux/libtmux-dotnet', revision: 'a'.repeat(40) }
 const fixture = () => {
   const program = {
-    id: 'fsharp-SnapshotAccess', profile: 'fsharp', title: 'Read captured state',
+    id: 'fsharp-SnapshotAccess',
+    profile: 'fsharp',
+    title: 'Read captured state',
     description: 'Read captured state without confusing it with an uncaptured relation.',
     sourceFile: 'examples/LibTmux.FSharp.Examples/Programs/SnapshotAccess.fs',
-    targets: ['M:LibTmux.FSharp.Snapshot.relation``1(LibTmux.CapturedRelation{``0})',
-      'T:LibTmux.FSharp.CaptureState`1'], output: 'captured\n',
+    targets: [
+      'M:LibTmux.FSharp.Snapshot.relation``1(LibTmux.CapturedRelation{``0})',
+      'T:LibTmux.FSharp.CaptureState`1',
+    ],
+    output: 'captured\n',
   }
   const manifest = {
     schemaVersion: 1,
-    profiles: { fsharp: { package: 'LibTmux.FSharp', projectFile: 'examples/api/fsharp/Example.fsproj', entrypoint: 'Program.fs' } },
-    setupFiles: ['global.json', 'examples/api/NuGet.config'], examples: [program],
+    profiles: {
+      fsharp: {
+        package: 'LibTmux.FSharp',
+        projectFile: 'examples/api/fsharp/Example.fsproj',
+        entrypoint: 'Program.fs',
+      },
+    },
+    setupFiles: ['global.json', 'examples/api/NuGet.config'],
+    examples: [program],
   }
   const files = new Map([
     ['global.json', '{"sdk":{"version":"10.0.302"}}\n'],
@@ -23,14 +35,31 @@ const fixture = () => {
     [program.sourceFile, '\n// Complete source file, including every blank line.\nopen LibTmux.FSharp\n\n'],
   ])
   const symbols: ApiSymbol[] = [
-    { id: 'LibTmux.FSharp.Snapshot.relation', name: 'relation', kind: 'function', modifiers: [],
-      signatures: [], source: { file: 'Library.fsi' }, slug: 'snapshot-relation',
-      doc: { summary: 'Native function documentation.', examples: [{ lang: 'fsharp', code: 'existing inline example' }] } },
-    { id: 'LibTmux.FSharp.CaptureState', name: 'CaptureState', kind: 'enum', modifiers: [],
-      signatures: [], source: { file: 'Library.fsi' }, slug: 'capturestate',
-      doc: { summary: 'Native type documentation.' } },
+    {
+      id: 'LibTmux.FSharp.Snapshot.relation',
+      name: 'relation',
+      kind: 'function',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'Library.fsi' },
+      slug: 'snapshot-relation',
+      doc: {
+        summary: 'Native function documentation.',
+        examples: [{ lang: 'fsharp', code: 'existing inline example' }],
+      },
+    },
+    {
+      id: 'LibTmux.FSharp.CaptureState',
+      name: 'CaptureState',
+      kind: 'enum',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'Library.fsi' },
+      slug: 'capturestate',
+      doc: { summary: 'Native type documentation.' },
+    },
   ]
-  const read = (path: string) => path === 'examples/api/manifest.json' ? JSON.stringify(manifest) : files.get(path)
+  const read = (path: string) => (path === 'examples/api/manifest.json' ? JSON.stringify(manifest) : files.get(path))
   return { manifest, files, symbols, read }
 }
 
@@ -48,8 +77,12 @@ describe('complete F# API programs', () => {
       expect(blocks).toHaveLength(7)
       expect(blocks[0].code).toContain(`checkout --detach ${source.revision}`)
       expect(blocks[0].intro).toContain('.NET SDK 10.0.302')
-      for (const [i, path] of ['global.json', 'examples/api/NuGet.config',
-        'examples/api/fsharp/Example.fsproj', manifest.examples[0].sourceFile].entries()) {
+      for (const [i, path] of [
+        'global.json',
+        'examples/api/NuGet.config',
+        'examples/api/fsharp/Example.fsproj',
+        manifest.examples[0].sourceFile,
+      ].entries()) {
         expect(blocks[i + 1].code).toBe(files.get(path))
         expect(blocks[i + 1].sourceUrl).toBe(`https://github.com/${source.repo}/blob/${source.revision}/${path}`)
       }
@@ -65,8 +98,13 @@ describe('complete F# API programs', () => {
   it('preserves a second complete program on the same API page', () => {
     const { manifest, files, symbols, read } = fixture()
     const first = manifest.examples[0]
-    const second = { ...first, id: 'fsharp-LookupFailures',
-      sourceFile: first.sourceFile.replace('SnapshotAccess', 'LookupFailures'), targets: [first.targets[0]], output: 'failure kept\n' }
+    const second = {
+      ...first,
+      id: 'fsharp-LookupFailures',
+      sourceFile: first.sourceFile.replace('SnapshotAccess', 'LookupFailures'),
+      targets: [first.targets[0]],
+      output: 'failure kept\n',
+    }
     files.set(second.sourceFile, 'printfn "failure kept"\n')
     manifest.examples.push(second)
     attachCompleteFSharpExamples(symbols, read, source)
@@ -89,7 +127,9 @@ describe('complete F# API programs', () => {
     for (const target of ['M:LibTmux.FSharp.Other.relation(System.String)', 'T:LibTmux.FSharp.Snapshot.relation']) {
       const { manifest, symbols, read } = fixture()
       manifest.examples[0].targets = [target]
-      expect(() => attachCompleteFSharpExamples(symbols, read, source)).toThrow('must resolve once with its native kind')
+      expect(() => attachCompleteFSharpExamples(symbols, read, source)).toThrow(
+        'must resolve once with its native kind',
+      )
     }
     const ambiguous = fixture()
     ambiguous.symbols.push(structuredClone(ambiguous.symbols[0]))
@@ -97,7 +137,10 @@ describe('complete F# API programs', () => {
   })
 
   it('rejects repeated targets, including two compiler signatures mapping to one source name', () => {
-    for (const target of [fixture().manifest.examples[0].targets[0], 'M:LibTmux.FSharp.Snapshot.relation(System.String)']) {
+    for (const target of [
+      fixture().manifest.examples[0].targets[0],
+      'M:LibTmux.FSharp.Snapshot.relation(System.String)',
+    ]) {
       const { manifest, symbols, read } = fixture()
       manifest.examples[0].targets.push(target)
       expect(() => attachCompleteFSharpExamples(symbols, read, source)).toThrow('Duplicate F# example target')
@@ -112,15 +155,20 @@ describe('complete F# API programs', () => {
     }
     const invalid = fixture()
     invalid.manifest.examples[0].sourceFile = 'examples/../private.fs'
-    expect(() => attachCompleteFSharpExamples(invalid.symbols, invalid.read, source)).toThrow('Invalid F# example metadata')
+    expect(() => attachCompleteFSharpExamples(invalid.symbols, invalid.read, source)).toThrow(
+      'Invalid F# example metadata',
+    )
   })
 
   it('requires the exact source revision, SDK and setup contract', () => {
     const invalid = fixture()
-    expect(() => attachCompleteFSharpExamples(invalid.symbols, invalid.read, { ...source, revision: 'main' }))
-      .toThrow('full source revision')
+    expect(() => attachCompleteFSharpExamples(invalid.symbols, invalid.read, { ...source, revision: 'main' })).toThrow(
+      'full source revision',
+    )
     invalid.manifest.setupFiles.pop()
-    expect(() => attachCompleteFSharpExamples(invalid.symbols, invalid.read, source)).toThrow('Invalid F# example manifest')
+    expect(() => attachCompleteFSharpExamples(invalid.symbols, invalid.read, source)).toThrow(
+      'Invalid F# example manifest',
+    )
     const sdk = fixture()
     sdk.files.set('global.json', '{"sdk":{"version":"latest"}}\n')
     expect(() => attachCompleteFSharpExamples(sdk.symbols, sdk.read, source)).toThrow('pinned SDK')
diff --git a/packages/api-model/test/fsharp.test.ts b/packages/api-model/test/fsharp.test.ts
index 5cc7d658f..f7b0c6b42 100644
--- a/packages/api-model/test/fsharp.test.ts
+++ b/packages/api-model/test/fsharp.test.ts
@@ -3,19 +3,41 @@ import { extractFSharpArtifact } from '../src/languages/fsharp.ts'
 import { ownersOf } from '../src/prose.ts'
 
 const declaration = {
-  id: 'LibTmux.FSharp.Filter', name: 'Filter', kind: 'class', parent: 'LibTmux.FSharp',
-  file: 'Query.fsi', line: 10, signature: "type Filter<'T>", parameters: [], returns: '', documentation: '',
+  id: 'LibTmux.FSharp.Filter',
+  name: 'Filter',
+  kind: 'class',
+  parent: 'LibTmux.FSharp',
+  file: 'Query.fsi',
+  line: 10,
+  signature: "type Filter<'T>",
+  parameters: [],
+  returns: '',
+  documentation: '',
   namespaces: ['LibTmux'],
 }
-const artifact = { schema: 1, port: 'fsharp', compiler: '43.10.302.0', declarations: [
-  declaration,
-  { ...declaration, kind: 'module', signature: 'module Filter', line: 15 },
-  { ...declaration, id: 'LibTmux.FSharp.Filter.eq', name: 'eq', kind: 'function', parent: 'LibTmux.FSharp.Filter',
-    signature: "val eq: value: 'Value -> field: Field<'T, 'Value> -> Filter<'T>",
-    parameters: [{ name: 'value', type: "'Value", optional: false }, { name: 'field', type: "Field<'T, 'Value>", optional: false }],
-    returns: "Filter<'T>", documentation: '<summary>Match a field.</summary><param name="value">The expected value.</param>',
-  },
-] }
+const artifact = {
+  schema: 1,
+  port: 'fsharp',
+  compiler: '43.10.302.0',
+  declarations: [
+    declaration,
+    { ...declaration, kind: 'module', signature: 'module Filter', line: 15 },
+    {
+      ...declaration,
+      id: 'LibTmux.FSharp.Filter.eq',
+      name: 'eq',
+      kind: 'function',
+      parent: 'LibTmux.FSharp.Filter',
+      signature: "val eq: value: 'Value -> field: Field<'T, 'Value> -> Filter<'T>",
+      parameters: [
+        { name: 'value', type: "'Value", optional: false },
+        { name: 'field', type: "Field<'T, 'Value>", optional: false },
+      ],
+      returns: "Filter<'T>",
+      documentation: '<summary>Match a field.</summary><param name="value">The expected value.</param>',
+    },
+  ],
+}
 
 it('preserves F# currying and type/module identity for member navigation', () => {
   const model = extractFSharpArtifact(artifact, 'a'.repeat(40))
@@ -25,15 +47,21 @@ it('preserves F# currying and type/module identity for member navigation', () =>
   expect(model.symbols[0].signatures.map((sig) => sig.raw)).toEqual(["type Filter<'T>", 'module Filter'])
   expect(model.symbols[1].signatures[0]).toMatchObject({
     raw: artifact.declarations[2].signature,
-    params: [{ name: 'value', type: "'Value", doc: 'The expected value.' }, { name: 'field', type: "Field<'T, 'Value>" }],
+    params: [
+      { name: 'value', type: "'Value", doc: 'The expected value.' },
+      { name: 'field', type: "Field<'T, 'Value>" },
+    ],
     returns: "Filter<'T>",
   })
 })
 
 it('rejects empty, unversioned, duplicate or incomplete F# compiler output', () => {
   for (const invalid of [
-    {}, { ...artifact, declarations: [] }, { ...artifact, compiler: undefined },
+    {},
+    { ...artifact, declarations: [] },
+    { ...artifact, compiler: undefined },
     { ...artifact, declarations: [declaration, declaration] },
     { ...artifact, declarations: [{ ...declaration, signature: '' }] },
-  ]) expect(() => extractFSharpArtifact(invalid)).toThrow()
+  ])
+    expect(() => extractFSharpArtifact(invalid)).toThrow()
 })
diff --git a/packages/api-model/test/go-examples.test.ts b/packages/api-model/test/go-examples.test.ts
index fdc2f649e..2719504af 100644
--- a/packages/api-model/test/go-examples.test.ts
+++ b/packages/api-model/test/go-examples.test.ts
@@ -17,18 +17,27 @@ func ExampleServer_Sessions_complete() {
 }
 `
 const symbol = (): ApiSymbol => ({
-  id: 'tmux.Server.Sessions', name: 'Sessions', kind: 'method', parent: 'tmux.Server',
-  source: { file: 'tmux/hierarchy.go', line: 7 }, signatures: [],
+  id: 'tmux.Server.Sessions',
+  name: 'Sessions',
+  kind: 'method',
+  parent: 'tmux.Server',
+  source: { file: 'tmux/hierarchy.go', line: 7 },
+  signatures: [],
   doc: { summary: 'Original contract.', examples: [{ lang: 'go', code: 'existing' }] },
 })
 
 describe('complete native Go examples', () => {
   it('attaches exact file bytes, description, dependency pin, and native run command', async () => {
     const examples = await readCompleteGoExamples([{ file, code }])
-    expect(examples).toEqual([{
-      symbol: 'tmux.Server.Sessions', file, code, output: 'sessions: 2',
-      intro: 'List sessions from the server.\nKeep the returned records for later inspection.',
-    }])
+    expect(examples).toEqual([
+      {
+        symbol: 'tmux.Server.Sessions',
+        file,
+        code,
+        output: 'sessions: 2',
+        intro: 'List sessions from the server.\nKeep the returned records for later inspection.',
+      },
+    ])
     const target = symbol()
     attachCompleteGoExamples([target], examples, source)
     expect(target.id).toBe('tmux.Server.Sessions')
@@ -36,7 +45,9 @@ describe('complete native Go examples', () => {
     const blocks = target.doc!.examples!
     expect(blocks.map((block) => block.lang)).toEqual(['go', 'console', 'go', 'go', 'console'])
     expect(blocks[0].code).toBe('existing')
-    expect(blocks[1].code).toBe(`$ git clone https://github.com/libtmux/libtmux-go.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`)
+    expect(blocks[1].code).toBe(
+      `$ git clone https://github.com/libtmux/libtmux-go.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`,
+    )
     expect(blocks[2].code).toContain('replace github.com/libtmux/libtmux-go => ./libtmux-source')
     expect(blocks[3].code).toBe(code)
     expect(blocks[3].sourceUrl).toBe(`https://github.com/${source.repo}/blob/${source.revision}/${file}`)
@@ -45,18 +56,18 @@ describe('complete native Go examples', () => {
   })
 
   it('uses native function and receiver-method names for attachment', async () => {
-    const examples = await readCompleteGoExamples([
-      { file, code: code.replace('Server_Sessions', 'NewServer') },
-    ])
+    const examples = await readCompleteGoExamples([{ file, code: code.replace('Server_Sessions', 'NewServer') }])
     expect(examples[0].symbol).toBe('tmux.NewServer')
   })
 
   it('omits ordinary examples, tests, and non-test source files', async () => {
-    expect(await readCompleteGoExamples([
-      { file, code: code.replace('_complete', '') },
-      { file, code: code.replace('ExampleServer_Sessions_complete', 'TestServer') },
-      { file: 'tmux/server.go', code },
-    ])).toEqual([])
+    expect(
+      await readCompleteGoExamples([
+        { file, code: code.replace('_complete', '') },
+        { file, code: code.replace('ExampleServer_Sessions_complete', 'TestServer') },
+        { file: 'tmux/server.go', code },
+      ]),
+    ).toEqual([])
   })
 
   it.each([
@@ -74,8 +85,12 @@ describe('complete native Go examples', () => {
   })
 
   it('rejects duplicate examples and missing or ambiguous API targets', async () => {
-    await expect(readCompleteGoExamples([{ file, code }, { file: 'tmux/other_test.go', code }]))
-      .rejects.toThrow(/duplicate example/)
+    await expect(
+      readCompleteGoExamples([
+        { file, code },
+        { file: 'tmux/other_test.go', code },
+      ]),
+    ).rejects.toThrow(/duplicate example/)
     const examples = await readCompleteGoExamples([{ file, code }])
     expect(() => attachCompleteGoExamples([], examples, source)).toThrow(/resolve once/)
     expect(() => attachCompleteGoExamples([symbol(), symbol()], examples, source)).toThrow(/resolve once/)
@@ -83,9 +98,11 @@ describe('complete native Go examples', () => {
 
   it('rejects mutable refs or missing dependency floors', async () => {
     const examples = await readCompleteGoExamples([{ file, code }])
-    expect(() => attachCompleteGoExamples([symbol()], examples, { ...source, revision: 'main' }))
-      .toThrow(/full source revision/)
-    expect(() => attachCompleteGoExamples([symbol()], examples, { ...source, goVersion: '' }))
-      .toThrow(/module Go version/)
+    expect(() => attachCompleteGoExamples([symbol()], examples, { ...source, revision: 'main' })).toThrow(
+      /full source revision/,
+    )
+    expect(() => attachCompleteGoExamples([symbol()], examples, { ...source, goVersion: '' })).toThrow(
+      /module Go version/,
+    )
   })
 })
diff --git a/packages/api-model/test/guarantees.test.ts b/packages/api-model/test/guarantees.test.ts
index aa040174b..124a49191 100644
--- a/packages/api-model/test/guarantees.test.ts
+++ b/packages/api-model/test/guarantees.test.ts
@@ -69,20 +69,17 @@ count = sum(len(entries) for entries in inv.values())
 names = sorted({name for entries in inv.values() for name in entries})
 print(json.dumps({"count": count, "domains": sorted(inv), "sample": names[:3]}))
 `
-    const out = execFileSync(
-      'uv',
-      ['run', '--with', 'sphinx', 'python', '-c', script, file],
-      { encoding: 'utf8', timeout: 120_000 },
-    )
+    const out = execFileSync('uv', ['run', '--with', 'sphinx', 'python', '-c', script, file], {
+      encoding: 'utf8',
+      timeout: 120_000,
+    })
     const result = JSON.parse(out.trim().split('\n').pop() ?? '{}') as {
       count: number
       domains: string[]
       sample: string[]
     }
 
-    expect(result.count, `${port}: Sphinx read a different number of entries`).toBe(
-      model.symbols.length,
-    )
+    expect(result.count, `${port}: Sphinx read a different number of entries`).toBe(model.symbols.length)
     expect(result.domains.length, `${port}: no domains`).toBeGreaterThan(0)
   })
 })
@@ -102,9 +99,7 @@ describe('names are representable', () => {
   it.each(PORTS)('%s has no whitespace in any name or id', (port) => {
     const model = load(port)
     if (!model) return
-    const bad = model.symbols.filter(
-      (s) => /\s/.test(s.name) || /\s/.test(s.id) || /\s/.test(s.publicId ?? ''),
-    )
+    const bad = model.symbols.filter((s) => /\s/.test(s.name) || /\s/.test(s.id) || /\s/.test(s.publicId ?? ''))
     expect(
       bad.slice(0, 5).map((s) => `${s.kind} ${JSON.stringify(s.name)} (${s.id})`),
       `${port}: ${bad.length} names carry whitespace`,
@@ -178,8 +173,9 @@ describe('the resolver keeps its rate', () => {
       }
     }
     const rate = 1 - failures.length / attempted.length
-    expect(rate, `${failures.length}/${attempted.length} unresolved:\n${failures.join('\n')}`)
-      .toBeGreaterThanOrEqual(0.85)
+    expect(rate, `${failures.length}/${attempted.length} unresolved:\n${failures.join('\n')}`).toBeGreaterThanOrEqual(
+      0.85,
+    )
   })
 
   it('still refuses what it should refuse', () => {
@@ -236,7 +232,10 @@ describe('doc comments give up their examples', () => {
       'edition2024',
     ])
     const wrong = blocks.filter((b) => attributes.has(b.lang))
-    expect(wrong.slice(0, 3).map((b) => b.lang), `${port} mis-tagged blocks`).toEqual([])
+    expect(
+      wrong.slice(0, 3).map((b) => b.lang),
+      `${port} mis-tagged blocks`,
+    ).toEqual([])
     const auxiliary = new Set(['console', 'text', 'toml'])
     const application = blocks.filter((b) => !auxiliary.has(b.lang))
     const own = application.filter((b) => b.lang === lang).length
@@ -272,13 +271,18 @@ describe('each language gets its own spelling of a cross-reference', () => {
     spans.filter((s) => s.kind === 'ref').map((s) => (s as { target: string }).target)
 
   it('preserves authored PowerShell code links and keyboard keys', () => {
-    const href = 'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_commonparameters?view=powershell-7.4#-erroraction'
-    const spans = tokenizeDoc(`Use [\`-ErrorAction Stop\`](${href}) after <kbd>C-a</kbd> or <kbd>Enter</kbd>.`, 'powershell')
+    const href =
+      'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_commonparameters?view=powershell-7.4#-erroraction'
+    const spans = tokenizeDoc(
+      `Use [\`-ErrorAction Stop\`](${href}) after <kbd>C-a</kbd> or <kbd>Enter</kbd>.`,
+      'powershell',
+    )
     expect(spans.filter((span) => span.kind === 'link')).toEqual([
       { kind: 'link', text: '-ErrorAction Stop', href, code: true },
     ])
     expect(spans.filter((span) => span.kind === 'kbd')).toEqual([
-      { kind: 'kbd', text: 'C-a' }, { kind: 'kbd', text: 'Enter' },
+      { kind: 'kbd', text: 'C-a' },
+      { kind: 'kbd', text: 'Enter' },
     ])
     expect(ref(spans)).toEqual([])
     expect(tokenizeDoc('The command continues after the key is sent.', 'powershell')).toEqual([
@@ -287,29 +291,21 @@ describe('each language gets its own spelling of a cross-reference', () => {
   })
 
   it('Go doc links resolve, Rust-style ones do not leak into Go', () => {
-    expect(ref(tokenizeDoc('See [GlobalWindowScope.Options] for this.', 'go'))).toEqual([
-      'GlobalWindowScope.Options',
-    ])
+    expect(ref(tokenizeDoc('See [GlobalWindowScope.Options] for this.', 'go'))).toEqual(['GlobalWindowScope.Options'])
     // Bracketed prose is not a reference, and a Markdown link is not one either.
     expect(ref(tokenizeDoc('as noted [see below] and [text](http://x)', 'go'))).toEqual([])
   })
 
   it('Rust keeps its scope operator, and Go links do not fire there', () => {
-    expect(ref(tokenizeDoc('Returns [`Error::Unsupported`] below 3.3.', 'rs'))).toEqual([
-      'Error.Unsupported',
-    ])
+    expect(ref(tokenizeDoc('Returns [`Error::Unsupported`] below 3.3.', 'rs'))).toEqual(['Error.Unsupported'])
     expect(ref(tokenizeDoc('the [Options] field', 'rs'))).toEqual([])
   })
 
   it('javadoc and TSDoc inline tags', () => {
-    expect(ref(tokenizeDoc('Use {@link Server#newSession} instead.', 'java'))).toEqual([
-      'Server.newSession',
-    ])
+    expect(ref(tokenizeDoc('Use {@link Server#newSession} instead.', 'java'))).toEqual(['Server.newSession'])
     // `{@code x}` is a literal, the same thing reST spells with double backticks.
     const spans = tokenizeDoc('Pass {@code null} to clear.', 'java')
-    expect(spans.filter((s) => s.kind === 'code').map((s) => (s as { text: string }).text)).toEqual([
-      'null',
-    ])
+    expect(spans.filter((s) => s.kind === 'code').map((s) => (s as { text: string }).text)).toEqual(['null'])
   })
 
   it('rustdoc links to an item in scope, and through Markdown syntax', () => {
@@ -324,16 +320,12 @@ describe('each language gets its own spelling of a cross-reference', () => {
   })
 
   it('C# see-cref, with the addressing prefix removed', () => {
-    expect(ref(tokenizeDoc('See <see cref="T:LibTmux.Server"/> for more.', 'csharp'))).toEqual([
-      'LibTmux.Server',
-    ])
+    expect(ref(tokenizeDoc('See <see cref="T:LibTmux.Server"/> for more.', 'csharp'))).toEqual(['LibTmux.Server'])
   })
 
   it('a C# keyword is a literal, not a member', () => {
     const spans = tokenizeDoc('Or <see langword="null" /> for the default.', 'csharp')
-    expect(spans.filter((s) => s.kind === 'code').map((s) => (s as { text: string }).text)).toEqual([
-      'null',
-    ])
+    expect(spans.filter((s) => s.kind === 'code').map((s) => (s as { text: string }).text)).toEqual(['null'])
   })
 
   it('bold reaches the page as bold, and prose keeps its asterisks', () => {
@@ -341,7 +333,9 @@ describe('each language gets its own spelling of a cross-reference', () => {
     // like. Rendered as text they were literal asterisks, which is what the
     // reference showed once the doc comment behind `#[derive]` was readable.
     const strong = (t: string, l?: string) =>
-      tokenizeDoc(t, l).filter((s) => s.kind === 'strong').map((s) => (s as { text: string }).text)
+      tokenizeDoc(t, l)
+        .filter((s) => s.kind === 'strong')
+        .map((s) => (s as { text: string }).text)
     expect(strong('**Connecting.** `new` takes the socket.', 'rs')).toEqual(['Connecting.'])
     // A single asterisk is emphasis, a glob and a multiplication sign, so it
     // is left alone. Both of these are prose.
@@ -376,9 +370,7 @@ describe('a doc comment is read in the dialect it was written in', () => {
    * `<socket>`. Only javadoc's own vocabulary may be translated.
    */
   it('javadoc HTML becomes the model, and other angle brackets survive', () => {
-    const md = javadocToMarkdown(
-      'Takes a {@code List<String>} at a <socket> path.\n\n<p>Then <em>waits</em>.',
-    )
+    const md = javadocToMarkdown('Takes a {@code List<String>} at a <socket> path.\n\n<p>Then <em>waits</em>.')
     expect(md).toContain('List<String>')
     expect(md).toContain('<socket>')
     expect(md).not.toContain('<p>')
@@ -387,9 +379,7 @@ describe('a doc comment is read in the dialect it was written in', () => {
 
   it('javadoc example blocks reach the renderer that draws examples', () => {
     const { doc } = parseJavadoc('Creates it.\n\n<pre>{@code\nvar s = server.newSession();\n}</pre>')
-    expect(doc.examples?.map((e) => [e.lang, e.code])).toEqual([
-      ['java', 'var s = server.newSession();'],
-    ])
+    expect(doc.examples?.map((e) => [e.lang, e.code])).toEqual([['java', 'var s = server.newSession();']])
   })
 })
 
@@ -419,9 +409,7 @@ describe('doc comments give up their parameters', () => {
     const model = load('csharp')
     if (!model) return
     const leaked = model.symbols.filter((s) =>
-      /<(summary|remarks|para|returns|example|list)\b/.test(
-        `${s.doc?.summary ?? ''}${s.doc?.body ?? ''}`,
-      ),
+      /<(summary|remarks|para|returns|example|list)\b/.test(`${s.doc?.summary ?? ''}${s.doc?.body ?? ''}`),
     )
     expect(leaked.slice(0, 3).map((s) => s.publicId ?? s.id)).toEqual([])
   })
@@ -491,11 +479,7 @@ describe('the mention index is computed, not observed', () => {
   })
 
   it('ignores prose that is not a code span, and code that is not a name', () => {
-    const md = [
-      '| Python | server.sessions |',
-      '| Go | `see the guide` |',
-      '| C++ | `-L socket-name` |',
-    ].join('\n')
+    const md = ['| Python | server.sessions |', '| Go | `see the guide` |', '| C++ | `-L socket-name` |'].join('\n')
     // Unbackticked prose is not a mention, and neither is a phrase with
     // spaces and no call parens — which covers both the sentence and the
     // command-line flag, so the resolver is never asked about either.
diff --git a/packages/api-model/test/java.test.ts b/packages/api-model/test/java.test.ts
index 83c088391..247cd76ce 100644
--- a/packages/api-model/test/java.test.ts
+++ b/packages/api-model/test/java.test.ts
@@ -61,7 +61,11 @@ describe('Java callable visibility', () => {
       public enum Mode { SAFE, FAST }
     `)
     expect(symbols.filter((symbol) => symbol.parent).map((symbol) => symbol.name)).toEqual([
-      'read', 'value', 'create', 'SAFE', 'FAST',
+      'read',
+      'value',
+      'create',
+      'SAFE',
+      'FAST',
     ])
   })
 })
@@ -79,18 +83,40 @@ describe('Java source-qualified names', () => {
         }
       }
     `)
-    expect(symbols.map(({ id, qualifiedName, namespace, parent }) => ({ id, qualifiedName, namespace, parent }))).toEqual([
+    expect(
+      symbols.map(({ id, qualifiedName, namespace, parent }) => ({ id, qualifiedName, namespace, parent })),
+    ).toEqual([
       { id: 'example.Example', qualifiedName: 'org.org.api.Example', namespace: 'org.org.api', parent: undefined },
-      { id: 'example.Example.Example', qualifiedName: 'org.org.api.Example.Example', namespace: 'org.org.api', parent: 'example.Example' },
-      { id: 'example.Example.Builder', qualifiedName: 'org.org.api.Example.Builder', namespace: 'org.org.api', parent: 'example.Example' },
-      { id: 'example.Example.Builder.Builder', qualifiedName: 'org.org.api.Example.Builder.Builder', namespace: 'org.org.api', parent: 'example.Example.Builder' },
-      { id: 'example.Example.Builder.build', qualifiedName: 'org.org.api.Example.Builder.build', namespace: 'org.org.api', parent: 'example.Example.Builder' },
+      {
+        id: 'example.Example.Example',
+        qualifiedName: 'org.org.api.Example.Example',
+        namespace: 'org.org.api',
+        parent: 'example.Example',
+      },
+      {
+        id: 'example.Example.Builder',
+        qualifiedName: 'org.org.api.Example.Builder',
+        namespace: 'org.org.api',
+        parent: 'example.Example',
+      },
+      {
+        id: 'example.Example.Builder.Builder',
+        qualifiedName: 'org.org.api.Example.Builder.Builder',
+        namespace: 'org.org.api',
+        parent: 'example.Example.Builder',
+      },
+      {
+        id: 'example.Example.Builder.build',
+        qualifiedName: 'org.org.api.Example.Builder.build',
+        namespace: 'org.org.api',
+        parent: 'example.Example.Builder',
+      },
     ])
     expect(moduleOf(symbols.at(-1)!)).toBe('org.org.api')
     expect(qualifiedNameOf(symbols.at(-1)!)).toBe('org.org.api.Example.Builder.build')
 
     const model = { port: 'java' as const, extractor: 'test', symbols }
-    const hrefFor = (symbol: typeof symbols[number]) => `/reference/${symbol.id}/#${symbol.id}`
+    const hrefFor = (symbol: (typeof symbols)[number]) => `/reference/${symbol.id}/#${symbol.id}`
     const index = new SymbolIndex(symbols, hrefFor, 'java')
     const resolver = new Resolver([model])
     for (const symbol of symbols) {
@@ -102,11 +128,16 @@ describe('Java source-qualified names', () => {
     expect(index.resolve('Example', 'class', builder)?.symbol?.id).toBe('example.Example')
     expect(index.resolve('Builder', 'class', builder)?.symbol?.id).toBe('example.Example.Builder')
     const parents = parentInventory(model, hrefFor)
-    expect(parents.find((entry) => entry.name === 'org.org.api.Example.Builder.build')?.uri).toBe(hrefFor(builder).slice(1))
-    expect(parents.find((entry) => entry.name === 'org.org.api.Example.Example')?.uri).toBe(hrefFor(symbols[1]).slice(1))
+    expect(parents.find((entry) => entry.name === 'org.org.api.Example.Builder.build')?.uri).toBe(
+      hrefFor(builder).slice(1),
+    )
+    expect(parents.find((entry) => entry.name === 'org.org.api.Example.Example')?.uri).toBe(
+      hrefFor(symbols[1]).slice(1),
+    )
     const inventory = readInventory(writeInventory(model, { project: 'java', version: 'test', uriFor: hrefFor }))
     expect(inventory.entries.find((entry) => entry.name === builder.id)).toMatchObject({
-      dispname: 'org.org.api.Example.Builder.build', uri: hrefFor(builder),
+      dispname: 'org.org.api.Example.Builder.build',
+      uri: hrefFor(builder),
     })
   })
 
@@ -120,7 +151,11 @@ describe('Java source-qualified names', () => {
   })
 
   it('keeps legacy type links when a constructor has the same canonical spelling', async () => {
-    const symbols = await extract('package example; public class Example { public Example() {} }', false, 'example.Example')
+    const symbols = await extract(
+      'package example; public class Example { public Example() {} }',
+      false,
+      'example.Example',
+    )
     const index = new SymbolIndex(symbols, (symbol) => `/reference/${symbol.id}`, 'java')
     expect(index.resolve('example.Example')?.symbol?.kind).toBe('class')
     // This is the constructor's native name and an existing type's stable id.
diff --git a/packages/api-model/test/julia.test.ts b/packages/api-model/test/julia.test.ts
index 8caef8740..235eaef9f 100644
--- a/packages/api-model/test/julia.test.ts
+++ b/packages/api-model/test/julia.test.ts
@@ -11,13 +11,27 @@ describe('Julia native API adapter', () => {
     const input = structuredClone(fixture)
     const method = input.symbols.find((entry) => entry.id === 'LibTmux.from_env').methods[0]
     method.documentation[0].markdown = [
-      '```julia', 'from_env(; env=ENV)', '```', '',
-      'Describe the selected endpoint.', '', '# Arguments', '',
+      '```julia',
+      'from_env(; env=ENV)',
+      '```',
+      '',
+      'Describe the selected endpoint.',
+      '',
+      '# Arguments',
+      '',
       '- `env=ENV`: Read `TMUX` from this mapping.',
-      '  Use [`Server`](@ref) for explicit selection.', '',
-      '  A second paragraph stays with the parameter.', '',
-      '- `unknown`: Keep documentation that has no matching native parameter.', '',
-      '# Examples', '', '```julia', '# Arguments', '- `env`: not an argument description', '```',
+      '  Use [`Server`](@ref) for explicit selection.',
+      '',
+      '  A second paragraph stays with the parameter.',
+      '',
+      '- `unknown`: Keep documentation that has no matching native parameter.',
+      '',
+      '# Examples',
+      '',
+      '```julia',
+      '# Arguments',
+      '- `env`: not an argument description',
+      '```',
     ].join('\n')
     const actual = extractJulia(input).symbols.find((entry) => entry.id === 'LibTmux.from_env')!
     const parameter = actual.signatures[0]!.params.find((entry) => entry.name === 'env')!
@@ -39,8 +53,14 @@ describe('Julia native API adapter', () => {
     const entry = input.symbols.find((entry) => entry.id === 'LibTmux.kill_session')
     for (const [i, method] of entry.methods.entries()) {
       const parameter = method.parameters.find((parameter) => parameter.name)
-      method.documentation = [{ signature: 'native', source: method.source, fields: {},
-        markdown: `Remove the session.\n\n# Keyword arguments\n\n- \`${parameter.name}::Any\`: Description for method ${i}.` }]
+      method.documentation = [
+        {
+          signature: 'native',
+          source: method.source,
+          fields: {},
+          markdown: `Remove the session.\n\n# Keyword arguments\n\n- \`${parameter.name}::Any\`: Description for method ${i}.`,
+        },
+      ]
     }
     const actual = extractJulia(input).symbols.find((symbol) => symbol.id === entry.id)!
     actual.signatures.forEach((method, i) => {
@@ -53,7 +73,9 @@ describe('Julia native API adapter', () => {
     const expected = [...fixture.symbols, ...fixture.extensionMethods].flatMap((symbol) => symbol.methods)
     const actual = model.symbols.flatMap((symbol) => symbol.signatures)
     expect(actual).toHaveLength(expected.length)
-    expect(actual.map((signature) => signature.identity).sort()).toEqual(expected.map((method) => method.identity).sort())
+    expect(actual.map((signature) => signature.identity).sort()).toEqual(
+      expected.map((method) => method.identity).sort(),
+    )
     for (const method of expected) {
       expect(actual.find((signature) => signature.identity === method.identity)?.source).toMatchObject(method.source)
     }
@@ -67,16 +89,30 @@ describe('Julia native API adapter', () => {
     expect(control.source?.file).toBe('src/control_topology.jl')
     expect(control.params.find((parameter) => parameter.name === 'kwargs')?.variadic).toBe('keyword')
     expect(binding('LibTmux.read_where_json').signatures[0]?.extension).toBe('LibTmuxJSONExt')
-    expect(binding('LibTmux.Filters.Contains').signatures[0]?.params.find((parameter) => parameter.name === 'case')).toMatchObject({ default: ':sensitive', keywordOnly: true, type: 'Symbol' })
+    expect(
+      binding('LibTmux.Filters.Contains').signatures[0]?.params.find((parameter) => parameter.name === 'case'),
+    ).toMatchObject({ default: ':sensitive', keywordOnly: true, type: 'Symbol' })
   })
 
   it('retains callable instances, parameterized constructors, aliases and fields', () => {
-    expect(binding('LibTmux.Criterion').signatures[0]).toMatchObject({ methodKind: 'call', receiver: { name: 'q', type: 'LibTmux.Criterion' } })
+    expect(binding('LibTmux.Criterion').signatures[0]).toMatchObject({
+      methodKind: 'call',
+      receiver: { name: 'q', type: 'LibTmux.Criterion' },
+    })
     expect(binding('LibTmux.RowProjection').signatures[0]?.raw).toContain('RowProjection{R, S}')
     expect(binding('LibTmux.RowProjection').typeParams).toEqual(['R<:NamedTuple', 'S<:LibTmux.Selection'])
-    expect(binding('LibTmux.SessionID')).toMatchObject({ kind: 'typealias', type: 'TmuxID{:session}', typeParams: [':session'], source: { file: 'src/model.jl', line: 41 } })
+    expect(binding('LibTmux.SessionID')).toMatchObject({
+      kind: 'typealias',
+      type: 'TmuxID{:session}',
+      typeParams: [':session'],
+      source: { file: 'src/model.jl', line: 41 },
+    })
     expect(binding('LibTmux.TmuxID').apiScope).toBe('supporting')
-    expect(binding('LibTmux.Server.socket_path')).toMatchObject({ kind: 'property', parent: 'LibTmux.Server', modifiers: ['readonly'] })
+    expect(binding('LibTmux.Server.socket_path')).toMatchObject({
+      kind: 'property',
+      parent: 'LibTmux.Server',
+      modifiers: ['readonly'],
+    })
     expect(binding('LibTmux.Server.socket_path').source.line).toBeUndefined()
     expect(binding('LibTmux.Base.IndexStyle').signatures).toHaveLength(3)
     expect(binding('LibTmux.Base.IteratorSize').signatures).toHaveLength(1)
diff --git a/packages/api-model/test/jvm-examples.test.ts b/packages/api-model/test/jvm-examples.test.ts
index 38e3bd8df..6fecec144 100644
--- a/packages/api-model/test/jvm-examples.test.ts
+++ b/packages/api-model/test/jvm-examples.test.ts
@@ -7,59 +7,90 @@ const variants = ['java', 'kotlin', 'scala-direct', 'scala-cats'] as const
 const fixture = () => {
   const files = new Map<string, string>()
   const examples = variants.map((variant) => {
-    const language = variant.startsWith('scala') ? 'scala' : variant as 'java' | 'kotlin'
+    const language = variant.startsWith('scala') ? 'scala' : (variant as 'java' | 'kotlin')
     const extension = language === 'kotlin' ? 'kt' : language
     const name = variant.replace('-', '')
     const path = `examples/src/main/${language}/${name}/Connect.${extension}`
     files.set(path, `\npackage example\n// ${variant} whole program bytes\n\n`)
-    return { id: `${variant}-Connect`, variant, language, description: `Connect with ${variant}.`,
-      sourceFile: path, mainClass: `io.github.libtmux.examples.${name}.Connect`,
-      targets: [`${name}.Server`], expectedOutput: 'connected=true\n', path: `src/main/${language}/Connect.${extension}` }
+    return {
+      id: `${variant}-Connect`,
+      variant,
+      language,
+      description: `Connect with ${variant}.`,
+      sourceFile: path,
+      mainClass: `io.github.libtmux.examples.${name}.Connect`,
+      targets: [`${name}.Server`],
+      expectedOutput: 'connected=true\n',
+      path: `src/main/${language}/Connect.${extension}`,
+    }
   })
   const manifest = {
-    schemaVersion: 1, examples,
-    variants: Object.fromEntries(variants.map((variant) => [variant, { files:
-      ['settings.gradle.kts', 'build.gradle.kts', 'gradle.properties', 'run.sh'].map((path) => {
-        const sourceFile = `examples/api/${variant}/${path}`
-        files.set(sourceFile, `${variant} ${path}\n`)
-        return { path, sourceFile }
-      }),
-    }])),
+    schemaVersion: 1,
+    examples,
+    variants: Object.fromEntries(
+      variants.map((variant) => [
+        variant,
+        {
+          files: ['settings.gradle.kts', 'build.gradle.kts', 'gradle.properties', 'run.sh'].map((path) => {
+            const sourceFile = `examples/api/${variant}/${path}`
+            files.set(sourceFile, `${variant} ${path}\n`)
+            return { path, sourceFile }
+          }),
+        },
+      ]),
+    ),
   }
   const symbols: ApiSymbol[] = examples.map((program) => ({
     id: program.variant === 'java' ? 'java.Server.Server' : program.targets[0],
     publicId: program.variant === 'java' ? 'java.Server.Server' : program.targets[0],
-    qualifiedName: program.targets[0], name: 'Server', kind: 'class', modifiers: [],
-    signatures: [], slug: `${program.variant}-server`, source: { file: 'Server' },
+    qualifiedName: program.targets[0],
+    name: 'Server',
+    kind: 'class',
+    modifiers: [],
+    signatures: [],
+    slug: `${program.variant}-server`,
+    source: { file: 'Server' },
     doc: { summary: 'Existing native documentation.' },
   }))
-  const read = (path: string) => path === 'examples/api/manifest.json' ? JSON.stringify(manifest) : files.get(path)
+  const read = (path: string) => (path === 'examples/api/manifest.json' ? JSON.stringify(manifest) : files.get(path))
   return { files, manifest, symbols, read }
 }
 
 describe('complete JVM API programs', () => {
-  it.each(['java', 'kotlin', 'scala'] as const)('attaches only %s programs with every source-owned setup file', (port) => {
-    const { manifest, symbols, files, read } = fixture()
-    const identities = symbols.map(({ id, publicId, qualifiedName, slug }) => ({ id, publicId, qualifiedName, slug }))
-    attachCompleteJvmExamples(symbols, port, read, source)
-    expect(symbols.map(({ id, publicId, qualifiedName, slug }) => ({ id, publicId, qualifiedName, slug }))).toEqual(identities)
-    for (const [i, program] of manifest.examples.entries()) {
-      const blocks = symbols[i].doc?.examples
-      if (program.language !== port) { expect(blocks).toBeUndefined(); continue }
-      expect(symbols[i].doc?.summary).toBe('Existing native documentation.')
-      expect(blocks).toHaveLength(8)
-      const displayed = [...manifest.variants[program.variant].files, program]
-      displayed.forEach((file, index) => {
-        expect(blocks![index + 1].code).toBe(files.get(file.sourceFile))
-        expect(blocks![index + 1].sourceUrl).toBe(`https://github.com/${source.repo}/blob/${source.revision}/${file.sourceFile}`)
-        expect(blocks![index + 1].intro).toContain(file.path)
-      })
-      expect(blocks![5].lang).toBe(port)
-      expect(blocks![0].code).toContain(`git -C libtmux-source checkout ${source.revision}`)
-      expect(blocks![6].code).toBe(`$ ./libtmux-source/gradlew --project-dir . --console=plain --quiet \\\n    installDist -PexampleMain=${program.mainClass} && \\\n  sh run.sh build/install/api-example/bin/api-example\n`)
-      expect(blocks![7]).toEqual({ lang: 'text', intro: 'Expected output:', code: program.expectedOutput })
-    }
-  })
+  it.each(['java', 'kotlin', 'scala'] as const)(
+    'attaches only %s programs with every source-owned setup file',
+    (port) => {
+      const { manifest, symbols, files, read } = fixture()
+      const identities = symbols.map(({ id, publicId, qualifiedName, slug }) => ({ id, publicId, qualifiedName, slug }))
+      attachCompleteJvmExamples(symbols, port, read, source)
+      expect(symbols.map(({ id, publicId, qualifiedName, slug }) => ({ id, publicId, qualifiedName, slug }))).toEqual(
+        identities,
+      )
+      for (const [i, program] of manifest.examples.entries()) {
+        const blocks = symbols[i].doc?.examples
+        if (program.language !== port) {
+          expect(blocks).toBeUndefined()
+          continue
+        }
+        expect(symbols[i].doc?.summary).toBe('Existing native documentation.')
+        expect(blocks).toHaveLength(8)
+        const displayed = [...manifest.variants[program.variant].files, program]
+        displayed.forEach((file, index) => {
+          expect(blocks![index + 1].code).toBe(files.get(file.sourceFile))
+          expect(blocks![index + 1].sourceUrl).toBe(
+            `https://github.com/${source.repo}/blob/${source.revision}/${file.sourceFile}`,
+          )
+          expect(blocks![index + 1].intro).toContain(file.path)
+        })
+        expect(blocks![5].lang).toBe(port)
+        expect(blocks![0].code).toContain(`git -C libtmux-source checkout ${source.revision}`)
+        expect(blocks![6].code).toBe(
+          `$ ./libtmux-source/gradlew --project-dir . --console=plain --quiet \\\n    installDist -PexampleMain=${program.mainClass} && \\\n  sh run.sh build/install/api-example/bin/api-example\n`,
+        )
+        expect(blocks![7]).toEqual({ lang: 'text', intro: 'Expected output:', code: program.expectedOutput })
+      }
+    },
+  )
 
   it('keeps older source revisions without a manifest unchanged', () => {
     const { symbols } = fixture()
@@ -71,9 +102,15 @@ describe('complete JVM API programs', () => {
   it('keeps two distinct complete programs attached to the same API page', () => {
     const { symbols, manifest, files, read } = fixture()
     const first = manifest.examples[0]
-    const second = { ...first, id: 'java-Query', mainClass: first.mainClass.replace('Connect', 'Query'),
-      sourceFile: first.sourceFile.replace('Connect', 'Query'), path: first.path.replace('Connect', 'Query'),
-      description: 'Query sessions.', expectedOutput: 'matches=1\n' }
+    const second = {
+      ...first,
+      id: 'java-Query',
+      mainClass: first.mainClass.replace('Connect', 'Query'),
+      sourceFile: first.sourceFile.replace('Connect', 'Query'),
+      path: first.path.replace('Connect', 'Query'),
+      description: 'Query sessions.',
+      expectedOutput: 'matches=1\n',
+    }
     files.set(second.sourceFile, '\n// Complete query program\n\n')
     manifest.examples.push(second)
     attachCompleteJvmExamples(symbols, 'java', read, source)
@@ -88,39 +125,57 @@ describe('complete JVM API programs', () => {
 
   it('requires an exact unique canonical Java target without renaming its public identity', () => {
     for (const symbols of [[], [...fixture().symbols, fixture().symbols[0]]]) {
-      expect(() => attachCompleteJvmExamples(symbols, 'java', fixture().read, source)).toThrow('must resolve once: java.Server')
+      expect(() => attachCompleteJvmExamples(symbols, 'java', fixture().read, source)).toThrow(
+        'must resolve once: java.Server',
+      )
     }
     const { manifest, symbols, read } = fixture()
     manifest.examples[0].targets = ['java.Server.Server']
-    expect(() => attachCompleteJvmExamples(symbols, 'java', read, source)).toThrow('must resolve once: java.Server.Server')
+    expect(() => attachCompleteJvmExamples(symbols, 'java', read, source)).toThrow(
+      'must resolve once: java.Server.Server',
+    )
   })
 
   it('rejects duplicate attachments and mismatched language variants', () => {
     const duplicate = fixture()
     duplicate.manifest.examples[0].targets.push('java.Server')
-    expect(() => attachCompleteJvmExamples(duplicate.symbols, 'java', duplicate.read, source)).toThrow('Duplicate JVM example target')
+    expect(() => attachCompleteJvmExamples(duplicate.symbols, 'java', duplicate.read, source)).toThrow(
+      'Duplicate JVM example target',
+    )
     const wrong = fixture()
     wrong.manifest.examples[0].language = 'kotlin'
-    expect(() => attachCompleteJvmExamples(wrong.symbols, 'java', wrong.read, source)).toThrow('Invalid JVM example variant')
+    expect(() => attachCompleteJvmExamples(wrong.symbols, 'java', wrong.read, source)).toThrow(
+      'Invalid JVM example variant',
+    )
   })
 
   it('rejects incomplete setup, missing source bytes and unsafe commands or paths', () => {
     const setup = fixture()
     setup.manifest.variants.java.files.pop()
-    expect(() => attachCompleteJvmExamples(setup.symbols, 'java', setup.read, source)).toThrow('Invalid JVM example setup')
+    expect(() => attachCompleteJvmExamples(setup.symbols, 'java', setup.read, source)).toThrow(
+      'Invalid JVM example setup',
+    )
     const missing = fixture()
     missing.files.delete(missing.manifest.examples[0].sourceFile)
-    expect(() => attachCompleteJvmExamples(missing.symbols, 'java', missing.read, source)).toThrow('Missing complete JVM example file')
+    expect(() => attachCompleteJvmExamples(missing.symbols, 'java', missing.read, source)).toThrow(
+      'Missing complete JVM example file',
+    )
     const path = fixture()
     path.manifest.examples[0].sourceFile = 'examples/../private.txt'
-    expect(() => attachCompleteJvmExamples(path.symbols, 'java', path.read, source)).toThrow('Invalid JVM example source path')
+    expect(() => attachCompleteJvmExamples(path.symbols, 'java', path.read, source)).toThrow(
+      'Invalid JVM example source path',
+    )
     const command = fixture()
     command.manifest.examples[0].mainClass += '; echo injected'
-    expect(() => attachCompleteJvmExamples(command.symbols, 'java', command.read, source)).toThrow('Invalid JVM example metadata')
+    expect(() => attachCompleteJvmExamples(command.symbols, 'java', command.read, source)).toThrow(
+      'Invalid JVM example metadata',
+    )
   })
 
   it('requires public source provenance for every displayed file', () => {
     const { symbols, read } = fixture()
-    expect(() => attachCompleteJvmExamples(symbols, 'java', read, { ...source, revision: 'main' })).toThrow('full source revision')
+    expect(() => attachCompleteJvmExamples(symbols, 'java', read, { ...source, revision: 'main' })).toThrow(
+      'full source revision',
+    )
   })
 })
diff --git a/packages/api-model/test/jvm.test.ts b/packages/api-model/test/jvm.test.ts
index 8f9c90252..7e77d099c 100644
--- a/packages/api-model/test/jvm.test.ts
+++ b/packages/api-model/test/jvm.test.ts
@@ -17,20 +17,26 @@ function fixture(file: string, code: string) {
 
 describe('native JVM declarations', () => {
   it('links Scala type parameters and extension receivers to their declarations', async () => {
-    const root = fixture('Box.scala', `package example
+    const root = fixture(
+      'Box.scala',
+      `package example
 class Box[F[_], +A <: Other](val value: A) {
   def read: F[A] = TODO
 }
 extension [F[_]](self: Box[F, String]) {
   def map[B](value: B): F[B] = TODO
 }
-`)
+`,
+    )
     const model = await extractJvm('scala', [root])
     const box = model.symbols.find((s) => s.id === 'example.Box')!
     const read = model.symbols.find((s) => s.id === 'example.Box.read')!
     const map = model.symbols.find((s) => s.id === 'example.Box.map')!
     expect(box.signatures[0].typeParams).toEqual(['F', 'A'])
-    expect(map.signatures[0]).toMatchObject({ typeParams: ['F', 'B'], receiver: { name: 'self', type: 'Box[F, String]' } })
+    expect(map.signatures[0]).toMatchObject({
+      typeParams: ['F', 'B'],
+      receiver: { name: 'self', type: 'Box[F, String]' },
+    })
     const index = new SymbolIndex(model.symbols, (symbol) => `#${symbol.id}`, 'scala')
     expect(index.resolve('F', 'class', read)?.href).toBe('#example.Box')
     expect(index.resolve('B', 'class', map)?.href).toBe('#example.Box.map')
@@ -42,27 +48,37 @@ extension [F[_]](self: Box[F, String]) {
     expect(spans.map((span) => span.text).join('')).toBe(signature.raw)
   })
   it('links the types in an overload while leaving its bindings plain', async () => {
-    const root = fixture('Server.scala', `package example
+    const root = fixture(
+      'Server.scala',
+      `package example
 class Server
 class Window
 class WindowId
 extension (self: Server) {
   def windows(id: WindowId): Vector[Window] = TODO
 }
-`)
+`,
+    )
     const { symbols } = await extractJvm('scala', [root])
     const method = symbols.find((s) => s.name === 'windows')!
     const index = new SymbolIndex(symbols, (symbol) => `#${symbol.id}`, 'scala')
     const signature = method.signatures[0]
     const spans = index.linkType(signature.raw!, method, signature)
-    expect(spans.filter((span) => span.link).map((span) => span.text)).toEqual(['Server', 'WindowId', 'Vector', 'Window'])
+    expect(spans.filter((span) => span.link).map((span) => span.text)).toEqual([
+      'Server',
+      'WindowId',
+      'Vector',
+      'Window',
+    ])
     expect(spans.map((span) => span.text).join('')).toBe(signature.raw)
     expect(index.resolve('id', 'any', method)?.href).toContain('.parameter.id')
   })
   it.each(['kotlin', 'scala'] as const)('keeps %s links outside generic code', async (port) => {
     const doc = port === 'kotlin' ? '[the server][Handle]' : '[[Handle the server]]'
-    const root = fixture(port === 'kotlin' ? 'Handle.kt' : 'Handle.scala',
-      'package example\n/** Uses `Execution[F]` and ' + doc + '. */\nclass Handle\n')
+    const root = fixture(
+      port === 'kotlin' ? 'Handle.kt' : 'Handle.scala',
+      'package example\n/** Uses `Execution[F]` and ' + doc + '. */\nclass Handle\n',
+    )
     const { symbols } = await extractJvm(port, [root])
     const summary = symbols[0]!.doc!.summary
     expect(summary).toContain('`Execution[F]`')
@@ -76,7 +92,9 @@ extension (self: Server) {
   })
 
   it('collects Kotlin constructor properties, companion members and generated extensions', async () => {
-    const root = fixture('Pane.kt', `package example
+    const root = fixture(
+      'Pane.kt',
+      `package example
 
 /** A pane in one server. */
 public class Pane internal constructor(internal val java: JavaPane, public val server: Server) {
@@ -95,21 +113,34 @@ public suspend fun Pane.capture(trim: Boolean = true): List<String> = TODO()
 
 /** Read scrollback too. */
 public suspend fun Pane.capture(start: Int): List<String> = TODO()
-`)
-    writeFileSync(join(root, 'Fields.kt'), `package example.query
+`,
+    )
+    writeFileSync(
+      join(root, 'Fields.kt'),
+      `package example.query
 import example.Pane as KotlinPane
 
 /** The pane id. */
 public val KotlinPane.Companion.id: TextField<JavaPane>
     get() = TODO()
-`)
+`,
+    )
     const { symbols } = await extractJvm('kotlin', [root])
-    expect(symbols.map((s) => s.id)).toEqual(expect.arrayContaining([
-      'example.Pane', 'example.Pane.server', 'example.Pane.Companion',
-      'example.Pane.Companion.open', 'example.Pane.Companion.id', 'example.Pane.capture',
-    ]))
+    expect(symbols.map((s) => s.id)).toEqual(
+      expect.arrayContaining([
+        'example.Pane',
+        'example.Pane.server',
+        'example.Pane.Companion',
+        'example.Pane.Companion.open',
+        'example.Pane.Companion.id',
+        'example.Pane.capture',
+      ]),
+    )
     expect(symbols.some((s) => /\.java$|\.implementation$/.test(s.id))).toBe(false)
-    expect(symbols.find((s) => s.id === 'example.Pane')!.signatures[0]).toMatchObject({ raw: 'public class Pane', params: [] })
+    expect(symbols.find((s) => s.id === 'example.Pane')!.signatures[0]).toMatchObject({
+      raw: 'public class Pane',
+      params: [],
+    })
     const capture = symbols.find((s) => s.id === 'example.Pane.capture')!
     const index = new SymbolIndex(symbols, (symbol) => `#${symbol.id}`, 'kotlin')
     const signature = capture.signatures[0]
@@ -122,13 +153,16 @@ public val KotlinPane.Companion.id: TextField<JavaPane>
     expect(capture.signatures[0]).toMatchObject({
       raw: 'public suspend fun Pane.capture(trim: Boolean = true): List<String>',
       params: [{ name: 'trim', type: 'Boolean', default: 'true', doc: 'remove trailing spaces' }],
-      returns: 'List<String>', returnsDoc: 'the captured rows',
+      returns: 'List<String>',
+      returnsDoc: 'the captured rows',
     })
     expect(symbols.find((s) => s.id === 'example.Pane.Companion.id')!.parent).toBe('example.Pane.Companion')
   })
 
   it('retains Scala 3 opaque companions, extension receivers, givens and enum cases', async () => {
-    const root = fixture('Pane.scala', `package example
+    const root = fixture(
+      'Pane.scala',
+      `package example
 
 /** A pane handle. */
 opaque type Pane = JavaPane
@@ -161,7 +195,8 @@ object Fields {
   /** The command field used to build a predicate. */
   def command: TextField[JavaPane] = TODO
 }
-`)
+`,
+    )
     const { symbols } = await extractJvm('scala', [root])
     const pane = symbols.find((s) => s.id === 'example.Pane')!
     expect(pane.kind).toBe('typealias')
@@ -169,37 +204,57 @@ object Fields {
     expect(pane.modifiers).not.toContain('overload')
     expect(symbols.some((s) => s.name === 'wrap')).toBe(false)
     expect(symbols.find((s) => s.id === 'example.Pane.id')!.signatures[0]).toMatchObject({
-      raw: 'extension (self: Pane)\ndef id: String', returns: 'String',
+      raw: 'extension (self: Pane)\ndef id: String',
+      returns: 'String',
     })
     expect(symbols.find((s) => s.id === 'example.Pane.capture')!.parent).toBe('example.Pane')
-    expect(symbols.map((s) => s.id)).toEqual(expect.arrayContaining([
-      'example.Pane.given_CanEqual_Pane_Pane', 'example.Missing.NoMatch', 'example.Missing.Several',
-    ]))
-    expect(symbols.find((s) => s.id === 'example.Missing.Several')!.signatures[0].params)
-      .toEqual([{ name: 'count', type: 'Int', doc: undefined }])
-    expect(symbols.find((s) => s.id === 'example.Box')!.signatures[0])
-      .toMatchObject({ raw: 'class Box[T]', params: [] })
+    expect(symbols.map((s) => s.id)).toEqual(
+      expect.arrayContaining([
+        'example.Pane.given_CanEqual_Pane_Pane',
+        'example.Missing.NoMatch',
+        'example.Missing.Several',
+      ]),
+    )
+    expect(symbols.find((s) => s.id === 'example.Missing.Several')!.signatures[0].params).toEqual([
+      { name: 'count', type: 'Int', doc: undefined },
+    ])
+    expect(symbols.find((s) => s.id === 'example.Box')!.signatures[0]).toMatchObject({
+      raw: 'class Box[T]',
+      params: [],
+    })
     expect(symbols.some((s) => s.id === 'example.Box.get')).toBe(true)
-    expect(symbols.find((s) => s.id === 'example.Box.server'))
-      .toMatchObject({ kind: 'property', parent: 'example.Box', signatures: [{ returns: 'Pane' }] })
+    expect(symbols.find((s) => s.id === 'example.Box.server')).toMatchObject({
+      kind: 'property',
+      parent: 'example.Box',
+      signatures: [{ returns: 'Pane' }],
+    })
     expect(symbols.some((s) => s.id === 'example.Box.value')).toBe(false)
-    expect(symbols.find((s) => s.id === 'example.Pane.command'))
-      .toMatchObject({ parent: 'example.Pane', exportedFrom: 'example.Fields.command',
-        signatures: [{ raw: 'def command: TextField[JavaPane]', returns: 'TextField[JavaPane]' }] })
+    expect(symbols.find((s) => s.id === 'example.Pane.command')).toMatchObject({
+      parent: 'example.Pane',
+      exportedFrom: 'example.Fields.command',
+      signatures: [{ raw: 'def command: TextField[JavaPane]', returns: 'TextField[JavaPane]' }],
+    })
   })
 
   it('keeps a Scala using clause separate from the extension receiver', async () => {
-    const root = fixture('Handle.scala', `package example
+    const root = fixture(
+      'Handle.scala',
+      `package example
 class Handle[F[_]]
 extension [F[_]](self: Handle[F])(using F: Effect[F]) {
   def capture: F[String] = TODO
 }
-`)
+`,
+    )
     const { symbols } = await extractJvm('scala', [root])
-    expect(symbols.find((symbol) => symbol.id === 'example.Handle.capture'))
-      .toMatchObject({ parent: 'example.Handle', signatures: [{
-        raw: 'extension [F[_]](self: Handle[F])(using F: Effect[F])\ndef capture: F[String]',
-      }] })
+    expect(symbols.find((symbol) => symbol.id === 'example.Handle.capture')).toMatchObject({
+      parent: 'example.Handle',
+      signatures: [
+        {
+          raw: 'extension [F[_]](self: Handle[F])(using F: Effect[F])\ndef capture: F[String]',
+        },
+      ],
+    })
   })
 
   it.each(['kotlin', 'scala'] as const)('rejects broken public %s syntax', async (port) => {
diff --git a/packages/api-model/test/lua-examples.test.ts b/packages/api-model/test/lua-examples.test.ts
index c2d775166..3aaf0b802 100644
--- a/packages/api-model/test/lua-examples.test.ts
+++ b/packages/api-model/test/lua-examples.test.ts
@@ -13,11 +13,22 @@ const files = [
 const manifest = (): LuaExampleManifest => ({
   schema: 1,
   setup: { lua: '5.5.1', luv: '1.52.1-0', launcher: 'examples/api/run.sh' },
-  examples: [{ id: 'connect', symbols: ['libtmux.Runtime:connect'], file: 'examples/api/connect.lua',
-    description: 'Connect to a tmux daemon.', stdout: 'connected\n' }],
+  examples: [
+    {
+      id: 'connect',
+      symbols: ['libtmux.Runtime:connect'],
+      file: 'examples/api/connect.lua',
+      description: 'Connect to a tmux daemon.',
+      stdout: 'connected\n',
+    },
+  ],
 })
 const target = (): ApiSymbol => ({
-  id: 'libtmux.Runtime:connect', name: 'connect', kind: 'method', modifiers: [], signatures: [],
+  id: 'libtmux.Runtime:connect',
+  name: 'connect',
+  kind: 'method',
+  modifiers: [],
+  signatures: [],
   source: { file: 'lua/libtmux/_internal/runtime.lua', revision: source.revision },
   doc: { summary: 'Existing native documentation.' },
 })
@@ -31,8 +42,12 @@ describe('complete Lua API examples from native artifacts', () => {
     expect(examples).toHaveLength(4)
     expect(examples[1].code).toBe(launcher)
     expect(examples[2].code).toBe(program)
-    expect(examples[1].sourceUrl).toBe(`https://github.com/${source.repository}/blob/${source.revision}/examples/api/run.sh`)
-    expect(examples[2].sourceUrl).toBe(`https://github.com/${source.repository}/blob/${source.revision}/examples/api/connect.lua`)
+    expect(examples[1].sourceUrl).toBe(
+      `https://github.com/${source.repository}/blob/${source.revision}/examples/api/run.sh`,
+    )
+    expect(examples[2].sourceUrl).toBe(
+      `https://github.com/${source.repository}/blob/${source.revision}/examples/api/connect.lua`,
+    )
     expect(examples[0].code).toContain(`git -C libtmux-source checkout ${source.revision}`)
     expect(examples[0].code).toContain('luarocks --tree ./rocks install luv 1.52.1-0')
     expect(examples[3].code).toBe('$ eval "$(luarocks --tree ./rocks path)" &&\n  sh run.sh connect.lua\n')
@@ -47,8 +62,11 @@ describe('complete Lua API examples from native artifacts', () => {
   })
 
   it('rejects missing or ambiguous full-file payloads and changed line endings', () => {
-    for (const invalid of [files.slice(0, 1), [...files, files[0]],
-      files.map((file) => ({ ...file, content: file.content.replaceAll('\n', '\r\n') }))]) {
+    for (const invalid of [
+      files.slice(0, 1),
+      [...files, files[0]],
+      files.map((file) => ({ ...file, content: file.content.replaceAll('\n', '\r\n') })),
+    ]) {
       expect(() => attachCompleteLuaExamples([target()], manifest(), invalid, source)).toThrow()
     }
   })
@@ -62,20 +80,34 @@ describe('complete Lua API examples from native artifacts', () => {
 
   it('rejects unsafe paths and absent runtime or output contracts', () => {
     for (const mutate of [
-      (value: LuaExampleManifest) => { value.setup.launcher = '../run.sh' },
-      (value: LuaExampleManifest) => { value.examples[0].file = '../../connect.lua' },
-      (value: LuaExampleManifest) => { value.setup.lua = 'latest' },
-      (value: LuaExampleManifest) => { value.setup.luv = 'latest' },
-      (value: LuaExampleManifest) => { value.examples[0].stdout = '' },
-      (value: LuaExampleManifest) => { value.examples[0].description = '' },
+      (value: LuaExampleManifest) => {
+        value.setup.launcher = '../run.sh'
+      },
+      (value: LuaExampleManifest) => {
+        value.examples[0].file = '../../connect.lua'
+      },
+      (value: LuaExampleManifest) => {
+        value.setup.lua = 'latest'
+      },
+      (value: LuaExampleManifest) => {
+        value.setup.luv = 'latest'
+      },
+      (value: LuaExampleManifest) => {
+        value.examples[0].stdout = ''
+      },
+      (value: LuaExampleManifest) => {
+        value.examples[0].description = ''
+      },
     ]) {
       const value = manifest()
       mutate(value)
       expect(() => attachCompleteLuaExamples([target()], value, files, source)).toThrow()
     }
-    expect(() => attachCompleteLuaExamples([target()], manifest(), files, { ...source, revision: 'main' }))
-      .toThrow(/full revision/)
-    expect(() => attachCompleteLuaExamples([target()], manifest(), files, { ...source, repository: 'other/repo' }))
-      .toThrow(/Lua repository/)
+    expect(() => attachCompleteLuaExamples([target()], manifest(), files, { ...source, revision: 'main' })).toThrow(
+      /full revision/,
+    )
+    expect(() =>
+      attachCompleteLuaExamples([target()], manifest(), files, { ...source, repository: 'other/repo' }),
+    ).toThrow(/Lua repository/)
   })
 })
diff --git a/packages/api-model/test/mcp-protocol.test.ts b/packages/api-model/test/mcp-protocol.test.ts
index ddce65aff..b5fc3d622 100644
--- a/packages/api-model/test/mcp-protocol.test.ts
+++ b/packages/api-model/test/mcp-protocol.test.ts
@@ -20,8 +20,9 @@ createInterface({ input: process.stdin }).on('line', line => {
 
 describe('MCP protocol discovery', () => {
   it('normalizes object order while preserving tuple and enumeration order', () => {
-    expect(JSON.stringify(orderedProtocol({ z: { b: 1, a: 2 }, a: ['z', 'a'] })))
-      .toBe('{"a":["z","a"],"z":{"a":2,"b":1}}')
+    expect(JSON.stringify(orderedProtocol({ z: { b: 1, a: 2 }, a: ['z', 'a'] }))).toBe(
+      '{"a":["z","a"],"z":{"a":2,"b":1}}',
+    )
   })
   it('collects paginated advertised contracts without invoking tools or unsupported capabilities', async () => {
     const protocol = await captureProtocol({ command: process.execPath, args: ['-e', server] })
@@ -33,13 +34,16 @@ describe('MCP protocol discovery', () => {
   })
 
   it('bounds an unresponsive process', async () => {
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', 'setInterval(() => {}, 1000)'], timeoutMs: 50 }))
-      .rejects.toThrow('MCP discovery timed out')
+    await expect(
+      captureProtocol({ command: process.execPath, args: ['-e', 'setInterval(() => {}, 1000)'], timeoutMs: 50 }),
+    ).rejects.toThrow('MCP discovery timed out')
   })
 
-  it.each(['tools', 'prompts', 'resources', 'resourceTemplates'])('rejects a missing %s array instead of publishing an empty catalog', async (key) => {
-    const capability = key === 'resourceTemplates' ? 'resources' : key
-    const fixture = `
+  it.each(['tools', 'prompts', 'resources', 'resourceTemplates'])(
+    'rejects a missing %s array instead of publishing an empty catalog',
+    async (key) => {
+      const capability = key === 'resourceTemplates' ? 'resources' : key
+      const fixture = `
       const { createInterface } = require('node:readline');
       createInterface({ input: process.stdin }).on('line', line => {
         const message = JSON.parse(line);
@@ -50,14 +54,20 @@ describe('MCP protocol discovery', () => {
             ? { resources: [] } : {};
         console.log(JSON.stringify({ jsonrpc: '2.0', id: message.id, result }));
       });`
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] }))
-      .rejects.toThrow(`missing or invalid ${key} array`)
-  })
+      await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] })).rejects.toThrow(
+        `missing or invalid ${key} array`,
+      )
+    },
+  )
 
   it('rejects an incomplete later page instead of publishing a partial catalog', async () => {
-    const fixture = server.replace("{ tools: [{ name: 'second', inputSchema: { type: 'object', properties: {} } }] }", '{}')
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] }))
-      .rejects.toThrow('missing or invalid tools array')
+    const fixture = server.replace(
+      "{ tools: [{ name: 'second', inputSchema: { type: 'object', properties: {} } }] }",
+      '{}',
+    )
+    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] })).rejects.toThrow(
+      'missing or invalid tools array',
+    )
   })
 
   it.each(['tools', 'prompts', 'resources', 'resourceTemplates'])('rejects an invalid %s registration', async (key) => {
@@ -73,12 +83,14 @@ describe('MCP protocol discovery', () => {
             ? { resources: [] } : { ${key}: [{ description: 'Missing the registration identity.' }] };
         console.log(JSON.stringify({ jsonrpc: '2.0', id: message.id, result }));
       });`
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] }))
-      .rejects.toThrow(`invalid ${key} registration`)
+    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] })).rejects.toThrow(
+      `invalid ${key} registration`,
+    )
   })
 
   it('follows an empty opaque pagination cursor', async () => {
-    const fixture = server.replace('message.params.cursor', "Object.hasOwn(message.params, 'cursor')")
+    const fixture = server
+      .replace('message.params.cursor', "Object.hasOwn(message.params, 'cursor')")
       .replace("nextCursor: 'page-two'", "nextCursor: ''")
     const protocol = await captureProtocol({ command: process.execPath, args: ['-e', fixture] })
     expect(protocol.tools.map((tool) => tool.name)).toEqual(['first', 'second'])
@@ -87,31 +99,38 @@ describe('MCP protocol discovery', () => {
   it('rejects a missing capabilities object while accepting an explicitly empty one', async () => {
     const empty = server.replace('capabilities: { tools: {} }', 'capabilities: {}')
     expect((await captureProtocol({ command: process.execPath, args: ['-e', empty] })).tools).toEqual([])
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', server.replace('capabilities: { tools: {} }', 'invalid: {}')] }))
-      .rejects.toThrow('missing or invalid capabilities object')
+    await expect(
+      captureProtocol({
+        command: process.execPath,
+        args: ['-e', server.replace('capabilities: { tools: {} }', 'invalid: {}')],
+      }),
+    ).rejects.toThrow('missing or invalid capabilities object')
   })
 
   it.each(['null', 'false', '[]'])('rejects a malformed advertised capability %s', async (value) => {
     const fixture = server.replace('capabilities: { tools: {} }', `capabilities: { tools: ${value} }`)
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] }))
-      .rejects.toThrow('invalid tools capability object')
+    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] })).rejects.toThrow(
+      'invalid tools capability object',
+    )
   })
 
   it('requires the negotiated protocol and server identity', async () => {
     const fixture = server.replace("protocolVersion: '2025-11-25', serverInfo: { name: 'fixture', version: '1' },", '')
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] }))
-      .rejects.toThrow('missing or invalid protocolVersion or serverInfo')
+    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] })).rejects.toThrow(
+      'missing or invalid protocolVersion or serverInfo',
+    )
   })
 
   it.each([-32601, -32603])('handles resource template discovery error %i', async (code) => {
-    const resources = server
-      .replace('tools: {}', 'resources: {}')
-      .replace("} else if (message.method === 'tools/list') {", `} else if (message.method === 'resources/list') {
+    const resources = server.replace('tools: {}', 'resources: {}').replace(
+      "} else if (message.method === 'tools/list') {",
+      `} else if (message.method === 'resources/list') {
         result = { resources: [{ name: 'capabilities', uri: 'tmux://capabilities' }] };
       } else if (message.method === 'resources/templates/list') {
         process.stdout.write(JSON.stringify({ jsonrpc: '2.0', id: message.id, error: { code: ${code}, message: 'template discovery failed' } }) + '\\n');
         return;
-      } else if (message.method === 'tools/list') {`)
+      } else if (message.method === 'tools/list') {`,
+    )
     const discovery = captureProtocol({ command: process.execPath, args: ['-e', resources] })
     if (code === -32601) {
       const protocol = await discovery
@@ -139,7 +158,8 @@ describe('MCP protocol discovery', () => {
           : { resourceTemplates: [{ name: 'first', uriTemplate: 'tmux://first/{id}' }], nextCursor: '' };
         console.log(JSON.stringify({ jsonrpc: '2.0', id: message.id, result }));
       });`
-    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] }))
-      .rejects.toThrow('Second page disappeared')
+    await expect(captureProtocol({ command: process.execPath, args: ['-e', fixture] })).rejects.toThrow(
+      'Second page disappeared',
+    )
   })
 })
diff --git a/packages/api-model/test/member-order.test.ts b/packages/api-model/test/member-order.test.ts
index fc4b26acc..4f5ba0dec 100644
--- a/packages/api-model/test/member-order.test.ts
+++ b/packages/api-model/test/member-order.test.ts
@@ -45,8 +45,10 @@ function violations(compare: Compare): string[] {
     for (const concept of LISTINGS) {
       const listing = byId.get(CONCEPTS[concept]!.symbols[port] ?? '')
       if (!listing?.parent) continue
-      const rank = [...children.get(listing.parent)!].sort(cmp)
-        .filter((member) => memberTier(member, signals) !== 'parent').indexOf(listing)
+      const rank = [...children.get(listing.parent)!]
+        .sort(cmp)
+        .filter((member) => memberTier(member, signals) !== 'parent')
+        .indexOf(listing)
       if (rank >= TOP) found.push(`${port}: ${concept} is #${rank + 1} on ${listing.parent}`)
     }
     for (const [owner, members] of children) {
@@ -88,25 +90,50 @@ d('member order', () => {
       .filter((symbol) => ['Server', 'Session', 'Window', 'Pane', 'Client', 'Snapshot'].includes(symbol.name))
       .map((owner) => ({ id: owner.id, members: symbols.filter((symbol) => symbol.parent === owner.id) }))
     // Cmdlets belong to their module; Julia's operations are free functions.
-    if (port === 'powershell') groups.push({ id: 'LibTmux', members: symbols.filter((symbol) => symbol.parent === 'LibTmux') })
-    if (port === 'julia') groups.push({
-      id: 'LibTmux free functions',
-      members: symbols.filter((symbol) => !symbol.parent && symbol.kind === 'function' && symbol.id.startsWith('LibTmux.')),
-    })
+    if (port === 'powershell')
+      groups.push({ id: 'LibTmux', members: symbols.filter((symbol) => symbol.parent === 'LibTmux') })
+    if (port === 'julia')
+      groups.push({
+        id: 'LibTmux free functions',
+        members: symbols.filter(
+          (symbol) => !symbol.parent && symbol.kind === 'function' && symbol.id.startsWith('LibTmux.'),
+        ),
+      })
     let checked = 0
     for (const { id, members } of groups) {
       const ordered = members.toSorted(compareMembers(signals))
-      const routine = members.filter((symbol) => ['New-TmuxSession', 'New-TmuxWindow', 'Remove-TmuxServer', 'Disconnect-TmuxControl', 'Base.close'].includes(symbol.name) ||
-        /^(new_?session|new_?window|create_?session|create_?window|close|dispose|asjava|tostring|__enter__|kill_?server)$/.test(
-          symbol.name.replace(/\(.*$/, '').replace(/Async$/, '').toLowerCase()))
-      const priority = members.filter((symbol) => symbol.doc?.deprecated === undefined && !symbol.modifiers?.includes('deprecated') && (
-        listingIds.has(symbol.publicId ?? symbol.id) ||
-        /^(?:list_?|get)?(?:sessions|windows|panes|clients|buffers)$/.test(symbol.name.replace(/\(.*$/, '').replace(/Async$/, '').toLowerCase()) ||
-        /^(search-|snapshot$)/.test(signals.conceptIds.get(symbol.publicId ?? symbol.id) ?? '')))
-      for (const listing of priority) for (const helper of routine) {
-        expect(ordered.indexOf(listing), `${id}: ${listing.name} before ${helper.name}`).toBeLessThan(ordered.indexOf(helper))
-        checked++
-      }
+      const routine = members.filter(
+        (symbol) =>
+          ['New-TmuxSession', 'New-TmuxWindow', 'Remove-TmuxServer', 'Disconnect-TmuxControl', 'Base.close'].includes(
+            symbol.name,
+          ) ||
+          /^(new_?session|new_?window|create_?session|create_?window|close|dispose|asjava|tostring|__enter__|kill_?server)$/.test(
+            symbol.name
+              .replace(/\(.*$/, '')
+              .replace(/Async$/, '')
+              .toLowerCase(),
+          ),
+      )
+      const priority = members.filter(
+        (symbol) =>
+          symbol.doc?.deprecated === undefined &&
+          !symbol.modifiers?.includes('deprecated') &&
+          (listingIds.has(symbol.publicId ?? symbol.id) ||
+            /^(?:list_?|get)?(?:sessions|windows|panes|clients|buffers)$/.test(
+              symbol.name
+                .replace(/\(.*$/, '')
+                .replace(/Async$/, '')
+                .toLowerCase(),
+            ) ||
+            /^(search-|snapshot$)/.test(signals.conceptIds.get(symbol.publicId ?? symbol.id) ?? '')),
+      )
+      for (const listing of priority)
+        for (const helper of routine) {
+          expect(ordered.indexOf(listing), `${id}: ${listing.name} before ${helper.name}`).toBeLessThan(
+            ordered.indexOf(helper),
+          )
+          checked++
+        }
       // F# currently exposes listPanes without creation or lifecycle helpers.
       if (priority.length && !routine.length) {
         expect(priority, id).toContain(ordered.find((member) => memberTier(member, signals) !== 'parent'))
@@ -153,9 +180,15 @@ d('member order', () => {
   ] as const)('puts %s %s parents first, walking toward the server', (port, owner, expected) => {
     const signals = memberSignals(port)
     const api = model(port)
-    const members = membersOf(api, api.symbols.find((symbol) => symbol.id === owner)!, signals)
+    const members = membersOf(
+      api,
+      api.symbols.find((symbol) => symbol.id === owner)!,
+      signals,
+    )
     expect(members.slice(0, expected.length).map((member) => member.name)).toEqual(expected)
-    expect(members.filter((member) => memberTier(member, signals) === 'parent').map((member) => member.name)).toEqual(expected)
+    expect(members.filter((member) => memberTier(member, signals) === 'parent').map((member) => member.name)).toEqual(
+      expected,
+    )
   })
 
   it.each(PORTS)('puts every mapped %s parent before collections and operations', (port) => {
@@ -198,13 +231,21 @@ d('member order', () => {
     ]) {
       const symbol = api.symbols.find((entry) => entry.id === `LibTmux\\${cmdlet}`)!
       expect(symbol).toMatchObject({ kind: 'function', parent: 'LibTmux' })
-      expect(symbol.signatures.some((signature) => signature.returns === `LibTmux.${result}` &&
-        signature.params.some((param) => param.name === receiver && param.type === `LibTmux.${receiver}`))).toBe(true)
+      expect(
+        symbol.signatures.some(
+          (signature) =>
+            signature.returns === `LibTmux.${result}` &&
+            signature.params.some((param) => param.name === receiver && param.type === `LibTmux.${receiver}`),
+        ),
+      ).toBe(true)
       expect(api.symbols.some((entry) => entry.id === `LibTmux.${result}`)).toBe(false)
       const handle = model('csharp').symbols.find((entry) => entry.id === `LibTmux.${result}`)!
       expect(handle, result).toBeDefined()
-      expect(membersOf(model('csharp'), handle).some((entry) => entry.name === 'Server' &&
-        memberTier(entry, memberSignals('csharp')) === 'parent')).toBe(true)
+      expect(
+        membersOf(model('csharp'), handle).some(
+          (entry) => entry.name === 'Server' && memberTier(entry, memberSignals('csharp')) === 'parent',
+        ),
+      ).toBe(true)
     }
   })
 
@@ -220,8 +261,9 @@ d('member order', () => {
       const symbol = api.symbols.find((entry) => entry.id === `LibTmux.${name}`)!
       expect(symbol.kind).toBe('function')
       expect(symbol.parent).toBeUndefined()
-      expect(symbol.signatures.map((signature) => signature.params[0].type).sort())
-        .toEqual(receiverTypes.map((type) => `LibTmux.${type}`).sort())
+      expect(symbol.signatures.map((signature) => signature.params[0].type).sort()).toEqual(
+        receiverTypes.map((type) => `LibTmux.${type}`).sort(),
+      )
       for (const type of receiverTypes) {
         const owner = api.symbols.find((entry) => entry.id === `LibTmux.${type}`)!
         expect(owner, type).toBeDefined()
@@ -232,11 +274,14 @@ d('member order', () => {
 
   it('does not promote scalar names, query fields, downward lookups, private or deprecated parents', () => {
     for (const [port, id] of [
-      ['go', 'tmux.Client.Session'], ['go', 'tmux.Pane.SessionID'],
-      ['java', 'io.github.libtmux.Server.Server.session'], ['rs', 'session.Session.window'],
+      ['go', 'tmux.Client.Session'],
+      ['go', 'tmux.Pane.SessionID'],
+      ['java', 'io.github.libtmux.Server.Server.session'],
+      ['rs', 'session.Session.window'],
       ['kotlin', 'io.github.libtmux.kotlin.Window.Companion.session'],
       ['scala', 'io.github.libtmux.scaladsl.generated.WindowFields.session'],
-      ['ts', 'selection.PaneWhere.window'], ['swift', 'Pane.windowID'],
+      ['ts', 'selection.PaneWhere.window'],
+      ['swift', 'Pane.windowID'],
     ]) {
       const symbol = model(port).symbols.find((entry) => (entry.publicId ?? entry.id) === id)!
       expect(symbol, id).toBeDefined()
@@ -245,7 +290,9 @@ d('member order', () => {
     const symbol = model('ts').symbols.find((entry) => entry.id === 'pane.Pane.server')!
     expect(memberTier({ ...symbol, modifiers: ['private'] }, memberSignals('ts'))).toBe('private')
     expect(memberTier({ ...symbol, apiScope: 'internal' }, memberSignals('ts'))).toBe('private')
-    expect(memberTier({ ...symbol, doc: { summary: '', deprecated: 'Use another handle.' } }, memberSignals('ts'))).toBe('deprecated')
+    expect(
+      memberTier({ ...symbol, doc: { summary: '', deprecated: 'Use another handle.' } }, memberSignals('ts')),
+    ).toBe('deprecated')
   })
 
   it('retains the parent relation when a broader concept also names the symbol', () => {
@@ -268,7 +315,9 @@ d('member order', () => {
     const privateReceiver = { ...owner, id: 'libtmux::PrivateRow', publicId: 'libtmux::PrivateRow' }
     expect(membersOf({ ...api, symbols: [...api.symbols, privateReceiver] }, privateReceiver)).toEqual([])
     const override = { ...source, id: `${owner.id}::server`, publicId: `${owner.id}::server`, parent: owner.id }
-    expect(membersOf({ ...api, symbols: [...api.symbols, override] }, owner).filter((member) => member.name === 'server')).toEqual([override])
+    expect(
+      membersOf({ ...api, symbols: [...api.symbols, override] }, owner).filter((member) => member.name === 'server'),
+    ).toEqual([override])
     expect(JSON.stringify(api)).toBe(before)
   })
 })
diff --git a/packages/api-model/test/mentions.test.ts b/packages/api-model/test/mentions.test.ts
index a1bc28c81..6d3c5802e 100644
--- a/packages/api-model/test/mentions.test.ts
+++ b/packages/api-model/test/mentions.test.ts
@@ -30,7 +30,7 @@ describe('prose mentions', () => {
   })
 
   it('keeps sentence context and table port labels', () => {
-    const source = "Python uses `Session.panes`.\n\n| Go | `Session.Panes` |"
+    const source = 'Python uses `Session.panes`.\n\n| Go | `Session.Panes` |'
     expect(proseMentions(source, LABELS).map(({ start: _start, end: _end, ...mention }) => mention)).toEqual([
       { text: 'Session.panes', port: undefined, before: 'Python uses ', line: 1 },
       { text: 'Session.Panes', port: 'go', before: '| Go | ', line: 3 },
@@ -39,8 +39,12 @@ describe('prose mentions', () => {
 
   it('ignores frontmatter and fenced examples but keeps a fence language for subsequent prose', () => {
     const source = [
-      '---', 'description: "`Server`"', '---',
-      '~~~python', '`not_a_reference`', '~~~',
+      '---',
+      'description: "`Server`"',
+      '---',
+      '~~~python',
+      '`not_a_reference`',
+      '~~~',
       'Read `Server.sessions`.',
       '## Other material',
       'Read `Server`.',
diff --git a/packages/api-model/test/native-adapters.test.ts b/packages/api-model/test/native-adapters.test.ts
index 2be306ce0..7d64258d9 100644
--- a/packages/api-model/test/native-adapters.test.ts
+++ b/packages/api-model/test/native-adapters.test.ts
@@ -17,29 +17,57 @@ describe('Ruby native documentation adapter', () => {
     ],
     namespaces: [
       {
-        id: 'LibTmux::Pane', name: 'Pane', kind: 'class', package: 'libtmux', product: 'core',
+        id: 'LibTmux::Pane',
+        name: 'Pane',
+        kind: 'class',
+        package: 'libtmux',
+        product: 'core',
         documentation: 'A pane handle.\n\nBound to one server.',
         source: { path: 'gems/libtmux/lib/libtmux/pane.rb', line: 12 },
       },
     ],
-    aliases: [{
-      id: 'LibTmux::Async::scope_diagnostics', name: 'scope_diagnostics', package: 'libtmux-async',
-      product: 'core', type: '{ closed: bool }',
-      source: { path: 'gems/libtmux-async/sig/libtmux-async.rbs', line: 7 },
-    }],
+    aliases: [
+      {
+        id: 'LibTmux::Async::scope_diagnostics',
+        name: 'scope_diagnostics',
+        package: 'libtmux-async',
+        product: 'core',
+        type: '{ closed: bool }',
+        source: { path: 'gems/libtmux-async/sig/libtmux-async.rbs', line: 7 },
+      },
+    ],
     symbols: [
       {
-        id: 'LibTmux::Pane#active?', owner: 'LibTmux::Pane#active?', namespace: 'LibTmux::Pane',
-        name: 'active?', kind: 'method', method_kind: 'instance', package: 'libtmux', product: 'core',
-        visibility: 'public', signatures: ['() -> bool'], returns: ['bool'], documentation: 'Whether this pane is active.',
-        tags: [], contract: { id: 'pane-state', title: 'Pane state' },
+        id: 'LibTmux::Pane#active?',
+        owner: 'LibTmux::Pane#active?',
+        namespace: 'LibTmux::Pane',
+        name: 'active?',
+        kind: 'method',
+        method_kind: 'instance',
+        package: 'libtmux',
+        product: 'core',
+        visibility: 'public',
+        signatures: ['() -> bool'],
+        returns: ['bool'],
+        documentation: 'Whether this pane is active.',
+        tags: [],
+        contract: { id: 'pane-state', title: 'Pane state' },
         source: { path: 'gems/libtmux/lib/libtmux/pane.rb', line: 30 },
       },
       {
-        id: 'LibTmux::Pane.active?', owner: 'LibTmux::Pane.active?', namespace: 'LibTmux::Pane',
-        name: 'active?', kind: 'method', method_kind: 'singleton', package: 'libtmux', product: 'core',
-        visibility: 'public', signatures: ['(name: ::String, ?force: bool) -> ::LibTmux::Pane'],
-        returns: ['::LibTmux::Pane'], documentation: '', tags: [],
+        id: 'LibTmux::Pane.active?',
+        owner: 'LibTmux::Pane.active?',
+        namespace: 'LibTmux::Pane',
+        name: 'active?',
+        kind: 'method',
+        method_kind: 'singleton',
+        package: 'libtmux',
+        product: 'core',
+        visibility: 'public',
+        signatures: ['(name: ::String, ?force: bool) -> ::LibTmux::Pane'],
+        returns: ['::LibTmux::Pane'],
+        documentation: '',
+        tags: [],
         contract: { id: 'pane-state', title: 'Pane state' },
         source: { path: 'gems/libtmux/lib/libtmux/pane.rb', line: 40 },
       },
@@ -84,13 +112,20 @@ describe('Ruby native documentation adapter', () => {
     const input = {
       ...artifact,
       examples: {
-        manifest: { programs: [{
-          id: 'pane_active', path: 'examples/api/active.rb', gem: 'libtmux',
-          api: {
-            symbols: ['LibTmux::Pane', 'LibTmux::Pane#active?'],
-            description: 'Read pane state.', output: 'active\n',
-          },
-        }] },
+        manifest: {
+          programs: [
+            {
+              id: 'pane_active',
+              path: 'examples/api/active.rb',
+              gem: 'libtmux',
+              api: {
+                symbols: ['LibTmux::Pane', 'LibTmux::Pane#active?'],
+                description: 'Read pane state.',
+                output: 'active\n',
+              },
+            },
+          ],
+        },
         files: [{ path: 'examples/api/active.rb', content: code }],
       },
     }
@@ -99,21 +134,26 @@ describe('Ruby native documentation adapter', () => {
       const symbol = model.symbols.find((entry) => entry.id === id)!
       expect(symbol.doc?.examples).toHaveLength(5)
       expect(symbol.doc!.examples![2]).toMatchObject({
-        lang: 'ruby', code,
+        lang: 'ruby',
+        code,
         sourceUrl: `https://github.com/libtmux/libtmux-ruby/blob/${REVISION}/examples/api/active.rb`,
       })
       expect(symbol.doc!.examples![4]).toMatchObject({ lang: 'text', code: 'active\n' })
     }
-    expect(model.symbols.find((entry) => entry.id === 'LibTmux::Pane#active?')?.doc?.summary)
-      .toBe('Whether this pane is active.')
-    expect(model.symbols.find((entry) => entry.id === 'LibTmux::Pane.active?')?.doc?.examples)
-      .toBeUndefined()
+    expect(model.symbols.find((entry) => entry.id === 'LibTmux::Pane#active?')?.doc?.summary).toBe(
+      'Whether this pane is active.',
+    )
+    expect(model.symbols.find((entry) => entry.id === 'LibTmux::Pane.active?')?.doc?.examples).toBeUndefined()
   })
 })
 
 describe('Lua native documentation adapter', () => {
   const definition = (file: string, line: number) => ({
-    file, start: [line, 0], finish: [line, 1], type: 'doc.class', visible: 'public',
+    file,
+    start: [line, 0],
+    finish: [line, 1],
+    type: 'doc.class',
+    visible: 'public',
   })
   const artifact = {
     schema: 1,
@@ -123,29 +163,53 @@ describe('Lua native documentation adapter', () => {
     package: { name: 'libtmux', version: '0.1.0alpha1-1', source_tag: 'v0.1.0alpha1' },
     declarations: [
       {
-        name: 'libtmux.query', type: 'type', view: 'libtmux.query',
+        name: 'libtmux.query',
+        type: 'type',
+        view: 'libtmux.query',
         defines: [definition('lua/libtmux/query.lua', 3)],
-        fields: [{
-          name: 'where', file: 'lua/libtmux/query.lua', start: [20, 0], type: 'setfield', view: 'function',
-          rawdesc: 'Filter records.', visible: 'public',
-          extends: {
-            args: [{ name: 'rows', view: 'T[]' }, { name: 'criteria', view: 'libtmux.Where' }],
-            returns: [{ view: 'libtmux.Selection<T>' }],
-            view: 'function libtmux.query.where(rows: T[], criteria: libtmux.Where) -> libtmux.Selection<T>',
+        fields: [
+          {
+            name: 'where',
+            file: 'lua/libtmux/query.lua',
+            start: [20, 0],
+            type: 'setfield',
+            view: 'function',
+            rawdesc: 'Filter records.',
+            visible: 'public',
+            extends: {
+              args: [
+                { name: 'rows', view: 'T[]' },
+                { name: 'criteria', view: 'libtmux.Where' },
+              ],
+              returns: [{ view: 'libtmux.Selection<T>' }],
+              view: 'function libtmux.query.where(rows: T[], criteria: libtmux.Where) -> libtmux.Selection<T>',
+            },
           },
-        }],
+        ],
       },
       {
-        name: 'libtmux.Request', type: 'type', view: 'libtmux.Request<T>',
+        name: 'libtmux.Request',
+        type: 'type',
+        view: 'libtmux.Request<T>',
         defines: [definition('lua/libtmux/_internal/runtime.lua', 100)],
-        fields: [{
-          name: 'await', file: 'lua/libtmux/_internal/runtime.lua', start: [120, 0], type: 'doc.field',
-          view: 'fun(self: libtmux.Request<T>, timeout?: number):T?, libtmux.Error?', rawdesc: 'Wait for completion.',
-          visible: 'public', extends: {
-            args: [{ name: 'self', view: 'libtmux.Request<T>' }, { name: 'timeout', view: 'number?' }],
-            returns: [{ view: 'T?' }, { name: 'error', view: 'libtmux.Error?' }],
+        fields: [
+          {
+            name: 'await',
+            file: 'lua/libtmux/_internal/runtime.lua',
+            start: [120, 0],
+            type: 'doc.field',
+            view: 'fun(self: libtmux.Request<T>, timeout?: number):T?, libtmux.Error?',
+            rawdesc: 'Wait for completion.',
+            visible: 'public',
+            extends: {
+              args: [
+                { name: 'self', view: 'libtmux.Request<T>' },
+                { name: 'timeout', view: 'number?' },
+              ],
+              returns: [{ view: 'T?' }, { name: 'error', view: 'libtmux.Error?' }],
+            },
           },
-        }],
+        ],
       },
     ],
     guides: [],
@@ -184,38 +248,50 @@ describe('Lua native documentation adapter', () => {
     })
     const typed = {
       ...artifact,
-      declarations: [{
-        name: 'libtmux.Server', type: 'type', view: 'libtmux.Server',
-        defines: [definition('lua/libtmux/_internal/server.lua', 600)],
-        fields: [
-          {
-            name: 'new_session', file: 'lua/libtmux/_internal/server.lua', start: [610, 0], type: 'doc.field',
-            view: 'fun(self: libtmux.Server, options?: libtmux.NewSessionOptions):libtmux.Request<libtmux.Creation>',
-            visible: 'public',
-            extends: {
-              type: 'doc.type',
+      declarations: [
+        {
+          name: 'libtmux.Server',
+          type: 'type',
+          view: 'libtmux.Server',
+          defines: [definition('lua/libtmux/_internal/server.lua', 600)],
+          fields: [
+            {
+              name: 'new_session',
+              file: 'lua/libtmux/_internal/server.lua',
+              start: [610, 0],
+              type: 'doc.field',
               view: 'fun(self: libtmux.Server, options?: libtmux.NewSessionOptions):libtmux.Request<libtmux.Creation>',
-              types: [{
-                type: 'doc.type.function',
-                args: [arg('self', 'libtmux.Server'), arg('options', '(libtmux.NewSessionOptions)?')],
-                returns: [{ view: 'libtmux.Request<libtmux.Creation>' }],
-              }],
+              visible: 'public',
+              extends: {
+                type: 'doc.type',
+                view: 'fun(self: libtmux.Server, options?: libtmux.NewSessionOptions):libtmux.Request<libtmux.Creation>',
+                types: [
+                  {
+                    type: 'doc.type.function',
+                    args: [arg('self', 'libtmux.Server'), arg('options', '(libtmux.NewSessionOptions)?')],
+                    returns: [{ view: 'libtmux.Request<libtmux.Creation>' }],
+                  },
+                ],
+              },
             },
-          },
-          {
-            name: 'handle', file: 'lua/libtmux/_internal/server.lua', start: [620, 0], type: 'doc.field',
-            view: 'fun(self: libtmux.Server, record: libtmux.SnapshotSession)|fun(self: libtmux.Server, record: libtmux.SnapshotPane)',
-            visible: 'public',
-            extends: {
-              type: 'doc.type',
-              types: [
-                { type: 'doc.type', types: [fn('libtmux.SnapshotSession', 'libtmux.Session')] },
-                { type: 'doc.type', types: [fn('libtmux.SnapshotPane', 'libtmux.Pane')] },
-              ],
+            {
+              name: 'handle',
+              file: 'lua/libtmux/_internal/server.lua',
+              start: [620, 0],
+              type: 'doc.field',
+              view: 'fun(self: libtmux.Server, record: libtmux.SnapshotSession)|fun(self: libtmux.Server, record: libtmux.SnapshotPane)',
+              visible: 'public',
+              extends: {
+                type: 'doc.type',
+                types: [
+                  { type: 'doc.type', types: [fn('libtmux.SnapshotSession', 'libtmux.Session')] },
+                  { type: 'doc.type', types: [fn('libtmux.SnapshotPane', 'libtmux.Pane')] },
+                ],
+              },
             },
-          },
-        ],
-      }],
+          ],
+        },
+      ],
     }
     const model = extractLua(typed)
     const create = model.symbols.find((s) => s.id === 'libtmux.Server:new_session')!
@@ -233,13 +309,21 @@ describe('Lua native documentation adapter', () => {
 
   it('credits a field LuaLS copied into a subclass to the class that declared it', () => {
     const field = (name: string, line: number) => ({
-      name, file: 'lua/libtmux/_internal/entity.lua', start: [line, 0], type: 'doc.field',
-      view: `fun(self: libtmux.Entity<T>)`, visible: 'public',
+      name,
+      file: 'lua/libtmux/_internal/entity.lua',
+      start: [line, 0],
+      type: 'doc.field',
+      view: `fun(self: libtmux.Entity<T>)`,
+      visible: 'public',
       extends: { args: [{ name: 'self', view: 'libtmux.Entity<T>' }], returns: [] },
     })
     const declare = (name: string, parent: string | undefined, fields: ReturnType<typeof field>[]) => ({
-      name, type: 'type', view: name,
-      defines: [{ ...definition('lua/libtmux/_internal/entity.lua', 1), ...(parent ? { extends: [{ view: parent }] } : {}) }],
+      name,
+      type: 'type',
+      view: name,
+      defines: [
+        { ...definition('lua/libtmux/_internal/entity.lua', 1), ...(parent ? { extends: [{ view: parent }] } : {}) },
+      ],
       fields,
     })
     const hierarchy = {
@@ -248,19 +332,26 @@ describe('Lua native documentation adapter', () => {
         declare('libtmux.Entity', undefined, [field('snapshot', 10)]),
         declare('libtmux.Configurable', 'libtmux.Entity<T>', [field('snapshot', 10), field('get_option', 20)]),
         declare('libtmux.Session', 'libtmux.Configurable<libtmux.SnapshotSession>', [
-          field('snapshot', 10), field('get_option', 20), field('new_window', 30),
+          field('snapshot', 10),
+          field('get_option', 20),
+          field('new_window', 30),
         ]),
       ],
     }
     const inherited = (model: ReturnType<typeof extractLua>) =>
-      Object.fromEntries(model.symbols.filter((s) => s.parent === 'libtmux.Session').map((s) => [s.name, s.inheritedFrom]))
+      Object.fromEntries(
+        model.symbols.filter((s) => s.parent === 'libtmux.Session').map((s) => [s.name, s.inheritedFrom]),
+      )
     expect(inherited(extractLua(hierarchy))).toEqual({
       snapshot: 'libtmux.Entity',
       get_option: 'libtmux.Configurable',
       new_window: undefined,
     })
     // A cycle in `extends` ends the walk instead of the stack.
-    hierarchy.declarations[0]!.defines[0] = { ...hierarchy.declarations[0]!.defines[0]!, extends: [{ view: 'libtmux.Session' }] }
+    hierarchy.declarations[0]!.defines[0] = {
+      ...hierarchy.declarations[0]!.defines[0]!,
+      extends: [{ view: 'libtmux.Session' }],
+    }
     expect(inherited(extractLua(hierarchy)).get_option).toBe('libtmux.Configurable')
   })
 })
diff --git a/packages/api-model/test/nav-config.test.ts b/packages/api-model/test/nav-config.test.ts
index b242eac18..b4ff27216 100644
--- a/packages/api-model/test/nav-config.test.ts
+++ b/packages/api-model/test/nav-config.test.ts
@@ -5,12 +5,7 @@ import { compileNav } from '../src/nav.ts'
 import { navSidecar } from '../src/nav-sidecar.ts'
 import type { ApiModel, ApiSymbol } from '../src/model.ts'
 
-const symbol = (
-  id: string,
-  name: string,
-  file: string,
-  apiScope: ApiSymbol['apiScope'] = 'exported',
-): ApiSymbol => ({
+const symbol = (id: string, name: string, file: string, apiScope: ApiSymbol['apiScope'] = 'exported'): ApiSymbol => ({
   id,
   name,
   kind: 'class',
@@ -39,7 +34,14 @@ it('keeps explicit workspace helpers out of unrelated naming buckets', () => {
   const compiled = compileNav(
     NAV.cxx,
     [
-      { ...symbol('libtmux::workspace::BuildEvent', 'BuildEvent', 'examples/workspace/include/libtmux_consumers/workspace.hpp'), kind: 'struct' },
+      {
+        ...symbol(
+          'libtmux::workspace::BuildEvent',
+          'BuildEvent',
+          'examples/workspace/include/libtmux_consumers/workspace.hpp',
+        ),
+        kind: 'struct',
+      },
       symbol('libtmux::OtherEvent', 'OtherEvent', 'include/libtmux/events.hpp'),
     ],
     { conceptIds: {}, moduleOf: () => 'libtmux' },
@@ -65,18 +67,21 @@ it('groups F# command composition and dispatch failures by their task', () => {
 })
 
 describe('native PowerShell and Julia navigation', () => {
-  const model = (port: string): ApiModel => JSON.parse(
-    readFileSync(new URL(`../../../site/src/data/api/${port}.json`, import.meta.url), 'utf8'),
-  )
+  const model = (port: string): ApiModel =>
+    JSON.parse(readFileSync(new URL(`../../../site/src/data/api/${port}.json`, import.meta.url), 'utf8'))
 
   it('places PowerShell command chains, literal pane input and owned event operations by task', () => {
     const nav = navSidecar('powershell', model('powershell'))!
     expect(nav.placement).toMatchObject({
-      'LibTmux\\Invoke-TmuxChain': 'commands', 'LibTmux\\Send-TmuxText': 'pane',
-      'LibTmux\\Wait-TmuxChannel': 'control', 'LibTmux\\Watch-TmuxEvent': 'control',
+      'LibTmux\\Invoke-TmuxChain': 'commands',
+      'LibTmux\\Send-TmuxText': 'pane',
+      'LibTmux\\Wait-TmuxChannel': 'control',
+      'LibTmux\\Watch-TmuxEvent': 'control',
     })
     expect(nav.assignments.server.slice(0, 3).map((entry) => entry.id)).toEqual([
-      'LibTmux\\New-TmuxServer', 'LibTmux\\Get-TmuxServer', 'LibTmux\\Connect-TmuxServer',
+      'LibTmux\\New-TmuxServer',
+      'LibTmux\\Get-TmuxServer',
+      'LibTmux\\Connect-TmuxServer',
     ])
     expect(nav.unplaced.map((entry) => entry.id)).toEqual(['LibTmux'])
     expect(nav.diagnostics.unmatched).toEqual([])
@@ -87,8 +92,18 @@ describe('native PowerShell and Julia navigation', () => {
   it('keeps Julia predicates, native interface extensions and workspace functions with their operations', () => {
     const nav = navSidecar('julia', model('julia'))!
     const expected = {
-      queries: ['Criterion', 'Selection', 'WireObject', 'Filters.OneOf', 'Filters.AllRelated',
-        'RowProjection', 'Base.IndexStyle', 'Base.getindex', 'Tables.schema', 'Tables.rows'],
+      queries: [
+        'Criterion',
+        'Selection',
+        'WireObject',
+        'Filters.OneOf',
+        'Filters.AllRelated',
+        'RowProjection',
+        'Base.IndexStyle',
+        'Base.getindex',
+        'Tables.schema',
+        'Tables.rows',
+      ],
       control: ['ObservationCursor', 'ObservationStream', 'observe_output', 'Base.iterate', 'Base.take!'],
       snapshots: ['snapshotof', 'hascoverage', 'Base.propertynames'],
       commands: ['run_batch', 'run_group'],
@@ -106,14 +121,25 @@ describe('native PowerShell and Julia navigation', () => {
     expect(nav.placement['LibTmuxWorkspace.Base.showerror']).toBe('errors')
     expect(nav.assignments.server[0].id).toBe('LibTmux.Server')
     expect(nav.assignments.session[0].id).toBe('LibTmux.sessions')
-    expect(nav.buckets.slice(0, 5).map((bucket) => bucket.id)).toEqual(['server', 'session', 'window', 'pane', 'client'])
+    expect(nav.buckets.slice(0, 5).map((bucket) => bucket.id)).toEqual([
+      'server',
+      'session',
+      'window',
+      'pane',
+      'client',
+    ])
     expect(nav.diagnostics.unmatched).toEqual([])
     expect(nav.diagnostics.ambiguous).toEqual([])
     expect(nav.diagnostics.staleUnsettled).toEqual([])
-    expect(nav.unplaced.map((entry) => entry.id).sort()).toEqual([
-      'LibTmux', 'LibTmux.EntityRef', 'LibTmux.TmuxID', 'LibTmux.entitykey',
-      ...['==', 'hash', 'isequal', 'string', 'show'].map((name) => `LibTmux.Base.${name}`),
-    ].sort())
+    expect(nav.unplaced.map((entry) => entry.id).sort()).toEqual(
+      [
+        'LibTmux',
+        'LibTmux.EntityRef',
+        'LibTmux.TmuxID',
+        'LibTmux.entitykey',
+        ...['==', 'hash', 'isequal', 'string', 'show'].map((name) => `LibTmux.Base.${name}`),
+      ].sort(),
+    )
   })
 
   it.each(['powershell', 'julia'])('still reports a new unrelated public declaration in %s', (port) => {
diff --git a/packages/api-model/test/nav-sidecar.test.ts b/packages/api-model/test/nav-sidecar.test.ts
index 34151cac6..8e9bde976 100644
--- a/packages/api-model/test/nav-sidecar.test.ts
+++ b/packages/api-model/test/nav-sidecar.test.ts
@@ -5,63 +5,125 @@ import { NAV } from '../src/nav-config.ts'
 import { navSidecar, navSidecarFor, type NavConfig } from '../src/nav-sidecar.ts'
 
 const symbol = (id: string, kind: ApiSymbol['kind'], parent?: string): ApiSymbol => ({
-  id, name: id, kind, parent, slug: id, modifiers: [], signatures: [],
-  apiScope: 'internal', source: { file: 'tmux.h' },
+  id,
+  name: id,
+  kind,
+  parent,
+  slug: id,
+  modifiers: [],
+  signatures: [],
+  apiScope: 'internal',
+  source: { file: 'tmux.h' },
 })
 
 describe('explicit catalog navigation', () => {
   it('compiles native unions, free declarations and diagnostics without a library port', () => {
-    const model: ApiModelBase = { extractor: 'fixture', symbols: [
-      symbol('read_value', 'function'), symbol('value', 'union'),
-      symbol('integer', 'attribute', 'value'), symbol('orphan', 'constant'),
-    ] }
-    const config: NavConfig = { buckets: [
-      { id: 'types', label: 'Types', match: { kind: 'symbol', kinds: ['union'] } },
-      { id: 'functions', label: 'Functions', match: { kind: 'symbol', kinds: ['function'] } },
-      { id: 'missing', label: 'Missing', match: { kind: 'name', prefix: 'not_present' } },
-    ] }
+    const model: ApiModelBase = {
+      extractor: 'fixture',
+      symbols: [
+        symbol('read_value', 'function'),
+        symbol('value', 'union'),
+        symbol('integer', 'attribute', 'value'),
+        symbol('orphan', 'constant'),
+      ],
+    }
+    const config: NavConfig = {
+      buckets: [
+        { id: 'types', label: 'Types', match: { kind: 'symbol', kinds: ['union'] } },
+        { id: 'functions', label: 'Functions', match: { kind: 'symbol', kinds: ['function'] } },
+        { id: 'missing', label: 'Missing', match: { kind: 'name', prefix: 'not_present' } },
+      ],
+    }
     const actual = navSidecarFor('tmux:3.7c', model, config)
     expect(actual.port).toBe('tmux:3.7c')
     expect(actual.assignments.types.map((entry) => entry.id)).toEqual(['value'])
     expect(actual.assignments.functions.map((entry) => entry.id)).toEqual(['read_value'])
     expect(actual.placement).toEqual({ value: 'types', read_value: 'functions', orphan: '__unplaced' })
-    expect(actual.diagnostics).toEqual({ unmatched: ['orphan'], deadBuckets: ['missing'], ambiguous: [], staleUnsettled: [] })
+    expect(actual.diagnostics).toEqual({
+      unmatched: ['orphan'],
+      deadBuckets: ['missing'],
+      ambiguous: [],
+      staleUnsettled: [],
+    })
     expect(actual.unplaced.map((entry) => entry.id)).toEqual(['orphan'])
     expect(model).not.toHaveProperty('port')
   })
 
   it('keeps union owners before free declarations and retains nested bucket shape', () => {
-    const model: ApiModelBase = { extractor: 'fixture', symbols: [symbol('a_function', 'function'), symbol('z_union', 'union')] }
-    const config: NavConfig = { buckets: [{ id: 'root', label: 'Root', match: { kind: 'path', re: 'tmux.h' }, children: [
-      { id: 'child', label: 'Child', match: { kind: 'path', re: 'tmux.h' }, children: [
-        { id: 'leaf', label: 'Leaf', match: { kind: 'path', re: 'tmux.h' } },
-      ] },
-    ] }] }
+    const model: ApiModelBase = {
+      extractor: 'fixture',
+      symbols: [symbol('a_function', 'function'), symbol('z_union', 'union')],
+    }
+    const config: NavConfig = {
+      buckets: [
+        {
+          id: 'root',
+          label: 'Root',
+          match: { kind: 'path', re: 'tmux.h' },
+          children: [
+            {
+              id: 'child',
+              label: 'Child',
+              match: { kind: 'path', re: 'tmux.h' },
+              children: [{ id: 'leaf', label: 'Leaf', match: { kind: 'path', re: 'tmux.h' } }],
+            },
+          ],
+        },
+      ],
+    }
     const actual = navSidecarFor('tmux', model, config)
     expect(actual.buckets[0].children?.[0].children?.[0].id).toBe('leaf')
     expect(actual.assignments.leaf.map((entry) => entry.id)).toEqual(['z_union', 'a_function'])
   })
 
   it('ranks assigned exact ids before defaults without moving or duplicating declarations', () => {
-    const model: ApiModelBase = { extractor: 'fixture', symbols: [
-      symbol('first', 'struct'), { ...symbol('native_second', 'union'), publicId: 'second' },
-      symbol('a_function', 'function'), symbol('z_function', 'function'), symbol('a_constant', 'constant'),
-      { ...symbol('elsewhere', 'struct'), source: { file: 'other.c' } },
-    ] }
-    const config: NavConfig = { buckets: [{ id: 'root', label: 'Root', match: { kind: 'path', re: '^tmux.h$' }, children: [
-      { id: 'nested', label: 'Nested', match: { kind: 'path', re: '^tmux.h$' },
-        order: ['z_function', 'second', 'z_function', 'missing', 'elsewhere'] },
-    ] }, { id: 'other', label: 'Other', match: { kind: 'path', re: '^other.c$' } }] }
+    const model: ApiModelBase = {
+      extractor: 'fixture',
+      symbols: [
+        symbol('first', 'struct'),
+        { ...symbol('native_second', 'union'), publicId: 'second' },
+        symbol('a_function', 'function'),
+        symbol('z_function', 'function'),
+        symbol('a_constant', 'constant'),
+        { ...symbol('elsewhere', 'struct'), source: { file: 'other.c' } },
+      ],
+    }
+    const config: NavConfig = {
+      buckets: [
+        {
+          id: 'root',
+          label: 'Root',
+          match: { kind: 'path', re: '^tmux.h$' },
+          children: [
+            {
+              id: 'nested',
+              label: 'Nested',
+              match: { kind: 'path', re: '^tmux.h$' },
+              order: ['z_function', 'second', 'z_function', 'missing', 'elsewhere'],
+            },
+          ],
+        },
+        { id: 'other', label: 'Other', match: { kind: 'path', re: '^other.c$' } },
+      ],
+    }
     const original = structuredClone(config)
     const baseline = structuredClone(config)
     delete baseline.buckets[0].children![0].order
     const before = navSidecarFor('tmux', model, baseline)
     const actual = navSidecarFor('tmux', model, config)
     expect(before.assignments.nested.map((entry) => entry.id)).toEqual([
-      'first', 'second', 'a_constant', 'a_function', 'z_function',
+      'first',
+      'second',
+      'a_constant',
+      'a_function',
+      'z_function',
     ])
     expect(actual.assignments.nested.map((entry) => entry.id)).toEqual([
-      'z_function', 'second', 'first', 'a_constant', 'a_function',
+      'z_function',
+      'second',
+      'first',
+      'a_constant',
+      'a_function',
     ])
     expect(actual.assignments.other).toEqual(before.assignments.other)
     expect(actual.placement).toEqual(before.placement)
@@ -70,11 +132,16 @@ describe('explicit catalog navigation', () => {
   })
 
   it('keeps contextual shortcuts separate from canonical placement and rejects missing targets', () => {
-    const model: ApiModelBase = { extractor: 'fixture', symbols: [symbol('owner', 'struct'), symbol('list_items', 'function')] }
-    const config: NavConfig = { buckets: [
-      { id: 'owner', label: 'Owner', match: { kind: 'id', is: 'owner' }, shortcuts: ['list_items'] },
-      { id: 'items', label: 'Items', match: { kind: 'id', is: 'list_items' } },
-    ] }
+    const model: ApiModelBase = {
+      extractor: 'fixture',
+      symbols: [symbol('owner', 'struct'), symbol('list_items', 'function')],
+    }
+    const config: NavConfig = {
+      buckets: [
+        { id: 'owner', label: 'Owner', match: { kind: 'id', is: 'owner' }, shortcuts: ['list_items'] },
+        { id: 'items', label: 'Items', match: { kind: 'id', is: 'list_items' } },
+      ],
+    }
     const before = structuredClone(model)
     const actual = navSidecarFor('fixture', model, config)
     expect(actual.buckets[0].shortcuts?.map((entry) => entry.id)).toEqual(['list_items'])
@@ -89,7 +156,9 @@ describe('explicit catalog navigation', () => {
 
 describe('existing port sidecars', () => {
   it.each(Object.keys(NAV))('keeps the generated %s sidecar byte-equivalent', (port) => {
-    const model = JSON.parse(readFileSync(new URL(`../../../site/src/data/api/${port}.json`, import.meta.url), 'utf8')) as ApiModel
+    const model = JSON.parse(
+      readFileSync(new URL(`../../../site/src/data/api/${port}.json`, import.meta.url), 'utf8'),
+    ) as ApiModel
     const expected = readFileSync(new URL(`../../../site/src/data/api/${port}.nav.json`, import.meta.url), 'utf8')
     expect(`${JSON.stringify(navSidecar(port, model))}\n`).toBe(expected)
   })
diff --git a/packages/api-model/test/nearest.test.ts b/packages/api-model/test/nearest.test.ts
index d5a31f681..aa6a2061d 100644
--- a/packages/api-model/test/nearest.test.ts
+++ b/packages/api-model/test/nearest.test.ts
@@ -36,27 +36,38 @@ const linkFor = (idx: SymbolIndex, annotation: string, name: string, context?: A
 it('resolves an explicit source import before a same-named local declaration', () => {
   const idx = new SymbolIndex([sym('example.Server'), sym('other.Server')], (s) => `/${s.id}/`, 'kotlin')
   const from = { ...sym('example.connect', 'function'), imports: { Server: 'other.Server', JavaServer: 'java.Server' } }
-  idx.addInventory('https://example.org/', [{ name: 'java.Server', type: 'std:label', priority: 1, uri: 'server', dispname: '-' }], ['kotlin'])
+  idx.addInventory(
+    'https://example.org/',
+    [{ name: 'java.Server', type: 'std:label', priority: 1, uri: 'server', dispname: '-' }],
+    ['kotlin'],
+  )
   expect(linkFor(idx, 'Server', 'Server', from)?.href).toBe('/other.Server/')
   expect(linkFor(idx, 'JavaServer', 'JavaServer', from)?.href).toBe('https://example.org/server')
 })
 
 it('links F# types around apostrophe-prefixed generic parameters', () => {
   const idx = new SymbolIndex([sym('Filter'), sym('Field')], (s) => `/${s.id}/`, 'fsharp')
-  expect(idx.linkType("Filter<'T> -> Field<'T, 'Value>").filter((span) => span.link).map((span) => span.text))
-    .toEqual(['Filter', 'Field'])
+  expect(
+    idx
+      .linkType("Filter<'T> -> Field<'T, 'Value>")
+      .filter((span) => span.link)
+      .map((span) => span.text),
+  ).toEqual(['Filter', 'Field'])
 })
 
 it('keeps Julia symbol literals separate from same-named APIs', () => {
-  const idx = new SymbolIndex([
-    sym('LibTmux.TmuxID'), sym('LibTmux.session', 'function'), sym('LibTmux.window', 'function'),
-  ], (s) => `/${s.id}/`, 'julia')
+  const idx = new SymbolIndex(
+    [sym('LibTmux.TmuxID'), sym('LibTmux.session', 'function'), sym('LibTmux.window', 'function')],
+    (s) => `/${s.id}/`,
+    'julia',
+  )
   expect(linkFor(idx, 'session', 'session')?.href).toBe('/LibTmux.session/')
   for (const annotation of ['TmuxID{:session}', '::TmuxID{:window}', 'Tuple{:session, :window}']) {
     const spans = idx.linkType(annotation)
     expect(spans.map((span) => span.text).join('')).toBe(annotation)
-    expect(spans.filter((span) => span.link).map((span) => span.text))
-      .toEqual(annotation.includes('TmuxID') ? ['TmuxID'] : [])
+    expect(spans.filter((span) => span.link).map((span) => span.text)).toEqual(
+      annotation.includes('TmuxID') ? ['TmuxID'] : [],
+    )
   }
 })
 
@@ -64,15 +75,28 @@ it('links Julia types after annotations without linking declaration names', () =
   const server = sym('LibTmux.Server')
   const id = sym('LibTmux.TmuxID')
   const idx = new SymbolIndex([server, id], (s) => `/${s.id}/`, 'julia')
-  const signature = { raw: 'LibTmux.Server(value::LibTmux.TmuxID{K}; socket_path) where K',
-    params: [{ name: 'value', type: 'LibTmux.TmuxID{K}' }, { name: 'socket_path', keywordOnly: true }], typeParams: ['K'] }
+  const signature = {
+    raw: 'LibTmux.Server(value::LibTmux.TmuxID{K}; socket_path) where K',
+    params: [
+      { name: 'value', type: 'LibTmux.TmuxID{K}' },
+      { name: 'socket_path', keywordOnly: true },
+    ],
+    typeParams: ['K'],
+  }
   const spans = idx.linkType(signature.raw, server, signature)
   expect(spans.map((span) => span.text).join('')).toBe(signature.raw)
   expect(spans.filter((span) => span.link).map((span) => span.link?.href)).toEqual([
-    '/LibTmux.Server/#LibTmux.Server.parameter.value', '/LibTmux.TmuxID/',
+    '/LibTmux.Server/#LibTmux.Server.parameter.value',
+    '/LibTmux.TmuxID/',
     '/LibTmux.Server/#LibTmux.Server.parameter.socket_path',
   ])
-  expect(spans.filter((span) => span.declaration).map((span) => span.text)).toEqual(['Server', 'value', 'K', 'socket_path', 'K'])
+  expect(spans.filter((span) => span.declaration).map((span) => span.text)).toEqual([
+    'Server',
+    'value',
+    'K',
+    'socket_path',
+    'K',
+  ])
   expect(spans.find((span) => span.text === 'where')?.keyword).toBe(true)
 })
 
@@ -80,14 +104,20 @@ it('links Julia variadic parameters without consuming their splat punctuation',
   const command = sym('LibTmux.capture_baseline', 'function')
   const server = sym('LibTmux.Server')
   const idx = new SymbolIndex([command, server], (s) => `/${s.id}/`, 'julia')
-  const signature = { raw: 'capture_baseline(server::LibTmux.Server, args...; kwargs...)',
-    params: [{ name: 'server', type: 'LibTmux.Server' }, { name: 'args', variadic: 'positional' },
-      { name: 'kwargs', variadic: 'keyword', keywordOnly: true }] } satisfies Signature
+  const signature = {
+    raw: 'capture_baseline(server::LibTmux.Server, args...; kwargs...)',
+    params: [
+      { name: 'server', type: 'LibTmux.Server' },
+      { name: 'args', variadic: 'positional' },
+      { name: 'kwargs', variadic: 'keyword', keywordOnly: true },
+    ],
+  } satisfies Signature
   const spans = idx.linkType(signature.raw, command, signature)
   expect(spans.map((span) => span.text).join('')).toBe(signature.raw)
   for (const name of ['server', 'args', 'kwargs']) {
-    expect(spans.find((span) => span.text === name)?.link?.href)
-      .toBe(`/LibTmux.capture_baseline/#LibTmux.capture_baseline.parameter.${name}`)
+    expect(spans.find((span) => span.text === name)?.link?.href).toBe(
+      `/LibTmux.capture_baseline/#LibTmux.capture_baseline.parameter.${name}`,
+    )
   }
   expect(spans.find((span) => span.text === 'LibTmux.Server')?.link?.href).toBe('/LibTmux.Server/')
   expect(spans.filter((span) => span.text.includes('...')).every((span) => !span.link)).toBe(true)
@@ -96,8 +126,12 @@ it('links Julia variadic parameters without consuming their splat punctuation',
 it('links Julia subtype bounds while leaving Symbol literals alone', () => {
   const field = sym('LibTmux.FormatField')
   const idx = new SymbolIndex([field, sym('LibTmux.session', 'function')], (s) => `/${s.id}/`, 'julia')
-  for (const annotation of ['AbstractVector{<:LibTmux.FormatField}', 'T<:LibTmux.FormatField',
-    'T>:LibTmux.FormatField', 'Tuple{:session, <:LibTmux.FormatField}']) {
+  for (const annotation of [
+    'AbstractVector{<:LibTmux.FormatField}',
+    'T<:LibTmux.FormatField',
+    'T>:LibTmux.FormatField',
+    'Tuple{:session, <:LibTmux.FormatField}',
+  ]) {
     const spans = idx.linkType(annotation)
     expect(spans.map((span) => span.text).join('')).toBe(annotation)
     expect(spans.filter((span) => span.link).map((span) => span.link?.href)).toEqual(['/LibTmux.FormatField/'])
@@ -152,9 +186,7 @@ describe('a bare name with more than one candidate', () => {
       'java',
     )
     const from = sym('io.github.libtmux.SplitSpec.SplitSpec.Builder.percent', 'method')
-    expect(linkFor(java, 'Builder', 'Builder', from)?.href).toBe(
-      '/io.github.libtmux.SplitSpec.SplitSpec.Builder/',
-    )
+    expect(linkFor(java, 'Builder', 'Builder', from)?.href).toBe('/io.github.libtmux.SplitSpec.SplitSpec.Builder/')
   })
 
   it('stays plain when two candidates are equally near', () => {
@@ -168,7 +200,9 @@ it('resolves C++ core and workspace types through their enclosing namespaces', (
   const symbols = ['libtmux::Pane', 'libtmux::workspace::Pane'].map(cpp)
   const idx = new SymbolIndex(symbols, (symbol) => `/${symbol.id}/`, 'cxx')
   expect(linkFor(idx, 'Pane', 'Pane', cpp('libtmux::Window::split'))?.href).toBe('/libtmux::Pane/')
-  expect(linkFor(idx, 'Pane', 'Pane', cpp('libtmux::workspace::Window::panes'))?.href).toBe('/libtmux::workspace::Pane/')
+  expect(linkFor(idx, 'Pane', 'Pane', cpp('libtmux::workspace::Window::panes'))?.href).toBe(
+    '/libtmux::workspace::Pane/',
+  )
   expect(linkFor(idx, 'Pane', 'Pane', cpp('other::Window::split'))).toBeUndefined()
 })
 
diff --git a/packages/api-model/test/powershell.test.ts b/packages/api-model/test/powershell.test.ts
index 1e5a93d19..cc01f7cd4 100644
--- a/packages/api-model/test/powershell.test.ts
+++ b/packages/api-model/test/powershell.test.ts
@@ -10,7 +10,8 @@ describe('PowerShell native command adapter', () => {
   it('preserves both module inventories without publishing implementation classes', () => {
     expect(model.symbols.filter((symbol) => symbol.kind === 'function')).toHaveLength(6)
     expect(model.sources?.map((source) => [source.package, source.product])).toEqual([
-      ['LibTmux', 'core'], ['LibTmux.Workspace', 'workspace'],
+      ['LibTmux', 'core'],
+      ['LibTmux.Workspace', 'workspace'],
     ])
     expect(model.symbols.every((symbol) => !symbol.id.includes('PowerShell.Commands'))).toBe(true)
     expect(command('Get-TmuxWorkspace')).toMatchObject({ package: 'LibTmux.Workspace', product: 'workspace' })
@@ -21,7 +22,11 @@ describe('PowerShell native command adapter', () => {
     expect(pane.signatures.map((signature) => signature.label)).toEqual(['Server', 'Session', 'Window'])
     for (const signature of pane.signatures) {
       const owner = signature.params.find((param) => param.name === signature.label)!
-      expect(owner.binding).toMatchObject({ mandatory: true, position: 0, pipeline: { byValue: true, byPropertyName: false } })
+      expect(owner.binding).toMatchObject({
+        mandatory: true,
+        position: 0,
+        pipeline: { byValue: true, byPropertyName: false },
+      })
       expect(signature.raw).toContain(`[<CommonParameters>]`)
       expect(signature.returns).toBe('LibTmux.Pane')
     }
@@ -31,12 +36,21 @@ describe('PowerShell native command adapter', () => {
     const control = command('Connect-TmuxControl')
     expect(control.command).toMatchObject({ kind: 'cmdlet', supportsShouldProcess: true })
     expect(control.signatures[0]!.params.map((parameter) => parameter.name)).toContain('WhatIf')
-    expect(control.signatures[0]!.params.find((parameter) => parameter.name === 'ErrorAction')?.binding?.common).toBe(true)
-    const timeout = command('Invoke-TmuxPaneCommand').signatures[0]!.params.find((parameter) => parameter.name === 'Timeout')!
+    expect(control.signatures[0]!.params.find((parameter) => parameter.name === 'ErrorAction')?.binding?.common).toBe(
+      true,
+    )
+    const timeout = command('Invoke-TmuxPaneCommand').signatures[0]!.params.find(
+      (parameter) => parameter.name === 'Timeout',
+    )!
     expect(timeout.default).toBe('30')
     const id = command('Get-TmuxPane').signatures[0]!.params.find((parameter) => parameter.name === 'Id')!
-    expect(id.binding?.attributes.some((attribute) => attribute.type.endsWith('ValidateNotNullOrEmptyAttribute'))).toBe(true)
-    expect(command('New-TmuxServer').signatures[0]!.params.find((parameter) => parameter.name === 'TmuxBinaryPath')?.binding?.declaration?.initializer).toBe('"tmux"')
+    expect(id.binding?.attributes.some((attribute) => attribute.type.endsWith('ValidateNotNullOrEmptyAttribute'))).toBe(
+      true,
+    )
+    expect(
+      command('New-TmuxServer').signatures[0]!.params.find((parameter) => parameter.name === 'TmuxBinaryPath')?.binding
+        ?.declaration?.initializer,
+    ).toBe('"tmux"')
   })
 
   it('describes engine-supplied common parameters without replacing authored help', () => {
@@ -50,11 +64,16 @@ describe('PowerShell native command adapter', () => {
     const parameters = authored.commands[0].parameterSets[0].parameters
     parameters.find((param: { name: string }) => param.name === 'Verbose').description = 'Authored verbose behavior.'
     const normalized = extractPowerShell(authored).symbols.find((symbol) => symbol.id === authored.commands[0].id)!
-    expect(normalized.signatures[0]!.params.find((param) => param.name === 'Verbose')?.doc).toBe('Authored verbose behavior.')
+    expect(normalized.signatures[0]!.params.find((param) => param.name === 'Verbose')?.doc).toBe(
+      'Authored verbose behavior.',
+    )
     parameters.find((param: { name: string }) => param.name === 'Verbose').description = ''
     parameters.find((param: { name: string }) => param.name === 'Verbose').common = false
-    expect(extractPowerShell(authored).symbols.find((symbol) => symbol.id === authored.commands[0].id)!
-      .signatures[0]!.params.find((param) => param.name === 'Verbose')?.doc).toBeUndefined()
+    expect(
+      extractPowerShell(authored)
+        .symbols.find((symbol) => symbol.id === authored.commands[0].id)!
+        .signatures[0]!.params.find((param) => param.name === 'Verbose')?.doc,
+    ).toBeUndefined()
   })
 
   it('keeps executable example code, following prose, errors and source provenance', () => {
@@ -68,8 +87,11 @@ describe('PowerShell native command adapter', () => {
   })
 
   it('renders nested reflected generic and array types without assembly metadata', () => {
-    expect(powerShellType('System.Collections.Generic.Dictionary`2[[System.String, System.Private.CoreLib, Version=8.0.0.0],[System.Collections.Generic.List`1[[LibTmux.Pane, LibTmux, Version=0.0.0.0]], System.Private.CoreLib]][]'))
-      .toBe('System.Collections.Generic.Dictionary[System.String, System.Collections.Generic.List[LibTmux.Pane]][]')
+    expect(
+      powerShellType(
+        'System.Collections.Generic.Dictionary`2[[System.String, System.Private.CoreLib, Version=8.0.0.0],[System.Collections.Generic.List`1[[LibTmux.Pane, LibTmux, Version=0.0.0.0]], System.Private.CoreLib]][]',
+      ),
+    ).toBe('System.Collections.Generic.Dictionary[System.String, System.Collections.Generic.List[LibTmux.Pane]][]')
     expect(powerShellType('System.String[]')).toBe('System.String[]')
   })
 
diff --git a/packages/api-model/test/product-exports.test.ts b/packages/api-model/test/product-exports.test.ts
index 09a7c793a..8369a6909 100644
--- a/packages/api-model/test/product-exports.test.ts
+++ b/packages/api-model/test/product-exports.test.ts
@@ -2,12 +2,22 @@ import { describe, expect, it } from 'vitest'
 import { scopeProductSymbols } from '../src/product-exports.ts'
 import type { ApiSymbol } from '../src/model.ts'
 
-const declaration = (name: string, file: string, kind: ApiSymbol['kind'] = 'interface'): ApiSymbol => ({ id: name, name, kind, source: { file }, modifiers: [], signatures: [] })
+const declaration = (name: string, file: string, kind: ApiSymbol['kind'] = 'interface'): ApiSymbol => ({
+  id: name,
+  name,
+  kind,
+  source: { file },
+  modifiers: [],
+  signatures: [],
+})
 
 describe('package export boundaries', () => {
   it('keeps an exported signature type without advertising an internal helper', () => {
     const symbols = [
-      { ...declaration('createServer', '/pkg/server.ts', 'function'), signatures: [{ params: [{ name: 'options', type: 'Startup' }] }] },
+      {
+        ...declaration('createServer', '/pkg/server.ts', 'function'),
+        signatures: [{ params: [{ name: 'options', type: 'Startup' }] }],
+      },
       declaration('Policy', '/pkg/policy.ts'),
       declaration('Startup', '/pkg/startup.ts'),
       declaration('ImplementationContext', '/pkg/startup.ts'),
@@ -22,7 +32,11 @@ describe('package export boundaries', () => {
   })
 
   it('distinguishes a Rust re-export from a private module and a doctest marker', () => {
-    const symbols = [declaration('Workspace', '/crate/config.rs'), declaration('Secret', '/crate/config.rs'), declaration('MacrosReadme', '/crate/lib.rs')]
+    const symbols = [
+      declaration('Workspace', '/crate/config.rs'),
+      declaration('Secret', '/crate/config.rs'),
+      declaration('MacrosReadme', '/crate/lib.rs'),
+    ]
     const files: Record<string, string> = {
       '/crate/lib.rs': 'mod config;\npub use config::{Workspace};\n#[cfg(doctest)]\npub struct MacrosReadme;',
       '/crate/config.rs': 'pub struct Workspace;\npub struct Secret;',
@@ -45,8 +59,10 @@ describe('package export boundaries', () => {
       declaration('libtmux::workspace::build', '/workspace.hpp', 'function'),
       declaration('libtmux::workspace::detail::build_windows', '/workspace.hpp', 'function'),
       declaration('libtmux::workspace::detail::State', '/workspace.hpp', 'struct'),
-      { ...declaration('libtmux::workspace::detail::State::value', '/workspace.hpp', 'attribute'),
-        parent: 'libtmux::workspace::detail::State' },
+      {
+        ...declaration('libtmux::workspace::detail::State::value', '/workspace.hpp', 'attribute'),
+        parent: 'libtmux::workspace::detail::State',
+      },
     ]
     scopeProductSymbols(symbols, { port: 'cxx', entries: [], readSource: () => '' })
     expect(symbols.map((symbol) => symbol.apiScope)).toEqual(['exported', 'internal', 'internal', 'internal'])
diff --git a/packages/api-model/test/products.test.ts b/packages/api-model/test/products.test.ts
index 37747fc58..7ad4edc50 100644
--- a/packages/api-model/test/products.test.ts
+++ b/packages/api-model/test/products.test.ts
@@ -4,23 +4,36 @@ import type { ApiModel, ApiSymbol } from '../src/model.ts'
 import { inheritProductFromOwners, sourceUrl, symbolsForProduct } from '../src/products.ts'
 
 const symbol: ApiSymbol = {
-  id: 'tmuxp.WorkspaceBuilder', name: 'WorkspaceBuilder', kind: 'class',
-  modifiers: [], signatures: [], product: 'workspace',
+  id: 'tmuxp.WorkspaceBuilder',
+  name: 'WorkspaceBuilder',
+  kind: 'class',
+  modifiers: [],
+  signatures: [],
+  product: 'workspace',
   source: { file: 'src/tmuxp/workspace/builder.py', line: 42, repo: 'tmux-python/tmuxp', revision: 'abc123' },
 }
-const model: ApiModel = { port: 'py', extractor: 'test', repo: 'tmux-python/libtmux', revision: 'def456', symbols: [symbol] }
+const model: ApiModel = {
+  port: 'py',
+  extractor: 'test',
+  repo: 'tmux-python/libtmux',
+  revision: 'def456',
+  symbols: [symbol],
+}
 
 describe('product reference provenance', () => {
   it('links generated sources within the selected documentation version', () => {
     const file = 'libtmux-scala/build/generated/GeneratedOperations.scala'
     const generated = { ...symbol, source: { file, line: 42 } }
     const sourceModel = { ...model, generatedSources: { [file]: 'extension (self: Pane)\ndef capture(): Unit' } }
-    expect(sourceUrl(sourceModel, generated, '/en/scala/v1.0.0/reference/'))
-      .toBe(`/en/scala/v1.0.0/reference/sources/${file}`)
+    expect(sourceUrl(sourceModel, generated, '/en/scala/v1.0.0/reference/')).toBe(
+      `/en/scala/v1.0.0/reference/sources/${file}`,
+    )
     expect(sourceUrl(sourceModel, generated)).toBeUndefined()
   })
   it('links a separate product repository and revision', () => {
-    expect(sourceUrl(model, symbol)).toBe('https://github.com/tmux-python/tmuxp/blob/abc123/src/tmuxp/workspace/builder.py#L42')
+    expect(sourceUrl(model, symbol)).toBe(
+      'https://github.com/tmux-python/tmuxp/blob/abc123/src/tmuxp/workspace/builder.py#L42',
+    )
   })
 
   it('keeps legacy core links and omits unknown line numbers', () => {
@@ -35,8 +48,20 @@ describe('product reference provenance', () => {
   })
 
   it('assigns members without files to their owning product independent of order', () => {
-    const nested: ApiSymbol = { ...symbol, id: 'Workspace.Nested.value', parent: 'Workspace.Nested', product: 'core', source: { file: '' } }
-    const container: ApiSymbol = { ...symbol, id: 'Workspace.Nested', parent: 'Workspace', product: 'core', source: { file: '' } }
+    const nested: ApiSymbol = {
+      ...symbol,
+      id: 'Workspace.Nested.value',
+      parent: 'Workspace.Nested',
+      product: 'core',
+      source: { file: '' },
+    }
+    const container: ApiSymbol = {
+      ...symbol,
+      id: 'Workspace.Nested',
+      parent: 'Workspace',
+      product: 'core',
+      source: { file: '' },
+    }
     const owner: ApiSymbol = { ...symbol, id: 'Workspace', product: 'workspace' }
     const ownSource: ApiSymbol = { ...symbol, id: 'Workspace.external', parent: 'Workspace', product: 'mcp' }
     const symbols = [nested, container, owner, ownSource]
@@ -49,13 +74,20 @@ describe('product reference provenance', () => {
 describe('generated product coverage', () => {
   for (const port of ['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']) {
     it(`${port} has source-proven workspace and MCP declarations`, () => {
-      const generated = JSON.parse(readFileSync(new URL(`../../../site/src/data/api/${port}.json`, import.meta.url), 'utf8')) as ApiModel
+      const generated = JSON.parse(
+        readFileSync(new URL(`../../../site/src/data/api/${port}.json`, import.meta.url), 'utf8'),
+      ) as ApiModel
       for (const product of ['workspace', 'mcp'] as const) {
         const symbols = symbolsForProduct(generated, product)
         expect(symbols.length).toBeGreaterThan(0)
         const sources = generated.sources?.filter((source) => source.product === product) ?? []
         for (const symbol of symbols) {
-          expect(sources.some((source) => source.repo === symbol.source.repo && source.extractedRevision === symbol.source.extractedRevision)).toBe(true)
+          expect(
+            sources.some(
+              (source) =>
+                source.repo === symbol.source.repo && source.extractedRevision === symbol.source.extractedRevision,
+            ),
+          ).toBe(true)
           expect(symbol.source.file).not.toMatch(/^(?:\/|\.\.)/)
         }
       }
@@ -63,7 +95,9 @@ describe('generated product coverage', () => {
   }
 
   it('keeps Lua MCP and workspace absent until those products are published', () => {
-    const generated = JSON.parse(readFileSync(new URL('../../../site/src/data/api/lua.json', import.meta.url), 'utf8')) as ApiModel
+    const generated = JSON.parse(
+      readFileSync(new URL('../../../site/src/data/api/lua.json', import.meta.url), 'utf8'),
+    ) as ApiModel
     expect(symbolsForProduct(generated, 'mcp')).toEqual([])
     expect(symbolsForProduct(generated, 'workspace')).toEqual([])
     expect(generated.sources?.map((source) => source.product)).toEqual(['core'])
diff --git a/packages/api-model/test/prose-audit.test.ts b/packages/api-model/test/prose-audit.test.ts
index d192b0ca1..ba1d5460d 100644
--- a/packages/api-model/test/prose-audit.test.ts
+++ b/packages/api-model/test/prose-audit.test.ts
@@ -11,19 +11,25 @@ import { extractWithSpec } from '../src/languages/spec.ts'
 import { GO } from '../src/languages/specs.ts'
 
 const root = fileURLToPath(new URL('../../../', import.meta.url))
-const audit = (...args: string[]) => spawnSync(process.execPath, ['scripts/check-api-links.mjs', ...args, '--json'], { cwd: root, encoding: 'utf8' })
+const audit = (...args: string[]) =>
+  spawnSync(process.execPath, ['scripts/check-api-links.mjs', ...args, '--json'], { cwd: root, encoding: 'utf8' })
 
 describe('product prose audit', () => {
   it('audits native commands and dependency types without accepting invented commands', () => {
     const scratch = mkdtempSync(join(tmpdir(), 'libtmux-powershell-audit-'))
     const file = join(scratch, 'topic.md')
     try {
-      writeFileSync(file, '---\ntitle: Snapshot\nport: powershell\n---\n\nUse `Get-TmuxSnapshot` with `LibTmux.Server`.\n')
+      writeFileSync(
+        file,
+        '---\ntitle: Snapshot\nport: powershell\n---\n\nUse `Get-TmuxSnapshot` with `LibTmux.Server`.\n',
+      )
       expect(audit(file).status).toBe(0)
       writeFileSync(file, '---\ntitle: Snapshot\nport: powershell\n---\n\nUse `Invent-TmuxSnapshot`.\n')
       const result = audit(file)
       expect(result.status).toBe(1)
-      expect(JSON.parse(result.stdout).unresolved.map((entry: { text: string }) => entry.text)).toEqual(['Invent-TmuxSnapshot'])
+      expect(JSON.parse(result.stdout).unresolved.map((entry: { text: string }) => entry.text)).toEqual([
+        'Invent-TmuxSnapshot',
+      ])
     } finally {
       rmSync(scratch, { recursive: true })
     }
@@ -41,7 +47,9 @@ describe('product prose audit', () => {
       writeFileSync(file, '---\ntitle: Capture\nport: ts\nproduct: mcp\n---\n\nUse `capture_pane()` for output.\n')
       const result = audit(file)
       expect(result.status).toBe(1)
-      expect(JSON.parse(result.stdout).unresolved.map((entry: { text: string }) => entry.text)).toEqual(['capture_pane()'])
+      expect(JSON.parse(result.stdout).unresolved.map((entry: { text: string }) => entry.text)).toEqual([
+        'capture_pane()',
+      ])
     } finally {
       rmSync(scratch, { recursive: true })
     }
@@ -82,23 +90,41 @@ describe('product context in prose', () => {
   })
 
   it('does not borrow another language when the page already names its port', () => {
-    const other = { port: 'py', version: '0', symbols: [{ id: 'Other', name: 'Other', kind: 'class', signatures: [] }] } as ApiModel
+    const other = {
+      port: 'py',
+      version: '0',
+      symbols: [{ id: 'Other', name: 'Other', kind: 'class', signatures: [] }],
+    } as ApiModel
     for (const product of [undefined, 'workspace'] as const) {
-      const result = decideMention('Other', { pagePort: 'go', product }, new Resolver([model, other]), { go: model, py: other })
+      const result = decideMention('Other', { pagePort: 'go', product }, new Resolver([model, other]), {
+        go: model,
+        py: other,
+      })
       expect(result.kind).toBe('unresolved')
     }
   })
 
   it('links standard-library types through the existing language catalog', () => {
     const rust = { port: 'rs', version: '0', symbols: [] } as unknown as ApiModel
-    expect(decideMention('BTreeMap', { pagePort: 'rs' }, new Resolver([rust]), { rs: rust }))
-      .toMatchObject({ kind: 'link', port: 'rs', href: 'https://doc.rust-lang.org/std/collections/struct.BTreeMap.html', external: true })
+    expect(decideMention('BTreeMap', { pagePort: 'rs' }, new Resolver([rust]), { rs: rust })).toMatchObject({
+      kind: 'link',
+      port: 'rs',
+      href: 'https://doc.rust-lang.org/std/collections/struct.BTreeMap.html',
+      external: true,
+    })
   })
 
   it('uses the enclosing type to distinguish nested builders', () => {
-    const java = { port: 'java', version: '0', symbols: ['SessionSpec', 'WindowSpec'].map((name) => ({
-      id: `io.example.${name}.${name}.Builder.environment`, name: 'environment', kind: 'method', signatures: [],
-    })) } as unknown as ApiModel
+    const java = {
+      port: 'java',
+      version: '0',
+      symbols: ['SessionSpec', 'WindowSpec'].map((name) => ({
+        id: `io.example.${name}.${name}.Builder.environment`,
+        name: 'environment',
+        kind: 'method',
+        signatures: [],
+      })),
+    } as unknown as ApiModel
     const r = new Resolver([java])
     const found = r.resolve('java', 'SessionSpec.Builder.environment(Map)')
     expect('symbol' in found && found.symbol.id).toBe('io.example.SessionSpec.SessionSpec.Builder.environment')
@@ -107,15 +133,20 @@ describe('product context in prose', () => {
 
   it('classifies MCP resource URIs and newly authored filenames explicitly', () => {
     expect(notASymbol('tmux://sessions/{session_id}')).toBe('a protocol URI')
-    expect(decideFilePath('dev.yaml', { before: 'Save this description as ' }, {})).toEqual({ kind: 'skip', why: 'file created by the example' })
+    expect(decideFilePath('dev.yaml', { before: 'Save this description as ' }, {})).toEqual({
+      kind: 'skip',
+      why: 'file created by the example',
+    })
     expect(decideFilePath('missing.yaml', { before: 'The implementation reads ' }, {}).kind).toBe('unresolved')
   })
 
   it('does not resolve a missing source path against another port', () => {
     const trees = { rs: new Set(['src/server.rs']), py: new Set(['src/libtmux/pane.py']) }
     expect(decideFilePath('src/libtmux/pane.py', { pagePort: 'rs' }, trees).kind).toBe('unresolved')
-    expect(decideFilePath('src/libtmux/pane.py', { pagePort: 'rs', before: 'Python uses ' }, trees))
-      .toMatchObject({ kind: 'link', port: 'py' })
+    expect(decideFilePath('src/libtmux/pane.py', { pagePort: 'rs', before: 'Python uses ' }, trees)).toMatchObject({
+      kind: 'link',
+      port: 'py',
+    })
     expect(decideFilePath('src/libtmux/pane.py', {}, trees)).toMatchObject({ kind: 'link', port: 'py' })
   })
 })
@@ -124,7 +155,10 @@ it('extracts exported Go error variables with their source documentation', async
   const scratch = mkdtempSync(join(tmpdir(), 'libtmux-go-api-'))
   const file = join(scratch, 'workspace.go')
   try {
-    writeFileSync(file, 'package workspace\n\n// ErrInvalidWorkspace matches parse and validation failures.\nvar ErrInvalidWorkspace = errors.New("workspace: invalid workspace")\nvar privateError = errors.New("private")\n')
+    writeFileSync(
+      file,
+      'package workspace\n\n// ErrInvalidWorkspace matches parse and validation failures.\nvar ErrInvalidWorkspace = errors.New("workspace: invalid workspace")\nvar privateError = errors.New("private")\n',
+    )
     const symbols = await extractWithSpec(GO, file, 'workspace')
     expect(symbols.map((symbol) => symbol.id)).toEqual(['workspace.ErrInvalidWorkspace'])
     expect(symbols[0].doc?.summary).toContain('parse and validation failures')
diff --git a/packages/api-model/test/python-docs.test.ts b/packages/api-model/test/python-docs.test.ts
index 50b2730e3..1704bb355 100644
--- a/packages/api-model/test/python-docs.test.ts
+++ b/packages/api-model/test/python-docs.test.ts
@@ -14,7 +14,9 @@ const sessions = [...queryList.matchAll(/^>>>[^\n]*(?:\n[^\n]+)*/gm)].map((match
 
 describe('Python docstring structure', () => {
   it('keeps every source doctest and its output in place without an Examples heading', () => {
-    expect(createHash('sha256').update(queryList).digest('hex')).toBe('245583d7072b64ceb8b722252375b3ba3537e06070e8fabbe1425059f4393cf1')
+    expect(createHash('sha256').update(queryList).digest('hex')).toBe(
+      '245583d7072b64ceb8b722252375b3ba3537e06070e8fabbe1425059f4393cf1',
+    )
     expect(sessions).toHaveLength(22)
     const doc = parsePythonDoc(queryList).doc
     const blocks = [...doc.body!.matchAll(/```python\n([\s\S]*?)\n```/g)].map((match) => match[1])
@@ -27,7 +29,9 @@ describe('Python docstring structure', () => {
   })
 
   it('preserves nested lists, references, notes and literal indentation', () => {
-    const doc = parsePythonDoc('Summary.\n\n- :class:`Server`\n\n  - :attr:`Server.sessions`\n\nA literal::\n\n    first\n      second\n\nAfter.\n\nNotes\n-----\n*Still experimental*.\n\n>>> 2 + 2\n4').doc
+    const doc = parsePythonDoc(
+      'Summary.\n\n- :class:`Server`\n\n  - :attr:`Server.sessions`\n\nA literal::\n\n    first\n      second\n\nAfter.\n\nNotes\n-----\n*Still experimental*.\n\n>>> 2 + 2\n4',
+    ).doc
     expect(doc.body).toContain('- :class:`Server`\n\n  - :attr:`Server.sessions`')
     expect(doc.body).toContain('A literal:\n\n```text\nfirst\n  second\n```')
     expect(doc.body).toContain('### Notes\n\n*Still experimental*.\n\n```python\n>>> 2 + 2\n4\n```')
@@ -36,25 +40,38 @@ describe('Python docstring structure', () => {
   it('keeps code directives and longer fences literal, including directive-looking source', () => {
     const body = pythonDocBody('.. code-block:: python\n   :linenos:\n\n   # comment\n   print("hi")\n\nEnd.')
     expect(body).toBe('```python\n# comment\nprint("hi")\n```\n\nEnd.')
-    const doc = parsePythonDoc('Summary.\n\n.. code-block:: text\n\n   .. note:: literal\n   ```\n\n.. warning:: A real warning.').doc
+    const doc = parsePythonDoc(
+      'Summary.\n\n.. code-block:: text\n\n   .. note:: literal\n   ```\n\n.. warning:: A real warning.',
+    ).doc
     expect(doc.body).toContain('````text\n.. note:: literal\n```\n````')
     expect(doc.admonitions).toEqual([{ kind: 'warning', text: 'A real warning.' }])
   })
 
   it('keeps paragraphs and literal sessions inside their admonition', () => {
-    const doc = parsePythonDoc('Summary.\n\n.. note:: First paragraph.\n\n    Second paragraph with :class:`Server`.\n\n    >>> value = [\n    ...     1,\n    ... ]\n    [1]\n\nAfter.').doc
-    expect(doc.admonitions).toEqual([{ kind: 'note', text: 'First paragraph.\n\nSecond paragraph with :class:`Server`.\n\n```python\n>>> value = [\n...     1,\n... ]\n[1]\n```' }])
+    const doc = parsePythonDoc(
+      'Summary.\n\n.. note:: First paragraph.\n\n    Second paragraph with :class:`Server`.\n\n    >>> value = [\n    ...     1,\n    ... ]\n    [1]\n\nAfter.',
+    ).doc
+    expect(doc.admonitions).toEqual([
+      {
+        kind: 'note',
+        text: 'First paragraph.\n\nSecond paragraph with :class:`Server`.\n\n```python\n>>> value = [\n...     1,\n... ]\n[1]\n```',
+      },
+    ])
     expect(doc.body).toBe('After.')
   })
 
   it('does not mistake an argumentless admonition for a literal introducer', () => {
-    const doc = parsePythonDoc('Summary.\n\n.. warning::\n\n    Use :class:`Server`.\n\n    It owns the connection.').doc
+    const doc = parsePythonDoc(
+      'Summary.\n\n.. warning::\n\n    Use :class:`Server`.\n\n    It owns the connection.',
+    ).doc
     expect(doc.body).toBeUndefined()
     expect(doc.admonitions).toEqual([{ kind: 'warning', text: 'Use :class:`Server`.\n\nIt owns the connection.' }])
   })
 
   it('retains every directive in Notes without leaking reST markers or an empty heading', () => {
-    const doc = parsePythonDoc('Summary.\n\nNotes\n-----\n.. versionchanged:: 2.0\n    New behavior.\n\n.. versionchanged:: 1.0\n    Earlier behavior.\n\n.. warning::\n    Check :class:`Server`.').doc
+    const doc = parsePythonDoc(
+      'Summary.\n\nNotes\n-----\n.. versionchanged:: 2.0\n    New behavior.\n\n.. versionchanged:: 1.0\n    Earlier behavior.\n\n.. warning::\n    Check :class:`Server`.',
+    ).doc
     expect(doc.changed).toBe('2.0 — New behavior.\n\n1.0 — Earlier behavior.')
     expect(doc.admonitions).toEqual([{ kind: 'warning', text: 'Check :class:`Server`.' }])
     expect(doc.body).toBeUndefined()
@@ -62,16 +79,28 @@ describe('Python docstring structure', () => {
 
   it('indexes real prose references without indexing literal roles or fence delimiters', () => {
     expect(referencesIn(':class:`Server`\n\n````text\n:class:`Imaginary`\n```\n````\n\n:class:`Window`')).toEqual([
-      { role: 'class', target: 'Server' }, { role: 'class', target: 'Window' },
+      { role: 'class', target: 'Server' },
+      { role: 'class', target: 'Window' },
     ])
   })
 
   it('renders single emphasis without claiming globs, arithmetic or code', () => {
     expect(tokenizeDoc('*Experimental, unstable*.')).toEqual([
-      { kind: 'emphasis', text: 'Experimental, unstable' }, { kind: 'text', text: '.' },
+      { kind: 'emphasis', text: 'Experimental, unstable' },
+      { kind: 'text', text: '.' },
     ])
-    for (const text of ['a * b and 2 * 3', 'glob *.py here', String.raw`\*literal\*`, '`*literal*`', '``*literal*``', '**Strong**']) {
-      expect(tokenizeDoc(text).filter((span) => span.kind === 'emphasis'), text).toEqual([])
+    for (const text of [
+      'a * b and 2 * 3',
+      'glob *.py here',
+      String.raw`\*literal\*`,
+      '`*literal*`',
+      '``*literal*``',
+      '**Strong**',
+    ]) {
+      expect(
+        tokenizeDoc(text).filter((span) => span.kind === 'emphasis'),
+        text,
+      ).toEqual([])
     }
     expect(docSummaryText('A *small* **local** `list`.', 'py')).toBe('A small local list.')
   })
@@ -95,12 +124,19 @@ describe('source-scoped Python typing bindings', () => {
     const index = new SymbolIndex([symbol], (entry) => `#${entry.id}`, 'py')
     const spans = index.linkType('t.Generic[T]', symbol)
     expect(spans.map((span) => span.text).join('')).toBe('t.Generic[T]')
-    expect(spans.find((span) => span.text === 't.Generic')?.link?.href).toBe('https://docs.python.org/3/library/typing.html#typing.Generic')
+    expect(spans.find((span) => span.text === 't.Generic')?.link?.href).toBe(
+      'https://docs.python.org/3/library/typing.html#typing.Generic',
+    )
     expect(spans.find((span) => span.text === 'T')?.link).toBeUndefined()
   })
 
   it('keeps aliases scoped to imports and invalidates rebound names', async () => {
-    for (const prefix of ['', 'import other as t\n', 'import typing as t\nt = other\n', 'import typing as t\nimport other as t\n']) {
+    for (const prefix of [
+      '',
+      'import other as t\n',
+      'import typing as t\nt = other\n',
+      'import typing as t\nimport other as t\n',
+    ]) {
       const symbols = await extract(`${prefix}class QueryList(t.Generic[T]):\n    pass\n`)
       const symbol = symbols.at(-1)!
       const index = new SymbolIndex(symbols, (entry) => `#${entry.id}`, 'py')
diff --git a/packages/api-model/test/raises.test.ts b/packages/api-model/test/raises.test.ts
index 25149ded3..f02c66789 100644
--- a/packages/api-model/test/raises.test.ts
+++ b/packages/api-model/test/raises.test.ts
@@ -20,9 +20,7 @@ Raises
 :exc:\`libtmux.exc.BadSessionName\`
     When the name is invalid.
 `)
-    expect(parsed.raises).toEqual([
-      { type: 'libtmux.exc.BadSessionName', doc: 'When the name is invalid.' },
-    ])
+    expect(parsed.raises).toEqual([{ type: 'libtmux.exc.BadSessionName', doc: 'When the name is invalid.' }])
   })
 
   it('shortens a target Sphinx would shorten', () => {
diff --git a/packages/api-model/test/resolver.test.ts b/packages/api-model/test/resolver.test.ts
index ea3937842..4322cdba1 100644
--- a/packages/api-model/test/resolver.test.ts
+++ b/packages/api-model/test/resolver.test.ts
@@ -133,13 +133,22 @@ d('resolver', () => {
 
   it('resolves most unlinked references in the real corpus', () => {
     const LABEL: Record<string, string> = {
-      Python: 'py', Ruby: 'ruby', Lua: 'lua', TypeScript: 'ts', Rust: 'rs', Go: 'go',
-      Java: 'java', '.NET': 'csharp', 'C++': 'cxx', Swift: 'swift',
+      Python: 'py',
+      Ruby: 'ruby',
+      Lua: 'lua',
+      TypeScript: 'ts',
+      Rust: 'rs',
+      Go: 'go',
+      Java: 'java',
+      '.NET': 'csharp',
+      'C++': 'cxx',
+      Swift: 'swift',
     }
     const docs = join(here, '../../../site/src/content/docs')
     const walk = (dir: string): string[] =>
       readdirSync(dir, { withFileTypes: true }).flatMap((e) =>
-        e.isDirectory() ? walk(join(dir, e.name)) : e.name.endsWith('.md') ? [join(dir, e.name)] : [])
+        e.isDirectory() ? walk(join(dir, e.name)) : e.name.endsWith('.md') ? [join(dir, e.name)] : [],
+      )
     let linkable = 0
     let resolved = 0
     for (const f of walk(docs)) {
diff --git a/packages/api-model/test/ruby-examples.test.ts b/packages/api-model/test/ruby-examples.test.ts
index 94d911042..a02da99ae 100644
--- a/packages/api-model/test/ruby-examples.test.ts
+++ b/packages/api-model/test/ruby-examples.test.ts
@@ -6,13 +6,20 @@ const source = { repository: 'libtmux/libtmux-ruby', revision: 'a'.repeat(40) }
 const file = 'examples/api/server.rb'
 const code = '# frozen_string_literal: true\n\nrequire "libtmux"\n\nputs "ready"\n'
 const program = () => ({
-  path: file, gem: 'libtmux',
+  path: file,
+  gem: 'libtmux',
   api: { symbols: ['LibTmux::Server.new'], description: 'Connect to a server.', output: 'ready\n' },
 })
 const bundle = () => ({ manifest: { programs: [program()] }, files: [{ path: file, content: code }] })
 const symbol = (): ApiSymbol => ({
-  id: 'LibTmux::Server.new', publicId: 'LibTmux::Server.new', name: 'new', kind: 'method',
-  modifiers: ['static'], parent: 'LibTmux::Server', package: 'libtmux', signatures: [],
+  id: 'LibTmux::Server.new',
+  publicId: 'LibTmux::Server.new',
+  name: 'new',
+  kind: 'method',
+  modifiers: ['static'],
+  parent: 'LibTmux::Server',
+  package: 'libtmux',
+  signatures: [],
   source: { file: 'gems/libtmux/lib/libtmux/server.rb', line: 45 },
   doc: { summary: 'Connect to an endpoint.', examples: [{ lang: 'ruby', code: 'existing' }] },
 })
@@ -26,12 +33,16 @@ describe('complete native Ruby examples', () => {
     const blocks = target.doc!.examples!
     expect(blocks.map((block) => block.lang)).toEqual(['ruby', 'console', 'ruby', 'ruby', 'console', 'text'])
     expect(blocks[0].code).toBe('existing')
-    expect(blocks[1].code).toBe(`$ git clone https://github.com/libtmux/libtmux-ruby.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`)
+    expect(blocks[1].code).toBe(
+      `$ git clone https://github.com/libtmux/libtmux-ruby.git libtmux-source && \\\n  git -C libtmux-source checkout ${source.revision}\n`,
+    )
     expect(blocks[2].code).toBe('source "https://rubygems.org"\n\ngem "libtmux", path: "libtmux-source/gems/libtmux"\n')
     expect(blocks[3].code).toBe(code)
     expect(blocks[3].sourceUrl).toBe(`https://github.com/${source.repository}/blob/${source.revision}/${file}`)
     expect(blocks[3].intro).toContain('server.rb')
-    expect(blocks[4].code).toBe('$ bundle config set --local path vendor/bundle && \\\n  bundle install --jobs 2 && \\\n  bundle exec ruby server.rb\n')
+    expect(blocks[4].code).toBe(
+      '$ bundle config set --local path vendor/bundle && \\\n  bundle install --jobs 2 && \\\n  bundle exec ruby server.rb\n',
+    )
     expect(blocks[5].code).toBe('ready\n')
   })
 
@@ -45,13 +56,39 @@ describe('complete native Ruby examples', () => {
 
   it.each([
     ['missing file', { manifest: { programs: [program()] }, files: [] }, /Missing complete/],
-    ['duplicate file', { ...bundle(), files: [{ path: file, content: code }, { path: file, content: code }] }, /Duplicate.*file/],
+    [
+      'duplicate file',
+      {
+        ...bundle(),
+        files: [
+          { path: file, content: code },
+          { path: file, content: code },
+        ],
+      },
+      /Duplicate.*file/,
+    ],
     ['empty file', { ...bundle(), files: [{ path: file, content: ' ' }] }, /Missing complete/],
     ['missing API metadata', { ...bundle(), manifest: { programs: [{ ...program(), api: null }] } }, /metadata/],
-    ['empty targets', { ...bundle(), manifest: { programs: [{ ...program(), api: { ...program().api, symbols: [] } }] } }, /metadata/],
-    ['missing output newline', { ...bundle(), manifest: { programs: [{ ...program(), api: { ...program().api, output: 'ready' } }] } }, /metadata/],
-    ['empty description', { ...bundle(), manifest: { programs: [{ ...program(), api: { ...program().api, description: ' ' } }] } }, /metadata/],
-    ['escaping path', { ...bundle(), manifest: { programs: [{ ...program(), path: 'examples/../server.rb' }] } }, /metadata/],
+    [
+      'empty targets',
+      { ...bundle(), manifest: { programs: [{ ...program(), api: { ...program().api, symbols: [] } }] } },
+      /metadata/,
+    ],
+    [
+      'missing output newline',
+      { ...bundle(), manifest: { programs: [{ ...program(), api: { ...program().api, output: 'ready' } }] } },
+      /metadata/,
+    ],
+    [
+      'empty description',
+      { ...bundle(), manifest: { programs: [{ ...program(), api: { ...program().api, description: ' ' } }] } },
+      /metadata/,
+    ],
+    [
+      'escaping path',
+      { ...bundle(), manifest: { programs: [{ ...program(), path: 'examples/../server.rb' }] } },
+      /metadata/,
+    ],
   ])('rejects %s', (_name, input, message) => {
     expect(() => attachCompleteRubyExamples([symbol()], input, source)).toThrow(message)
   })
@@ -59,17 +96,20 @@ describe('complete native Ruby examples', () => {
   it('rejects unknown, duplicate, and wrong-package declaration targets', () => {
     expect(() => attachCompleteRubyExamples([], bundle(), source)).toThrow(/resolve once/)
     expect(() => attachCompleteRubyExamples([symbol(), symbol()], bundle(), source)).toThrow(/resolve once/)
-    expect(() => attachCompleteRubyExamples([{ ...symbol(), package: 'libtmux-async' }], bundle(), source))
-      .toThrow(/package differs/)
+    expect(() => attachCompleteRubyExamples([{ ...symbol(), package: 'libtmux-async' }], bundle(), source)).toThrow(
+      /package differs/,
+    )
     const duplicate = bundle()
     duplicate.manifest.programs.push(program())
     expect(() => attachCompleteRubyExamples([symbol()], duplicate, source)).toThrow(/Duplicate.*target/)
   })
 
   it('rejects mutable revisions and invalid repository citations', () => {
-    expect(() => attachCompleteRubyExamples([symbol()], bundle(), { ...source, revision: 'master' }))
-      .toThrow(/full source revision/)
-    expect(() => attachCompleteRubyExamples([symbol()], bundle(), { ...source, repository: '../libtmux-ruby' }))
-      .toThrow(/repository/)
+    expect(() => attachCompleteRubyExamples([symbol()], bundle(), { ...source, revision: 'master' })).toThrow(
+      /full source revision/,
+    )
+    expect(() =>
+      attachCompleteRubyExamples([symbol()], bundle(), { ...source, repository: '../libtmux-ruby' }),
+    ).toThrow(/repository/)
   })
 })
diff --git a/packages/api-model/test/rust-examples.test.ts b/packages/api-model/test/rust-examples.test.ts
index 1fb287003..a23de69d7 100644
--- a/packages/api-model/test/rust-examples.test.ts
+++ b/packages/api-model/test/rust-examples.test.ts
@@ -4,42 +4,63 @@ import { attachCompleteRustExamples } from '../src/languages/rust-examples.ts'
 
 const source = { repo: 'libtmux/libtmux-rs', revision: 'a'.repeat(40) }
 const symbol = (id: string, kind: ApiSymbol['kind'], parent?: string): ApiSymbol => ({
-  id, name: id.split('.').at(-1)!, slug: id.toLowerCase().replaceAll('.', '-'), kind,
-  signatures: [], modifiers: [], ...(parent ? { parent } : {}),
+  id,
+  name: id.split('.').at(-1)!,
+  slug: id.toLowerCase().replaceAll('.', '-'),
+  kind,
+  signatures: [],
+  modifiers: [],
+  ...(parent ? { parent } : {}),
   source: { file: 'crates/libtmux/src/server.rs' },
   doc: { summary: 'Existing prose.', examples: [{ lang: 'rust', code: 'old();\n' }] },
 })
 function fixture() {
-  const symbols = [symbol('server.Server', 'struct'),
+  const symbols = [
+    symbol('server.Server', 'struct'),
     symbol('server.Server.builder', 'method', 'server.Server'),
     symbol('options.OptionScope.Server', 'constant', 'options.OptionScope'),
     symbol('query.QueryIteratorExt', 'trait'),
-    symbol('query.QueryIteratorExt.exactly_one', 'method', 'query.QueryIteratorExt')]
+    symbol('query.QueryIteratorExt.exactly_one', 'method', 'query.QueryIteratorExt'),
+  ]
   const manifest = {
-    schemaVersion: 1, language: 'rust', nativeInventory: 'crates/libtmux/docs/public-api.txt',
+    schemaVersion: 1,
+    language: 'rust',
+    nativeInventory: 'crates/libtmux/docs/public-api.txt',
     setupFiles: [
       { sourceFile: 'crates/libtmux/examples/api/consumer.toml', name: 'Cargo.toml' },
       { sourceFile: 'rust-toolchain.toml', name: 'rust-toolchain.toml' },
-    ], programFileName: 'src/main.rs', runCommand: 'cargo run --quiet',
-    examples: [{ id: 'rust-construction', title: 'Construct a server', description: 'Use a private socket.',
-      sourceFile: 'crates/libtmux/examples/api_construction.rs', cargoExample: 'api_construction',
-      targets: ['libtmux::Server', 'libtmux::Server::builder', 'libtmux::query::QueryIteratorExt::exactly_one'],
-      expectedOutput: 'done' }],
+    ],
+    programFileName: 'src/main.rs',
+    runCommand: 'cargo run --quiet',
+    examples: [
+      {
+        id: 'rust-construction',
+        title: 'Construct a server',
+        description: 'Use a private socket.',
+        sourceFile: 'crates/libtmux/examples/api_construction.rs',
+        cargoExample: 'api_construction',
+        targets: ['libtmux::Server', 'libtmux::Server::builder', 'libtmux::query::QueryIteratorExt::exactly_one'],
+        expectedOutput: 'done',
+      },
+    ],
   }
   const files: Record<string, string> = {
-    'crates/libtmux/docs/public-api.txt': 'struct libtmux::Server\n' +
+    'crates/libtmux/docs/public-api.txt':
+      'struct libtmux::Server\n' +
       'function libtmux::Server::builder: fn() -> libtmux::ServerBuilder\n' +
       'trait libtmux::query::QueryIteratorExt\n' +
       'function libtmux::query::QueryIteratorExt::exactly_one: fn(mut self) -> Result<Self::Item, ExactlyOneError>\n',
-    'crates/libtmux/examples/api/consumer.toml': '[package]\nname = "libtmux-api-example"\n' +
+    'crates/libtmux/examples/api/consumer.toml':
+      '[package]\nname = "libtmux-api-example"\n' +
       'edition = "2024"\npublish = false\n[workspace]\nexclude = ["libtmux-source"]\n' +
       '[dependencies]\nlibtmux = { path = "libtmux-source/crates/libtmux" }\n' +
       'tempfile = "3.20"\ntokio = { version = "1.40", features = ["macros", "rt", "time"] }\n',
     'rust-toolchain.toml': '[toolchain]\nchannel = "1.97.1"\n',
-    'crates/libtmux/examples/api_construction.rs': 'use libtmux::Server;\n#[tokio::main(flavor = "current_thread")]\nasync fn main() {}\n',
+    'crates/libtmux/examples/api_construction.rs':
+      'use libtmux::Server;\n#[tokio::main(flavor = "current_thread")]\nasync fn main() {}\n',
   }
-  const read = (file: string) => file === 'crates/libtmux/examples/api/manifest.json'
-    ? JSON.stringify(manifest) : files[file]
+  const read = (file: string) =>
+    file === 'crates/libtmux/examples/api/manifest.json' ? JSON.stringify(manifest) : files[file]
   return { symbols, manifest, files, read }
 }
 
@@ -55,7 +76,9 @@ describe('complete Rust API programs', () => {
       expect(blocks[2].code).toBe(f.files['crates/libtmux/examples/api/consumer.toml'])
       expect(blocks[3].code).toBe(f.files['rust-toolchain.toml'])
       expect(blocks[4].code).toBe(f.files[f.manifest.examples[0].sourceFile])
-      expect(blocks[4].sourceUrl).toBe(`https://github.com/${source.repo}/blob/${source.revision}/${f.manifest.examples[0].sourceFile}`)
+      expect(blocks[4].sourceUrl).toBe(
+        `https://github.com/${source.repo}/blob/${source.revision}/${f.manifest.examples[0].sourceFile}`,
+      )
       expect(blocks[1].code).toContain(`checkout --detach ${source.revision}`)
       expect(blocks[5].code).toContain('mkdir -p src &&\n')
       expect(blocks[5].code).toContain('cargo run --quiet\n')
@@ -73,30 +96,153 @@ describe('complete Rust API programs', () => {
   })
 
   it.each([
-    ['missing native target', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].targets.push('libtmux::Unknown') }],
-    ['duplicate native target', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].targets.push('libtmux::Server') }],
-    ['ambiguous inventory', (f: ReturnType<typeof fixture>) => { f.files[f.manifest.nativeInventory] += 'enum libtmux::Server\n' }],
-    ['missing model target', (f: ReturnType<typeof fixture>) => { f.symbols.splice(1, 1) }],
-    ['ambiguous model target', (f: ReturnType<typeof fixture>) => { f.symbols.push(symbol('other.Server', 'struct')) }],
-    ['wrong kind', (f: ReturnType<typeof fixture>) => { f.symbols[0].kind = 'enum' }],
-    ['wrong method owner', (f: ReturnType<typeof fixture>) => { f.symbols[4].parent = 'query.Other' }],
-    ['wrong source crate', (f: ReturnType<typeof fixture>) => { f.symbols[0].source.file = 'crates/tmux-workspace/src/server.rs' }],
-    ['wrong product', (f: ReturnType<typeof fixture>) => { f.symbols[0].product = 'workspace' }],
-    ['duplicate program', (f: ReturnType<typeof fixture>) => { f.manifest.examples.push(f.manifest.examples[0]) }],
-    ['missing Cargo setup', (f: ReturnType<typeof fixture>) => { delete f.files[f.manifest.setupFiles[0].sourceFile] }],
-    ['missing toolchain', (f: ReturnType<typeof fixture>) => { delete f.files['rust-toolchain.toml'] }],
-    ['malformed TOML', (f: ReturnType<typeof fixture>) => { f.files['rust-toolchain.toml'] += '[broken\n' }],
-    ['unpinned toolchain', (f: ReturnType<typeof fixture>) => { f.files['rust-toolchain.toml'] = '[toolchain]\nchannel = "stable"\n' }],
-    ['wrong dependency path', (f: ReturnType<typeof fixture>) => { const file = f.manifest.setupFiles[0].sourceFile; f.files[file] = f.files[file].replace('libtmux-source/crates/libtmux', '../hidden') }],
-    ['missing runtime dependency', (f: ReturnType<typeof fixture>) => { const file = f.manifest.setupFiles[0].sourceFile; f.files[file] = f.files[file].replace('"macros", ', '') }],
-    ['duplicate setup file', (f: ReturnType<typeof fixture>) => { f.manifest.setupFiles[1] = f.manifest.setupFiles[0] }],
-    ['unsafe program path', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].sourceFile = '../main.rs' }],
-    ['unexpected run command', (f: ReturnType<typeof fixture>) => { f.manifest.runCommand = 'cargo run --features test-support' }],
-    ['missing program', (f: ReturnType<typeof fixture>) => { delete f.files[f.manifest.examples[0].sourceFile] }],
-    ['partial file', (f: ReturnType<typeof fixture>) => { const file = f.manifest.examples[0].sourceFile; f.files[file] = f.files[file].trimEnd() }],
-    ['hidden helper', (f: ReturnType<typeof fixture>) => { f.files[f.manifest.examples[0].sourceFile] += 'mod helper;\n' }],
-    ['missing entrypoint', (f: ReturnType<typeof fixture>) => { f.files[f.manifest.examples[0].sourceFile] = 'fn example() {}\n' }],
-    ['empty output', (f: ReturnType<typeof fixture>) => { f.manifest.examples[0].expectedOutput = '' }],
+    [
+      'missing native target',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].targets.push('libtmux::Unknown')
+      },
+    ],
+    [
+      'duplicate native target',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].targets.push('libtmux::Server')
+      },
+    ],
+    [
+      'ambiguous inventory',
+      (f: ReturnType<typeof fixture>) => {
+        f.files[f.manifest.nativeInventory] += 'enum libtmux::Server\n'
+      },
+    ],
+    [
+      'missing model target',
+      (f: ReturnType<typeof fixture>) => {
+        f.symbols.splice(1, 1)
+      },
+    ],
+    [
+      'ambiguous model target',
+      (f: ReturnType<typeof fixture>) => {
+        f.symbols.push(symbol('other.Server', 'struct'))
+      },
+    ],
+    [
+      'wrong kind',
+      (f: ReturnType<typeof fixture>) => {
+        f.symbols[0].kind = 'enum'
+      },
+    ],
+    [
+      'wrong method owner',
+      (f: ReturnType<typeof fixture>) => {
+        f.symbols[4].parent = 'query.Other'
+      },
+    ],
+    [
+      'wrong source crate',
+      (f: ReturnType<typeof fixture>) => {
+        f.symbols[0].source.file = 'crates/tmux-workspace/src/server.rs'
+      },
+    ],
+    [
+      'wrong product',
+      (f: ReturnType<typeof fixture>) => {
+        f.symbols[0].product = 'workspace'
+      },
+    ],
+    [
+      'duplicate program',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples.push(f.manifest.examples[0])
+      },
+    ],
+    [
+      'missing Cargo setup',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files[f.manifest.setupFiles[0].sourceFile]
+      },
+    ],
+    [
+      'missing toolchain',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files['rust-toolchain.toml']
+      },
+    ],
+    [
+      'malformed TOML',
+      (f: ReturnType<typeof fixture>) => {
+        f.files['rust-toolchain.toml'] += '[broken\n'
+      },
+    ],
+    [
+      'unpinned toolchain',
+      (f: ReturnType<typeof fixture>) => {
+        f.files['rust-toolchain.toml'] = '[toolchain]\nchannel = "stable"\n'
+      },
+    ],
+    [
+      'wrong dependency path',
+      (f: ReturnType<typeof fixture>) => {
+        const file = f.manifest.setupFiles[0].sourceFile
+        f.files[file] = f.files[file].replace('libtmux-source/crates/libtmux', '../hidden')
+      },
+    ],
+    [
+      'missing runtime dependency',
+      (f: ReturnType<typeof fixture>) => {
+        const file = f.manifest.setupFiles[0].sourceFile
+        f.files[file] = f.files[file].replace('"macros", ', '')
+      },
+    ],
+    [
+      'duplicate setup file',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.setupFiles[1] = f.manifest.setupFiles[0]
+      },
+    ],
+    [
+      'unsafe program path',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].sourceFile = '../main.rs'
+      },
+    ],
+    [
+      'unexpected run command',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.runCommand = 'cargo run --features test-support'
+      },
+    ],
+    [
+      'missing program',
+      (f: ReturnType<typeof fixture>) => {
+        delete f.files[f.manifest.examples[0].sourceFile]
+      },
+    ],
+    [
+      'partial file',
+      (f: ReturnType<typeof fixture>) => {
+        const file = f.manifest.examples[0].sourceFile
+        f.files[file] = f.files[file].trimEnd()
+      },
+    ],
+    [
+      'hidden helper',
+      (f: ReturnType<typeof fixture>) => {
+        f.files[f.manifest.examples[0].sourceFile] += 'mod helper;\n'
+      },
+    ],
+    [
+      'missing entrypoint',
+      (f: ReturnType<typeof fixture>) => {
+        f.files[f.manifest.examples[0].sourceFile] = 'fn example() {}\n'
+      },
+    ],
+    [
+      'empty output',
+      (f: ReturnType<typeof fixture>) => {
+        f.manifest.examples[0].expectedOutput = ''
+      },
+    ],
   ])('rejects %s without partially changing documentation', (_name, change) => {
     const f = fixture()
     change(f)
@@ -107,7 +253,11 @@ describe('complete Rust API programs', () => {
 
   it('rejects an unpinned revision or foreign repository', () => {
     const f = fixture()
-    expect(() => attachCompleteRustExamples(f.symbols, f.read, { ...source, revision: 'master' })).toThrow('full revision')
-    expect(() => attachCompleteRustExamples(f.symbols, f.read, { ...source, repo: 'other/repo' })).toThrow('Rust repository')
+    expect(() => attachCompleteRustExamples(f.symbols, f.read, { ...source, revision: 'master' })).toThrow(
+      'full revision',
+    )
+    expect(() => attachCompleteRustExamples(f.symbols, f.read, { ...source, repo: 'other/repo' })).toThrow(
+      'Rust repository',
+    )
   })
 })
diff --git a/packages/api-model/test/rust.test.ts b/packages/api-model/test/rust.test.ts
index 16f99ad57..66090b960 100644
--- a/packages/api-model/test/rust.test.ts
+++ b/packages/api-model/test/rust.test.ts
@@ -45,11 +45,13 @@ describe('Rust trait member visibility', () => {
     expect(symbols.map(({ id, kind, parent }) => ({ id, kind, parent }))).toEqual([
       { id: 'query.QueryIteratorExt', kind: 'trait', parent: undefined },
       {
-        id: 'query.QueryIteratorExt.one_or_none', kind: 'method',
+        id: 'query.QueryIteratorExt.one_or_none',
+        kind: 'method',
         parent: 'query.QueryIteratorExt',
       },
       {
-        id: 'query.QueryIteratorExt.matching', kind: 'method',
+        id: 'query.QueryIteratorExt.matching',
+        kind: 'method',
         parent: 'query.QueryIteratorExt',
       },
     ])
@@ -60,10 +62,13 @@ describe('Rust trait member visibility', () => {
     })
     expect(symbols[2]).toMatchObject({
       doc: { summary: 'Keep matching items.' },
-      signatures: [{
-        params: [{ name: 'self' }, { name: 'predicate', type: 'P' }],
-        typeParams: ['P'], returns: 'Vec<Self::Item>',
-      }],
+      signatures: [
+        {
+          params: [{ name: 'self' }, { name: 'predicate', type: 'P' }],
+          typeParams: ['P'],
+          returns: 'Vec<Self::Item>',
+        },
+      ],
       source: { line: 6 },
     })
   })
@@ -83,15 +88,18 @@ describe('Rust trait member visibility', () => {
       pub fn public_free() {}
     `
     const symbols = await extract(source)
-    expect(symbols.map((symbol) => symbol.id)).toEqual([
-      'query.Server', 'query.Server.visible', 'query.public_free',
-    ])
+    expect(symbols.map((symbol) => symbol.id)).toEqual(['query.Server', 'query.Server.visible', 'query.public_free'])
     const all = await extract(source, true)
     for (const id of [
-      'query.Internal.hidden', 'query.Internal.default_hidden',
-      'query.CrateInternal.hidden', 'query.ParentInternal.hidden',
-      'query.Server.hidden', 'query.Server.crate_hidden', 'query.private_free',
-    ]) expect(all.some((symbol) => symbol.id === id)).toBe(true)
+      'query.Internal.hidden',
+      'query.Internal.default_hidden',
+      'query.CrateInternal.hidden',
+      'query.ParentInternal.hidden',
+      'query.Server.hidden',
+      'query.Server.crate_hidden',
+      'query.private_free',
+    ])
+      expect(all.some((symbol) => symbol.id === id)).toBe(true)
   })
 
   it('omits explicitly hidden trait hooks without hiding adjacent documented methods', async () => {
@@ -119,12 +127,19 @@ describe('Rust trait member visibility', () => {
       pub trait HiddenCombinedOwner { fn required(); }
     `
     expect((await extract(source)).map((symbol) => symbol.id)).toEqual([
-      'query.Contract', 'query.Contract.visible_required', 'query.Contract.visible_default',
+      'query.Contract',
+      'query.Contract.visible_required',
+      'query.Contract.visible_default',
     ])
-    expect((await extract(source, true)).filter((symbol) => symbol.parent === 'query.Contract')
-      .map((symbol) => symbol.name)).toEqual([
-      'hidden_required', 'hidden_default', 'hidden_combined', 'hidden_last',
-      'visible_required', 'visible_default',
+    expect(
+      (await extract(source, true)).filter((symbol) => symbol.parent === 'query.Contract').map((symbol) => symbol.name),
+    ).toEqual([
+      'hidden_required',
+      'hidden_default',
+      'hidden_combined',
+      'hidden_last',
+      'visible_required',
+      'visible_default',
     ])
   })
 
@@ -150,10 +165,12 @@ describe('Rust trait member visibility', () => {
     expect(params('typed')).toEqual([{ name: 'self', type: 'Box<Self>', default: undefined }])
     expect(params('consume')).toEqual([{ name: 'mut self' }])
     expect(params('borrow')).toEqual([{ name: '&mut self' }])
-    expect(symbols.find((symbol) => symbol.name === 'exactly_one')?.signatures[0].returns)
-      .toBe('Result<Self::Item, ExactlyOneError>')
-    expect(symbols.find((symbol) => symbol.name === 'one_or_none')?.signatures[0].returns)
-      .toBe('Result<Option<Self::Item>, MultipleItemsError>')
+    expect(symbols.find((symbol) => symbol.name === 'exactly_one')?.signatures[0].returns).toBe(
+      'Result<Self::Item, ExactlyOneError>',
+    )
+    expect(symbols.find((symbol) => symbol.name === 'one_or_none')?.signatures[0].returns).toBe(
+      'Result<Option<Self::Item>, MultipleItemsError>',
+    )
   })
 
   it('keeps fully qualified trait method identities and public links distinct', async () => {
@@ -165,36 +182,46 @@ describe('Rust trait member visibility', () => {
     })
     const model = await extractProject({ port: 'rs', root, revision: 'fixture-revision' })
     expect(model.revision).toBe('fixture-revision')
-    const hrefFor = (symbol: typeof model.symbols[number]) =>
+    const hrefFor = (symbol: (typeof model.symbols)[number]) =>
       `/reference/${pageSlug(symbol.publicId ?? symbol.id)}/#${symbol.publicId}`
     const resolver = new Resolver([model])
     const index = new SymbolIndex(model.symbols, hrefFor, 'rs')
     const parents = parentInventory(model, hrefFor)
-    const inventory = readInventory(writeInventory(model, {
-      project: 'rs', version: 'test', uriFor: hrefFor,
-    }))
+    const inventory = readInventory(
+      writeInventory(model, {
+        project: 'rs',
+        version: 'test',
+        uriFor: hrefFor,
+      }),
+    )
     for (const id of [
-      'query.QueryIteratorExt.matching', 'query.QueryIteratorExt.exactly_one',
+      'query.QueryIteratorExt.matching',
+      'query.QueryIteratorExt.exactly_one',
       'other.QueryIteratorExt.matching',
     ]) {
       const symbol = model.symbols.find((candidate) => candidate.id === id)
       expect(symbol).toMatchObject({
-        id, publicId: id, parent: id.slice(0, id.lastIndexOf('.')), kind: 'method',
+        id,
+        publicId: id,
+        parent: id.slice(0, id.lastIndexOf('.')),
+        kind: 'method',
       })
       expect(resolver.resolve('rs', id.replaceAll('.', '::'))?.symbol.id).toBe(id)
       expect(index.resolve(id)?.symbol?.id).toBe(id)
-      expect(index.linkText('[`crate::' + id.replaceAll('.', '::') + '`]')[0].link?.href)
-        .toBe(hrefFor(symbol!))
+      expect(index.linkText('[`crate::' + id.replaceAll('.', '::') + '`]')[0].link?.href).toBe(hrefFor(symbol!))
       expect(parents.find((entry) => entry.name === id)?.uri).toBe(hrefFor(symbol!).slice(1))
       expect(inventory.entries.find((entry) => entry.name === id)?.uri).toBe(hrefFor(symbol!))
     }
     expect(resolver.resolve('rs', 'Server')?.symbol.id).toBe('server.Server')
     expect(index.resolve('Server', 'class')?.symbol?.id).toBe('server.Server')
-    expect(parents.find((entry) => entry.name === 'Server')?.uri)
-      .toBe('reference/server-server/#server.Server')
-    expect(model.symbols.find((symbol) => symbol.id === 'server.Server.builder'))
-      .toMatchObject({ parent: 'server.Server', kind: 'method' })
-    expect(model.symbols.find((symbol) => symbol.id === 'options.OptionScope.Server'))
-      .toMatchObject({ parent: 'options.OptionScope', kind: 'constant' })
+    expect(parents.find((entry) => entry.name === 'Server')?.uri).toBe('reference/server-server/#server.Server')
+    expect(model.symbols.find((symbol) => symbol.id === 'server.Server.builder')).toMatchObject({
+      parent: 'server.Server',
+      kind: 'method',
+    })
+    expect(model.symbols.find((symbol) => symbol.id === 'options.OptionScope.Server')).toMatchObject({
+      parent: 'options.OptionScope',
+      kind: 'constant',
+    })
   })
 })
diff --git a/packages/api-model/test/source-lines.test.ts b/packages/api-model/test/source-lines.test.ts
index e830e85eb..a2c258733 100644
--- a/packages/api-model/test/source-lines.test.ts
+++ b/packages/api-model/test/source-lines.test.ts
@@ -8,9 +8,7 @@ import { mapLine, parseHunks } from '../src/source-lines.ts'
  */
 describe('parseHunks', () => {
   it('reads an omitted count as one line', () => {
-    expect(parseHunks('@@ -3 +3 @@\n-old\n+new\n')).toEqual([
-      { oldStart: 3, oldLines: 1, newStart: 3, newLines: 1 },
-    ])
+    expect(parseHunks('@@ -3 +3 @@\n-old\n+new\n')).toEqual([{ oldStart: 3, oldLines: 1, newStart: 3, newLines: 1 }])
   })
 
   it('reads several hunks in one diff', () => {
diff --git a/packages/api-model/test/symbolgraph.test.ts b/packages/api-model/test/symbolgraph.test.ts
index 3f84a9248..9fcc00d41 100644
--- a/packages/api-model/test/symbolgraph.test.ts
+++ b/packages/api-model/test/symbolgraph.test.ts
@@ -57,41 +57,66 @@ function graph(conformances: [string, string?][]): string[] {
   return [file]
 }
 
-const basesOf = (files: string[]) =>
-  extractSymbolGraph(files).find((s) => s.id === 'Thing')?.extends
+const basesOf = (files: string[]) => extractSymbolGraph(files).find((s) => s.id === 'Thing')?.extends
 
 const compatibleSelectors = [
-  ['LibTmux', 'Server.newSession(named:startDirectory:windowName:width:height:)',
-    'Server.newSession(named:startDirectory:windowName:width:height:environment:shell:)'],
-  ['LibTmux', 'Server.newWindow(in:named:startDirectory:)',
-    'Server.newWindow(in:named:startDirectory:at:environment:shell:)'],
-  ['LibTmux', 'Server.split(_:direction:size:startDirectory:)',
-    'Server.split(_:direction:size:startDirectory:environment:shell:)'],
-  ['LibTmux', 'Server.splitWindow(_:direction:size:startDirectory:)',
-    'Server.splitWindow(_:direction:size:startDirectory:environment:shell:)'],
-  ['TmuxWorkspace', 'PanePlan.init(shellCommands:startDirectory:)',
-    'PanePlan.init(shellCommands:startDirectory:focus:environment:shell:sleepBefore:sleepAfter:)'],
-  ['TmuxWorkspace', 'WindowPlan.init(windowName:startDirectory:layout:panes:)',
-    'WindowPlan.init(windowName:startDirectory:layout:panes:windowIndex:focus:environment:windowShell:)'],
+  [
+    'LibTmux',
+    'Server.newSession(named:startDirectory:windowName:width:height:)',
+    'Server.newSession(named:startDirectory:windowName:width:height:environment:shell:)',
+  ],
+  [
+    'LibTmux',
+    'Server.newWindow(in:named:startDirectory:)',
+    'Server.newWindow(in:named:startDirectory:at:environment:shell:)',
+  ],
+  [
+    'LibTmux',
+    'Server.split(_:direction:size:startDirectory:)',
+    'Server.split(_:direction:size:startDirectory:environment:shell:)',
+  ],
+  [
+    'LibTmux',
+    'Server.splitWindow(_:direction:size:startDirectory:)',
+    'Server.splitWindow(_:direction:size:startDirectory:environment:shell:)',
+  ],
+  [
+    'TmuxWorkspace',
+    'PanePlan.init(shellCommands:startDirectory:)',
+    'PanePlan.init(shellCommands:startDirectory:focus:environment:shell:sleepBefore:sleepAfter:)',
+  ],
+  [
+    'TmuxWorkspace',
+    'WindowPlan.init(windowName:startDirectory:layout:panes:)',
+    'WindowPlan.init(windowName:startDirectory:layout:panes:windowIndex:focus:environment:windowShell:)',
+  ],
 ] as const
 
 function selectorGraph(module: string, ids: string[]) {
   const dir = mkdtempSync(join(tmpdir(), 'symbolgraph-selector-'))
   dirs.push(dir)
   const file = join(dir, `${module}.symbols.json`)
-  writeFileSync(file, JSON.stringify({
-    module: { name: module },
-    symbols: ids.map((id) => ({
-      identifier: { precise: `s:${id}` },
-      kind: { identifier: 'swift.method' },
-      pathComponents: id.split('.'),
-      names: { title: id.split('.').at(-1), subHeading: [{ kind: 'text', spelling: `func ${id}` }] },
-      functionSignature: { parameters: [{ name: 'environment', declarationFragments: [
-        { kind: 'text', spelling: 'environment: [String: String] = [:]' },
-      ] }] },
-      accessLevel: 'public',
-    })),
-  }))
+  writeFileSync(
+    file,
+    JSON.stringify({
+      module: { name: module },
+      symbols: ids.map((id) => ({
+        identifier: { precise: `s:${id}` },
+        kind: { identifier: 'swift.method' },
+        pathComponents: id.split('.'),
+        names: { title: id.split('.').at(-1), subHeading: [{ kind: 'text', spelling: `func ${id}` }] },
+        functionSignature: {
+          parameters: [
+            {
+              name: 'environment',
+              declarationFragments: [{ kind: 'text', spelling: 'environment: [String: String] = [:]' }],
+            },
+          ],
+        },
+        accessLevel: 'public',
+      })),
+    }),
+  )
   return extractSymbolGraph([file])
 }
 
@@ -99,10 +124,13 @@ describe('compatible Swift selectors', () => {
   it.each(compatibleSelectors)('keeps %s %s links with the current declaration', (module, previous, current) => {
     const symbols = selectorGraph(module, [current])
     const [symbol] = symbols
-    expect(symbol).toMatchObject({ id: current, publicId: previous, qualifiedName: current,
-      name: current.split('.').at(-1), signatures: [{ params: [
-        { name: 'environment', type: '[String: String] = [:]' },
-      ] }] })
+    expect(symbol).toMatchObject({
+      id: current,
+      publicId: previous,
+      qualifiedName: current,
+      name: current.split('.').at(-1),
+      signatures: [{ params: [{ name: 'environment', type: '[String: String] = [:]' }] }],
+    })
     const href = `/reference/${pageSlug(symbol.publicId!)}/#${symbol.publicId}`
     expect(href).toBe(`/reference/${pageSlug(previous)}/#${previous}`)
     const index = new SymbolIndex(symbols, () => href, 'swift')
@@ -126,9 +154,7 @@ describe('symbol graph conformances', () => {
   it('names a standard library protocol rather than its USR', () => {
     // The long mangling form: module `s`, length-prefixed name, `P` for
     // protocol. `Copyable` is the same shape but is dropped as implicit.
-    expect(
-      basesOf(graph([['s:s12IdentifiableP', 'Swift.Identifiable']])),
-    ).toEqual(['Identifiable'])
+    expect(basesOf(graph([['s:s12IdentifiableP', 'Swift.Identifiable']]))).toEqual(['Identifiable'])
   })
 
   it('names one mangled with a standard substitution', () => {
@@ -198,14 +224,31 @@ describe('symbol graph source locations', () => {
     dirs.push(dir)
     const file = join(dir, 'Thing.symbols.json')
     const entry = {
-      identifier: { precise: 'generated-init' }, kind: { identifier: 'swift.init' },
-      pathComponents: ['Thing', 'init(from:)'], names: { title: 'init(from:)' }, accessLevel: 'public',
+      identifier: { precise: 'generated-init' },
+      kind: { identifier: 'swift.init' },
+      pathComponents: ['Thing', 'init(from:)'],
+      names: { title: 'init(from:)' },
+      accessLevel: 'public',
     }
-    const located = { ...entry, identifier: { precise: 'declared-init' }, location: { uri: 'file:///Sources/Thing.swift', position: { line: 12 } } }
-    writeFileSync(file, JSON.stringify({
-      symbols: locatedFirst ? [located, entry] : [entry, located],
-      relationships: [{ kind: 'memberOf', source: 'generated-init', target: 'Thing', sourceOrigin: { identifier: 'Decodable-init', displayName: 'Decodable.init(from:)' } }],
-    }))
+    const located = {
+      ...entry,
+      identifier: { precise: 'declared-init' },
+      location: { uri: 'file:///Sources/Thing.swift', position: { line: 12 } },
+    }
+    writeFileSync(
+      file,
+      JSON.stringify({
+        symbols: locatedFirst ? [located, entry] : [entry, located],
+        relationships: [
+          {
+            kind: 'memberOf',
+            source: 'generated-init',
+            target: 'Thing',
+            sourceOrigin: { identifier: 'Decodable-init', displayName: 'Decodable.init(from:)' },
+          },
+        ],
+      }),
+    )
     return file
   }
 
@@ -230,7 +273,14 @@ describe('symbol graph throwing contracts', () => {
   const keyword = (spelling: string) => ({ kind: 'keyword', spelling })
   const text = (spelling: string) => ({ kind: 'text', spelling })
   const type = (spelling: string) => ({ kind: 'typeIdentifier', spelling })
-  const head = [keyword('func'), text(' '), { kind: 'identifier', spelling: 'next' }, text('() '), keyword('async'), text(' ')]
+  const head = [
+    keyword('func'),
+    text(' '),
+    { kind: 'identifier', spelling: 'next' },
+    text('() '),
+    keyword('async'),
+    text(' '),
+  ]
   const returns = [type('Self'), text('.'), type('Element'), text('?')]
   const returned = [text(' -> '), ...returns]
 
@@ -238,18 +288,29 @@ describe('symbol graph throwing contracts', () => {
     const dir = mkdtempSync(join(tmpdir(), 'symbolgraph-throws-'))
     dirs.push(dir)
     const file = join(dir, 'Iterator.symbols.json')
-    writeFileSync(file, JSON.stringify({ symbols: [{
-      identifier: { precise: 'iterator-next' }, kind: { identifier: 'swift.method' },
-      pathComponents: ['Iterator', 'next()'], accessLevel: 'public',
-      names: { title: 'next()', subHeading: fragments },
-      functionSignature: { parameters: [], returns },
-    }] }))
+    writeFileSync(
+      file,
+      JSON.stringify({
+        symbols: [
+          {
+            identifier: { precise: 'iterator-next' },
+            kind: { identifier: 'swift.method' },
+            pathComponents: ['Iterator', 'next()'],
+            accessLevel: 'public',
+            names: { title: 'next()', subHeading: fragments },
+            functionSignature: { parameters: [], returns },
+          },
+        ],
+      }),
+    )
     return extractSymbolGraph([file])[0].signatures[0]
   }
 
   it('records untyped throws without treating the returned type as an error', () => {
     expect(signature([...head, keyword('throws'), ...returned])).toEqual({
-      params: [], returns: 'Self.Element?', raises: [{ type: 'any Error' }],
+      params: [],
+      returns: 'Self.Element?',
+      raises: [{ type: 'any Error' }],
     })
     expect(signature([...head, keyword('throws')]).raises).toEqual([{ type: 'any Error' }])
     expect(signature([...head, ...returned]).raises).toBeUndefined()
@@ -259,20 +320,35 @@ describe('symbol graph throwing contracts', () => {
     ['TmuxError', [type('TmuxError')]],
     ['Self.Failure', [type('Self'), text('.'), type('Failure')]],
     ['any Error', [keyword('any'), text(' '), type('Error')]],
-    ['Failures.Box<(Int, String)>', [type('Failures'), text('.'), type('Box'), text('<('), type('Int'), text(', '), type('String'), text(')>')]],
+    [
+      'Failures.Box<(Int, String)>',
+      [type('Failures'), text('.'), type('Box'), text('<('), type('Int'), text(', '), type('String'), text(')>')],
+    ],
   ] as const)('preserves the complete balanced error type %s', (expected, fragments) => {
-    expect(signature([...head, keyword('throws'), text('('), ...fragments, text(')'), ...returned]).raises)
-      .toEqual([{ type: expected }])
+    expect(signature([...head, keyword('throws'), text('('), ...fragments, text(')'), ...returned]).raises).toEqual([
+      { type: expected },
+    ])
   })
 
   it('does not attribute a throwing callback or returned function to its enclosing function', () => {
-    const callback = [keyword('func'), text(' map(('), type('Element'), text(') '), keyword('throws'), text(' -> '), type('Value'), text(') ')]
+    const callback = [
+      keyword('func'),
+      text(' map(('),
+      type('Element'),
+      text(') '),
+      keyword('throws'),
+      text(' -> '),
+      type('Value'),
+      text(') '),
+    ]
     expect(signature([...callback, ...returned]).raises).toBeUndefined()
-    expect(signature([...callback, keyword('throws'), text('('), type('TmuxError'), text(')'), ...returned]).raises)
-      .toEqual([{ type: 'TmuxError' }])
+    expect(
+      signature([...callback, keyword('throws'), text('('), type('TmuxError'), text(')'), ...returned]).raises,
+    ).toEqual([{ type: 'TmuxError' }])
     expect(signature([...head, text(' -> () '), keyword('throws'), ...returned]).raises).toBeUndefined()
-    expect(signature([...callback, keyword('rethrows'), ...returned]).raises)
-      .toEqual([{ type: 'any Error', doc: 'Conditionally propagates errors (rethrows).' }])
+    expect(signature([...callback, keyword('rethrows'), ...returned]).raises).toEqual([
+      { type: 'any Error', doc: 'Conditionally propagates errors (rethrows).' },
+    ])
   })
 
   it('does not invent a throwing contract from empty, incomplete or Never clauses', () => {
@@ -283,9 +359,13 @@ describe('symbol graph throwing contracts', () => {
 
   it('keeps the integrated iterator and callback wrapper error contracts separate', () => {
     const model = JSON.parse(readFileSync(new URL('../../../site/src/data/api/swift.json', import.meta.url), 'utf8'))
-    const iterator = model.symbols.find((symbol: { id: string }) => symbol.id === 'ControlNotificationStream.Iterator.next()')
-    expect(iterator.signatures.map((signature: { raises: { type: string }[] }) => signature.raises))
-      .toEqual([[{ type: 'Self.Failure' }], [{ type: 'TmuxError' }]])
+    const iterator = model.symbols.find(
+      (symbol: { id: string }) => symbol.id === 'ControlNotificationStream.Iterator.next()',
+    )
+    expect(iterator.signatures.map((signature: { raises: { type: string }[] }) => signature.raises)).toEqual([
+      [{ type: 'Self.Failure' }],
+      [{ type: 'TmuxError' }],
+    ])
     const wrapper = model.symbols.find((symbol: { id: string }) => symbol.id === 'withTmuxError(_:)')
     expect(wrapper.signatures[0].raises).toEqual([{ type: 'TmuxError' }])
   })
diff --git a/packages/api-model/test/typescript.test.ts b/packages/api-model/test/typescript.test.ts
index 2cdd52ef0..532f3619f 100644
--- a/packages/api-model/test/typescript.test.ts
+++ b/packages/api-model/test/typescript.test.ts
@@ -6,7 +6,9 @@ import { extractWithSpec } from '../src/languages/spec.ts'
 import { TYPESCRIPT } from '../src/languages/specs.ts'
 
 const dirs: string[] = []
-afterEach(() => { for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true }) })
+afterEach(() => {
+  for (const dir of dirs.splice(0)) rmSync(dir, { recursive: true, force: true })
+})
 
 async function extract(source: string) {
   const dir = mkdtempSync(join(tmpdir(), 'typescript-api-'))
@@ -36,7 +38,9 @@ describe('TypeScript signatures and parameter documentation', () => {
     expect(signature.params[0]).toMatchObject({ name: 'tmux', type: 'Server' })
     const options = signature.params[1]
     expect(options.default).toBe('{}')
-    expect(options.type).toBe(`{\n  readonly callerEnvironment?: Readonly<Record<string, string | undefined>>;\n  readonly environment?: Readonly<Record<string, string | undefined>>;\n  readonly policy?: Policy;\n  readonly startup?: ServerStartup;\n}`)
+    expect(options.type).toBe(
+      `{\n  readonly callerEnvironment?: Readonly<Record<string, string | undefined>>;\n  readonly environment?: Readonly<Record<string, string | undefined>>;\n  readonly policy?: Policy;\n  readonly startup?: ServerStartup;\n}`,
+    )
     expect(options.doc).toContain('Controls the server.')
     expect(options.doc).toContain('- `callerEnvironment`: The host pane environment. See {@link Server}.')
     expect(options.doc).toContain('- `environment`: Policy input.')
@@ -58,11 +62,17 @@ describe('TypeScript signatures and parameter documentation', () => {
     `)
     expect(symbols.find((symbol) => symbol.name === 'mode')?.type).toBe('"// literal  spaces"')
     const signature = symbols.find((symbol) => symbol.name === 'open')!.signatures[0]
-    expect(signature.params[0]).toMatchObject({ name: 'options', optional: true, doc: '- `transport.url`: Remote address.' })
+    expect(signature.params[0]).toMatchObject({
+      name: 'options',
+      optional: true,
+      doc: '- `transport.url`: Remote address.',
+    })
     expect(signature.params[0].type).toContain('"https://example.test/*value*/"')
     expect(signature.params[1]).toMatchObject({ name: 'keys', variadic: 'positional', type: 'string[]' })
     expect(signature.returns).toBe('"/* literal */"')
     expect(symbols.find((symbol) => symbol.name === 'isText')!.signatures[0].returns).toBe('value is string')
-    expect(symbols.find((symbol) => symbol.name === 'assertText')!.signatures[0].returns).toBe('asserts value is string')
+    expect(symbols.find((symbol) => symbol.name === 'assertText')!.signatures[0].returns).toBe(
+      'asserts value is string',
+    )
   })
 })
diff --git a/packages/theme/package.json b/packages/theme/package.json
index f97c1836c..b7a2f77e8 100644
--- a/packages/theme/package.json
+++ b/packages/theme/package.json
@@ -15,7 +15,6 @@
     "test:watch": "vitest watch",
     "test:types": "vitest run --typecheck",
     "lint": "oxlint --type-aware --tsconfig tsconfig.json --ignore-pattern '**/*.test.ts' --ignore-pattern '**/*.test-d.ts' src",
-    "format": "pnpm biome check . --write; biome format . --write",
     "update": "pnpm update",
     "ncu": "ncu",
     "clean": "rm -rf dist/ node_modules/.cache/",
@@ -27,7 +26,6 @@
     "tailwindcss": "^4.0.0"
   },
   "devDependencies": {
-    "@biomejs/biome": "catalog:",
     "@types/chroma-js": "^3.1.2",
     "memfs": "^4.80.0",
     "oxlint": "catalog:",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index df19eefce..86f92f485 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -164,15 +164,15 @@ settings:
 
 catalogs:
   default:
-    '@biomejs/biome':
-      specifier: 2.5.14
-      version: 2.5.14
     entities:
       specifier: 7.0.1
       version: 7.0.1
     happy-dom:
       specifier: ^20.14.5
       version: 20.14.5
+    oxfmt:
+      specifier: 0.70.0
+      version: 0.70.0
     oxlint:
       specifier: ^1.86.0
       version: 1.86.0
@@ -202,9 +202,6 @@ importers:
 
   .:
     devDependencies:
-      '@biomejs/biome':
-        specifier: 'catalog:'
-        version: 2.5.14
       entities:
         specifier: 'catalog:'
         version: 7.0.1
@@ -217,6 +214,9 @@ importers:
       mdast-util-to-markdown:
         specifier: 2.1.3
         version: 2.1.3
+      oxfmt:
+        specifier: 'catalog:'
+        version: 0.70.0
       oxlint:
         specifier: 'catalog:'
         version: 1.86.0(oxlint-tsgolint@7.0.2003)
@@ -270,9 +270,6 @@ importers:
         specifier: ^4.6.5
         version: 4.6.5
     devDependencies:
-      '@biomejs/biome':
-        specifier: 'catalog:'
-        version: 2.5.14
       '@types/chroma-js':
         specifier: ^3.1.2
         version: 3.1.2
@@ -547,63 +544,6 @@ packages:
     resolution: {integrity: sha512-Vj1jF3cPfxg7OAfoI7QnVKLoILlm2JF9pnVHrX8qx7AHMiYWT+NDAA7jChlNgRS4WTLc/fD1lXLmPixluj+3Gg==}
     engines: {node: '>=6.9.0'}
 
-  '@biomejs/biome@2.5.14':
-    resolution: {integrity: sha512-0FabLIjd4M/dm8VFI86RMaLLdgepzbdfiAL2R8cr7V81OYYrP1w7Z73KfAwPK5h9SrEBXTzNG2y+mBwPo9xRnw==}
-    engines: {node: '>=14.21.3'}
-    hasBin: true
-
-  '@biomejs/cli-darwin-arm64@2.5.14':
-    resolution: {integrity: sha512-UnzaXO65L4tsZimFITFP2M121GyhDcWFrT3pL5ZJ5U4XcS/0L5VHYytVohdCf/gnDUFHgl2I9xnt5bV/J1kxHQ==}
-    engines: {node: '>=14.21.3'}
-    cpu: [arm64]
-    os: [darwin]
-
-  '@biomejs/cli-darwin-x64@2.5.14':
-    resolution: {integrity: sha512-kiy8qA16K93J7uvFfWi4LgjqDpnRKyePAna6A0Y4jxyUga35SYpIZ2cNWlhy0lsfgqRenCpfymnJWEZ6mgpRgA==}
-    engines: {node: '>=14.21.3'}
-    cpu: [x64]
-    os: [darwin]
-
-  '@biomejs/cli-linux-arm64-musl@2.5.14':
-    resolution: {integrity: sha512-SJ9PrZkBnnH9dHJDnxk34vKs0GB2dbsioaft6/hPhWJ7AHpwYH83Isnhj0FSRpFkGgpVfJ1lds23ApB2czUDLQ==}
-    engines: {node: '>=14.21.3'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [musl]
-
-  '@biomejs/cli-linux-arm64@2.5.14':
-    resolution: {integrity: sha512-vO/9BaU1n30CiFNLx49gMTMtbCAAqlo/EqFoG0BU3deQInTbJrmXSmTQ9e3FoDZIKQnvSLDVNL4lx1ci7y1T1Q==}
-    engines: {node: '>=14.21.3'}
-    cpu: [arm64]
-    os: [linux]
-    libc: [glibc]
-
-  '@biomejs/cli-linux-x64-musl@2.5.14':
-    resolution: {integrity: sha512-2kI5PrMgW5dcEZYrstLPmUmCwkUwZY39rP4BN93Vxbwcs2O57LDQOktUZZYPvvspN5i0mhGr3TJtF5sU26NUWg==}
-    engines: {node: '>=14.21.3'}
-    cpu: [x64]
-    os: [linux]
-    libc: [musl]
-
-  '@biomejs/cli-linux-x64@2.5.14':
-    resolution: {integrity: sha512-VHZRa7CCQBUWKxNwUvHJeuW03WFRgN5NWO//SDGOitc9QIeNyfA42V9zlKm+x82xFSG9Bzi5fi+hbhm9anO8yA==}
-    engines: {node: '>=14.21.3'}
-    cpu: [x64]
-    os: [linux]
-    libc: [glibc]
-
-  '@biomejs/cli-win32-arm64@2.5.14':
-    resolution: {integrity: sha512-pHgAFffmZtaYoxavEsWEYNvcA7NwOIjLyqw2HXyLbt16xYryX0L4fMV2u0G9ag6LNYPIoqWaWqzUcnc6rLGGXg==}
-    engines: {node: '>=14.21.3'}
-    cpu: [arm64]
-    os: [win32]
-
-  '@biomejs/cli-win32-x64@2.5.14':
-    resolution: {integrity: sha512-oJWmBhoHsnhUKIke+0gXDX0mltJrWHA1UyHsrTlXwX0TL64ilVZAo+TYZm97baecV0esBdpzy3k96q+09JaZUQ==}
-    engines: {node: '>=14.21.3'}
-    cpu: [x64]
-    os: [win32]
-
   '@bruits/satteri-darwin-arm64@0.10.5':
     resolution: {integrity: sha512-27KTVl4TJkVahMy/ohyA7qd4938G5UNneFUz/PsScYfpIhj0IVAS23mpcJXdPF44sa6nva198lmV/cKIb2YPyA==}
     cpu: [arm64]
@@ -1196,6 +1136,128 @@ packages:
   '@oxc-project/types@0.151.0':
     resolution: {integrity: sha512-J1yXrIlNDZVzE3ada310xeAw7nH8yCAyLPuUIsjKatFPmfn5bS1oW+cM+QsGOtVWd5nhSpbwZWx/rue+r5Z+PA==}
 
+  '@oxfmt/binding-android-arm-eabi@0.70.0':
+    resolution: {integrity: sha512-Xd7YO4/T2axEj6FTLcj4Why3mTBqFMg+x24xtorT4Lb2+1g82090GH0a/4U1m0pABGYiix2bq1pqkYrmV3f0Sw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [android]
+
+  '@oxfmt/binding-android-arm64@0.70.0':
+    resolution: {integrity: sha512-x9rlMYyKXdgKdYyUJzGsK1ZV8P4di/J32ipzcS6Jet6p9r9UAh28neXIMtdlSaJJycdi61Z4YkcLKLpk8ueFjg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [android]
+
+  '@oxfmt/binding-darwin-arm64@0.70.0':
+    resolution: {integrity: sha512-IUTUPvrBVYy7POh4stXzRdz4IVC/1QSaviCWoyenSlOhGu0X9j5K07vCTM9biLjAA2Zs31l0Rj5vvRpj9n95wA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [darwin]
+
+  '@oxfmt/binding-darwin-x64@0.70.0':
+    resolution: {integrity: sha512-vw745q870oTd6J517O24asoX4/E+eK0nxYIFoedSLqgJ+nI5En7+ZS82iZSHZ69zevQrnOXiyHP01dA+t8xD8w==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [darwin]
+
+  '@oxfmt/binding-freebsd-x64@0.70.0':
+    resolution: {integrity: sha512-NO14EgSM9dFkcg+MfGPxvsKqXYs9LKaxPrOKXpv1R0rLokGGFDcCq6dBMq18dE4wlpFOovX0UZY2uh1P30O7QA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [freebsd]
+
+  '@oxfmt/binding-linux-arm-gnueabihf@0.70.0':
+    resolution: {integrity: sha512-139OEhHarj9CYoJ/i9gXlPv4KLBGtLj2toseOWYFf09QwlhklaZk+wW3aOvlqoeZtuayvkoSNVWra7WJ21s3VQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxfmt/binding-linux-arm-musleabihf@0.70.0':
+    resolution: {integrity: sha512-GEh2PY3IWTE0M24eNhTduountANSbWyDmMnzFSQE/nGg/bjPugbUgiGuFu+xdqcQSd/HKSwH80/F2yVVD48yhA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm]
+    os: [linux]
+
+  '@oxfmt/binding-linux-arm64-gnu@0.70.0':
+    resolution: {integrity: sha512-En5i+UJmZSPxuSf47F2Hl5YOzKB0bicQLnGQkeTCMQ35cWLtbrSwACJKfiLqRZrk05DwSnsJkhBRaM3OURtIaA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-arm64-musl@0.70.0':
+    resolution: {integrity: sha512-WWOoV5W9Im3flVwOVrWn/2DUlOF8v5vcCip+kcNuaMpulRCh6nzzt1Su2vcL2F908YJIXNV3HvegbBHuyLwKHg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxfmt/binding-linux-ppc64-gnu@0.70.0':
+    resolution: {integrity: sha512-YUouneIqW+5n7aE8xx/zeZ6/utr/KH7oykcGoFyd8Uz8uh591T1oKlnoWA3BsRq/ZR42oY1w4MUYvS/0e/MQOA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ppc64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-riscv64-gnu@0.70.0':
+    resolution: {integrity: sha512-iEnMf21S5aGVa4hViDGY8sAQ/AHyCu2JPyrQF8P06wtHhSkD1YJBeT4m/KiGewgf7+a5XCYSCRIPcRQa1xwEoQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-riscv64-musl@0.70.0':
+    resolution: {integrity: sha512-91Sdniaj20fQzyMeCxMDzTP4c9s4RB8dGQ308xHhDR0n6U7+1Xq7N9klE7mfXq8iV3lRmIGSXi5X23Hn/0XX/g==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [riscv64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxfmt/binding-linux-s390x-gnu@0.70.0':
+    resolution: {integrity: sha512-uUV30M6E+2TKKGMaKiwfeL4RZrviHXlUxsrYJ/jFBb+1EZy+pnFT+hF73eeWdzh5NqPOAnw0iiMAIqjqiLZPFg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [s390x]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-x64-gnu@0.70.0':
+    resolution: {integrity: sha512-ivMcX6kNDPhqtbOaBt/ItFlLlTlXNHLgRuNmxP6Na6UuYXRT10llpJcAPbGeRgjjb3Qzv4jwPp3fB0hui50WNQ==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [glibc]
+
+  '@oxfmt/binding-linux-x64-musl@0.70.0':
+    resolution: {integrity: sha512-w+S+fERxYmlZSyZlJK/U292FjyBoH8cCEj21/tYJX6atX5kNSn+HDkhlFQKT2zcMwUW0uAtUL/bOrlwJZwqRdA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [linux]
+    libc: [musl]
+
+  '@oxfmt/binding-openharmony-arm64@0.70.0':
+    resolution: {integrity: sha512-Zlom1Xkx257R8bk4ZI4zJsrGno2opknz1+5v5baka3nn4FPyvNSdh8JUL4CdN1S1OWRMvJ9UJQ+RfIqGGCUEfA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [openharmony]
+
+  '@oxfmt/binding-win32-arm64-msvc@0.70.0':
+    resolution: {integrity: sha512-FQgPW5R17vzt7cgrJ8eG/dqX00o2xHsqFeLfw4xzA9FRHpN/DjFo9YDonvIIXGxiEuS9F/jZPnGO+KHNKuCo4Q==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [arm64]
+    os: [win32]
+
+  '@oxfmt/binding-win32-ia32-msvc@0.70.0':
+    resolution: {integrity: sha512-ZfZublNhZ+XBndMiXhkiLlPE+XyGRDa0CweeTL6t1fZypfCh1LTg7e5CvnOeTBunq15MskOcRempumSPGAaCQA==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [ia32]
+    os: [win32]
+
+  '@oxfmt/binding-win32-x64-msvc@0.70.0':
+    resolution: {integrity: sha512-HlIZEn+WzLQL0DszNzldiRl/DPRCX5R0Vkt6qeUPR1YHwy52hZZo4x6HoTOVmKRP2wUiwPGtKsihNY/f8KRaBg==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    cpu: [x64]
+    os: [win32]
+
   '@oxlint-tsgolint/darwin-arm64@7.0.2003':
     resolution: {integrity: sha512-TgV33rXr6ueXBwvc+0nssUkTBSXHJxv77I8p4RCjDjCnvexHtmoPiudVRDfj3S3puMDdeQdHW6jdUgUPy3nr/w==}
     cpu: [arm64]
@@ -2657,6 +2719,19 @@ packages:
   oniguruma-to-es@4.3.6:
     resolution: {integrity: sha512-csuQ9x3Yr0cEIs/Zgx/OEt9iBw9vqIunAPQkx19R/fiMq2oGVTgcMqO/V3Ybqefr1TBvosI6jU539ksaBULJyA==}
 
+  oxfmt@0.70.0:
+    resolution: {integrity: sha512-IsHxZ4y0wQLLMhnrJblBJgZsLDzfULrJnAw5j/QqsTlMa/m3AqsbToi+W71uhBGaqlqq/PbbjvHc09TJwdv3Tw==}
+    engines: {node: ^20.19.0 || >=22.12.0}
+    hasBin: true
+    peerDependencies:
+      svelte: ^5.0.0
+      vite-plus: '*'
+    peerDependenciesMeta:
+      svelte:
+        optional: true
+      vite-plus:
+        optional: true
+
   oxlint-tsgolint@7.0.2003:
     resolution: {integrity: sha512-VnK4zlqgmgq/7ZcjzCk/WpN8kKFsYGcB85Io9qT3wL4K8Un3RKmJkp793crNETieMusPMKOA4a+Mw2wbteI6TQ==}
     hasBin: true
@@ -2990,6 +3065,10 @@ packages:
     resolution: {integrity: sha512-wXR/dYpcqKmfWpEdZjiKJOwCNFndD0DMnrW/cYjVGttEkBfVgcLFHoNrlj47mjOVic9yyNu65alsgF4NQyTa2g==}
     engines: {node: '>=12.0.0'}
 
+  tinypool@2.1.2:
+    resolution: {integrity: sha512-9YodfrxS9g9IbFr/KOjE5bAeJ0p61n3bW6mqvy0jtoeKd1kTW1Cxm0oulm6KX2lyM9Gl6WIe8nEbY7LWv5ZJww==}
+    engines: {node: ^20.0.0 || >=22.0.0}
+
   tree-dump@1.1.0:
     resolution: {integrity: sha512-rMuvhU4MCDbcbnleZTFezWsaZXRFemSqAM+7jPnzUl1fo9w3YEKOxAeui0fz3OI4EU4hf23iyA7uQRVko+UaBA==}
     engines: {node: '>=10.0'}
@@ -3626,41 +3705,6 @@ snapshots:
       '@babel/helper-string-parser': 7.29.7
       '@babel/helper-validator-identifier': 7.29.7
 
-  '@biomejs/biome@2.5.14':
-    optionalDependencies:
-      '@biomejs/cli-darwin-arm64': 2.5.14
-      '@biomejs/cli-darwin-x64': 2.5.14
-      '@biomejs/cli-linux-arm64': 2.5.14
-      '@biomejs/cli-linux-arm64-musl': 2.5.14
-      '@biomejs/cli-linux-x64': 2.5.14
-      '@biomejs/cli-linux-x64-musl': 2.5.14
-      '@biomejs/cli-win32-arm64': 2.5.14
-      '@biomejs/cli-win32-x64': 2.5.14
-
-  '@biomejs/cli-darwin-arm64@2.5.14':
-    optional: true
-
-  '@biomejs/cli-darwin-x64@2.5.14':
-    optional: true
-
-  '@biomejs/cli-linux-arm64-musl@2.5.14':
-    optional: true
-
-  '@biomejs/cli-linux-arm64@2.5.14':
-    optional: true
-
-  '@biomejs/cli-linux-x64-musl@2.5.14':
-    optional: true
-
-  '@biomejs/cli-linux-x64@2.5.14':
-    optional: true
-
-  '@biomejs/cli-win32-arm64@2.5.14':
-    optional: true
-
-  '@biomejs/cli-win32-x64@2.5.14':
-    optional: true
-
   '@bruits/satteri-darwin-arm64@0.10.5':
     optional: true
 
@@ -4170,6 +4214,63 @@ snapshots:
 
   '@oxc-project/types@0.151.0': {}
 
+  '@oxfmt/binding-android-arm-eabi@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-android-arm64@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-darwin-arm64@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-darwin-x64@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-freebsd-x64@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm-gnueabihf@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm-musleabihf@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm64-gnu@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-arm64-musl@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-ppc64-gnu@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-riscv64-gnu@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-riscv64-musl@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-s390x-gnu@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-x64-gnu@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-linux-x64-musl@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-openharmony-arm64@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-win32-arm64-msvc@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-win32-ia32-msvc@0.70.0':
+    optional: true
+
+  '@oxfmt/binding-win32-x64-msvc@0.70.0':
+    optional: true
+
   '@oxlint-tsgolint/darwin-arm64@7.0.2003':
     optional: true
 
@@ -5896,6 +5997,30 @@ snapshots:
       regex: 6.1.0
       regex-recursion: 6.0.2
 
+  oxfmt@0.70.0:
+    dependencies:
+      tinypool: 2.1.2
+    optionalDependencies:
+      '@oxfmt/binding-android-arm-eabi': 0.70.0
+      '@oxfmt/binding-android-arm64': 0.70.0
+      '@oxfmt/binding-darwin-arm64': 0.70.0
+      '@oxfmt/binding-darwin-x64': 0.70.0
+      '@oxfmt/binding-freebsd-x64': 0.70.0
+      '@oxfmt/binding-linux-arm-gnueabihf': 0.70.0
+      '@oxfmt/binding-linux-arm-musleabihf': 0.70.0
+      '@oxfmt/binding-linux-arm64-gnu': 0.70.0
+      '@oxfmt/binding-linux-arm64-musl': 0.70.0
+      '@oxfmt/binding-linux-ppc64-gnu': 0.70.0
+      '@oxfmt/binding-linux-riscv64-gnu': 0.70.0
+      '@oxfmt/binding-linux-riscv64-musl': 0.70.0
+      '@oxfmt/binding-linux-s390x-gnu': 0.70.0
+      '@oxfmt/binding-linux-x64-gnu': 0.70.0
+      '@oxfmt/binding-linux-x64-musl': 0.70.0
+      '@oxfmt/binding-openharmony-arm64': 0.70.0
+      '@oxfmt/binding-win32-arm64-msvc': 0.70.0
+      '@oxfmt/binding-win32-ia32-msvc': 0.70.0
+      '@oxfmt/binding-win32-x64-msvc': 0.70.0
+
   oxlint-tsgolint@7.0.2003:
     optionalDependencies:
       '@oxlint-tsgolint/darwin-arm64': 7.0.2003
@@ -6364,6 +6489,8 @@ snapshots:
       fdir: 6.5.0(picomatch@4.0.7)
       picomatch: 4.0.7
 
+  tinypool@2.1.2: {}
+
   tree-dump@1.1.0(tslib@2.8.1):
     dependencies:
       tslib: 2.8.1
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index 3c3e20822..9d18936f1 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -2,9 +2,9 @@ packages:
   - packages/*
   - site
 catalog:
-  '@biomejs/biome': 2.5.14
   entities: 7.0.1
   happy-dom: ^20.14.5
+  oxfmt: 0.70.0
   oxlint: ^1.86.0
   tree-sitter-wasms: ^0.1.13
   # Pinned exactly, not caret: the prebuilt grammars are ABI 13-14 and runtime
diff --git a/scripts/add-intersphinx.mjs b/scripts/add-intersphinx.mjs
index e1948fa57..962f972cf 100755
--- a/scripts/add-intersphinx.mjs
+++ b/scripts/add-intersphinx.mjs
@@ -50,7 +50,11 @@ for (const port of PORTS) {
   for (const dir of referenceDirs(siteDir, port)) {
     const inv = join(dir, 'objects.inv')
     if (!existsSync(inv)) continue
-    entries.push([`libtmux-${port}`, `${baseUrl.replace(/\/*$/, '')}/${dir.slice(siteDir.length).replace(/^\/+/, '')}/`, inv])
+    entries.push([
+      `libtmux-${port}`,
+      `${baseUrl.replace(/\/*$/, '')}/${dir.slice(siteDir.length).replace(/^\/+/, '')}/`,
+      inv,
+    ])
     break
   }
 }
diff --git a/scripts/audit-site.mjs b/scripts/audit-site.mjs
index 3a17a6931..d9bd3877c 100644
--- a/scripts/audit-site.mjs
+++ b/scripts/audit-site.mjs
@@ -1,34 +1,50 @@
 import { readdirSync, statSync, readFileSync } from 'node:fs'
 import { join, relative } from 'node:path'
-const ROOT='/home/d/work/libtmux/docs/_site'
-const pages=[]
-;(function w(d){for(const e of readdirSync(d)){const p=join(d,e)
-  if(statSync(p).isDirectory()){if(!/^(_static|_sources|_images|pagefind|\.build-logs)$/.test(e))w(p)}
-  else if(e==='index.html')pages.push(p)}})(ROOT)
-function content(h){
-  const m=h.match(/<article[^>]*role="main"[^>]*>([\s\S]*?)<\/article>/)||h.match(/<main[^>]*>([\s\S]*?)<\/main>/)
-  let b=m?m[1]:h
-  b=b.replace(/<(script|style|nav|aside|footer|header)[^>]*>[\s\S]*?<\/\1>/g,'')
-  return b.replace(/<[^>]+>/g,' ').replace(/&[a-z]+;|&#\d+;/g,' ').replace(/\s+/g,' ').trim()
+const ROOT = '/home/d/work/libtmux/docs/_site'
+const pages = []
+;(function w(d) {
+  for (const e of readdirSync(d)) {
+    const p = join(d, e)
+    if (statSync(p).isDirectory()) {
+      if (!/^(_static|_sources|_images|pagefind|\.build-logs)$/.test(e)) w(p)
+    } else if (e === 'index.html') pages.push(p)
+  }
+})(ROOT)
+function content(h) {
+  const m = h.match(/<article[^>]*role="main"[^>]*>([\s\S]*?)<\/article>/) || h.match(/<main[^>]*>([\s\S]*?)<\/main>/)
+  let b = m ? m[1] : h
+  b = b.replace(/<(script|style|nav|aside|footer|header)[^>]*>[\s\S]*?<\/\1>/g, '')
+  return b
+    .replace(/<[^>]+>/g, ' ')
+    .replace(/&[a-z]+;|&#\d+;/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
 }
-const rows=[]; let redirects=0
-for(const f of pages){
-  const url='/'+relative(ROOT,f).replace(/index\.html$/,'')
-  const html=readFileSync(f,'utf8')
-  if(/You should have been redirected/.test(html)){redirects++;continue}
-  const text=content(html); const flags=[]
-  if(text.length<40)flags.push('EMPTY')
-  else if(text.length<250)flags.push('THIN')
+const rows = []
+let redirects = 0
+for (const f of pages) {
+  const url = '/' + relative(ROOT, f).replace(/index\.html$/, '')
+  const html = readFileSync(f, 'utf8')
+  if (/You should have been redirected/.test(html)) {
+    redirects++
+    continue
+  }
+  const text = content(html)
+  const flags = []
+  if (text.length < 40) flags.push('EMPTY')
+  else if (text.length < 250) flags.push('THIN')
   // real rendered admonitions only, not identifiers containing "Error"
-  if(/class="admonition warning"|class="admonition error"/.test(html))flags.push('ADMONITION')
-  if(/Found multiple matches for file/.test(html))flags.push('breathe-ambiguous')
-  if(/Unable to resolve|Cannot find file|not found in doxygen/.test(html))flags.push('breathe-unresolved')
-  if(/\bTODO\b|\bFIXME\b|PLACEHOLDER/.test(text))flags.push('placeholder')
-  if(flags.length)rows.push({url,len:text.length,flags})
+  if (/class="admonition warning"|class="admonition error"/.test(html)) flags.push('ADMONITION')
+  if (/Found multiple matches for file/.test(html)) flags.push('breathe-ambiguous')
+  if (/Unable to resolve|Cannot find file|not found in doxygen/.test(html)) flags.push('breathe-unresolved')
+  if (/\bTODO\b|\bFIXME\b|PLACEHOLDER/.test(text)) flags.push('placeholder')
+  if (flags.length) rows.push({ url, len: text.length, flags })
 }
-rows.sort((a,b)=>a.len-b.len)
+rows.sort((a, b) => a.len - b.len)
 console.log(`pages ${pages.length}  redirects ${redirects}  flagged ${rows.length}\n`)
-const by={};for(const r of rows)for(const f of r.flags)by[f]=(by[f]||0)+1
-for(const[k,v]of Object.entries(by).sort((a,b)=>b[1]-a[1]))console.log(`  ${String(v).padStart(4)}  ${k}`)
+const by = {}
+for (const r of rows) for (const f of r.flags) by[f] = (by[f] || 0) + 1
+for (const [k, v] of Object.entries(by).sort((a, b) => b[1] - a[1])) console.log(`  ${String(v).padStart(4)}  ${k}`)
 console.log('\n-- non-THIN-only findings --')
-for(const r of rows.filter(r=>r.flags.some(f=>f!=='THIN')))console.log(`  ${String(r.len).padStart(6)}  ${r.flags.join(',').padEnd(28)} ${r.url}`)
+for (const r of rows.filter((r) => r.flags.some((f) => f !== 'THIN')))
+  console.log(`  ${String(r.len).padStart(6)}  ${r.flags.join(',').padEnd(28)} ${r.url}`)
diff --git a/scripts/brand-native-pages.mjs b/scripts/brand-native-pages.mjs
index 7f497e971..e19ff33d1 100644
--- a/scripts/brand-native-pages.mjs
+++ b/scripts/brand-native-pages.mjs
@@ -5,7 +5,8 @@ import { fileURLToPath } from 'node:url'
 import { branding, documentationTitle, jsonLd } from '../site/src/lib/branding.ts'
 import { PORT_BY_SLUG } from '../site/src/lib/ports.ts'
 
-const escape = (text) => String(text).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c])
+const escape = (text) =>
+  String(text).replace(/[&<>"']/g, (c) => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;' })[c])
 
 /** Add crawler-visible artwork while preserving native canonical/robots policy. */
 export function nativeBrandHead(html, { port, pagePath, root = '/en' }) {
@@ -16,7 +17,10 @@ export function nativeBrandHead(html, { port, pagePath, root = '/en' }) {
   const twitter = new URL(brand.asset('twitter-light.png'), origin).href
   // Native generators already escape title text. Retain those entities when
   // adding the project suffix, including in the social-title attributes.
-  const title = documentationTitle(/<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1].trim() || brand.projectName, brand.projectName)
+  const title = documentationTitle(
+    /<title\b[^>]*>([\s\S]*?)<\/title>/i.exec(html)?.[1].trim() || brand.projectName,
+    brand.projectName,
+  )
   const titleAttribute = title.replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
   const attr = (text) => escape(text)
   const tags = [
@@ -42,7 +46,8 @@ export function nativeBrandHead(html, { port, pagePath, root = '/en' }) {
     `<meta name="twitter:image" content="${attr(twitter)}">`,
     `<meta name="twitter:image:alt" content="${attr(brand.label)}">`,
     `<script type="application/ld+json" data-libtmux-brand>${jsonLd({
-      '@context': 'https://schema.org', '@type': 'SoftwareSourceCode',
+      '@context': 'https://schema.org',
+      '@type': 'SoftwareSourceCode',
       name: brand.projectName,
       alternateName: brand.port?.packageName,
       programmingLanguage: brand.palette.name,
@@ -50,19 +55,26 @@ export function nativeBrandHead(html, { port, pagePath, root = '/en' }) {
       image: new URL(brand.asset('logo-512.png'), origin).href,
     })}</script>`,
   ].join('\n')
-  const branded = html.replace(/<html\b([^>]*)>/i, (_match, attributes) =>
-    `<html${attributes.replace(/\sdata-brand(?:-variant)?=["'][^"']*["']/g, '')} data-brand="${brand.language}" data-brand-variant="${brand.variant}">`)
+  const branded = html.replace(
+    /<html\b([^>]*)>/i,
+    (_match, attributes) =>
+      `<html${attributes.replace(/\sdata-brand(?:-variant)?=["'][^"']*["']/g, '')} data-brand="${brand.language}" data-brand-variant="${brand.variant}">`,
+  )
   const withLogo = branded.replace(/<img\b[^>]*>/gi, (tag) => {
     const classes = /\bclass=["']([^"']*)["']/i.exec(tag)?.[1].split(/\s+/) ?? []
     if (!classes.includes('sidebar-logo')) return tag
-    return tag.replace(/\s(?:src|srcset)=["'][^"']*["']/gi, '')
+    return tag
+      .replace(/\s(?:src|srcset)=["'][^"']*["']/gi, '')
       .replace(/\s*\/?>$/, ` src="${attr(brand.asset('logo.svg'))}">`)
   })
   return withLogo.replace(/(<head\b[^>]*>)([\s\S]*?)(<\/head>)/i, (_match, open, head, close) => {
     const clean = head
       .replace(/<title\b[^>]*>[\s\S]*?<\/title>/gi, '')
       .replace(/<link\b[^>]*\brel=["'](?:shortcut icon|icon|apple-touch-icon|mask-icon|manifest)["'][^>]*>/gi, '')
-      .replace(/<meta\b[^>]*\b(?:name|property)=["'](?:og:title|og:site_name|twitter:title|og:image(?::[a-z_]+)?|twitter:image(?::alt)?|twitter:card|theme-color|msapplication-config)["'][^>]*>/gi, '')
+      .replace(
+        /<meta\b[^>]*\b(?:name|property)=["'](?:og:title|og:site_name|twitter:title|og:image(?::[a-z_]+)?|twitter:image(?::alt)?|twitter:card|theme-color|msapplication-config)["'][^>]*>/gi,
+        '',
+      )
       .replace(/<script\b[^>]*\bdata-libtmux-brand[^>]*>[\s\S]*?<\/script>/gi, '')
     return `${open}${clean.trimEnd()}\n${tags}\n${close}`
   })
@@ -77,7 +89,10 @@ export function brandNativePages(directory, port, root) {
       else if (entry.name.endsWith('.html')) {
         const before = readFileSync(path, 'utf8')
         const after = nativeBrandHead(before, { port, root, pagePath: relative(directory, path).replaceAll('\\', '/') })
-        if (before !== after) { writeFileSync(path, after); count++ }
+        if (before !== after) {
+          writeFileSync(path, after)
+          count++
+        }
       }
     }
   }
diff --git a/scripts/check-api-fidelity.mjs b/scripts/check-api-fidelity.mjs
index 959daab81..ee095a0db 100755
--- a/scripts/check-api-fidelity.mjs
+++ b/scripts/check-api-fidelity.mjs
@@ -73,9 +73,7 @@ function entriesIn(html) {
     }
     const raw = html.slice(i, end)
     if (raw.includes('gp-sphinx-api-header')) {
-      out.push(
-        Object.fromEntries([...raw.matchAll(/([a-z-]+)="([^"]*)"/g)].map((a) => [a[1], a[2]])),
-      )
+      out.push(Object.fromEntries([...raw.matchAll(/([a-z-]+)="([^"]*)"/g)].map((a) => [a[1], a[2]])))
     }
     i = end
   }
@@ -84,16 +82,23 @@ function entriesIn(html) {
 
 const failures = []
 const summary = []
-const decode = (value) => value?.replace(/&(amp|lt|gt|quot|#39);/g, (_, entity) =>
-  ({ amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" })[entity])
+const decode = (value) =>
+  value?.replace(
+    /&(amp|lt|gt|quot|#39);/g,
+    (_, entity) => ({ amp: '&', lt: '<', gt: '>', quot: '"', '#39': "'" })[entity],
+  )
 
 for (const port of PORTS) {
   const model = JSON.parse(readFileSync(join(repoRoot, `site/src/data/api/${port}.json`), 'utf8'))
-  const symbols = new Map(model.symbols.flatMap((symbol) => [
-    [symbol.id, symbol], [symbol.publicId ?? symbol.id, symbol],
-  ]))
-  const pages = referenceDirs(root, port, { products: true })
-    .flatMap((dir) => globSync('**/index.html', { cwd: dir }).map((page) => join(dir.slice(root.length + 1), page)))
+  const symbols = new Map(
+    model.symbols.flatMap((symbol) => [
+      [symbol.id, symbol],
+      [symbol.publicId ?? symbol.id, symbol],
+    ]),
+  )
+  const pages = referenceDirs(root, port, { products: true }).flatMap((dir) =>
+    globSync('**/index.html', { cwd: dir }).map((page) => join(dir.slice(root.length + 1), page)),
+  )
   if (!pages.length) {
     failures.push(`${port}: no reference pages built`)
     continue
diff --git a/scripts/check-api-links.mjs b/scripts/check-api-links.mjs
index 8269bed2f..3db514e60 100755
--- a/scripts/check-api-links.mjs
+++ b/scripts/check-api-links.mjs
@@ -19,13 +19,26 @@
 import { existsSync, globSync, readdirSync, readFileSync, statSync } from 'node:fs'
 import { dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { Resolver, parentInventory, decideFilePath, decideMention, isLikelyReference, looksLikeApiMention, notASymbol, notApiReason, proseMentions, readInventory } from '../packages/api-model/src/index.ts'
+import {
+  Resolver,
+  parentInventory,
+  decideFilePath,
+  decideMention,
+  isLikelyReference,
+  looksLikeApiMention,
+  notASymbol,
+  notApiReason,
+  proseMentions,
+  readInventory,
+} from '../packages/api-model/src/index.ts'
 import { decideMcpMention } from '../site/src/lib/mcp-catalog.ts'
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
 const { API_MODEL_PORTS: PORT_DEFS, PORT_BY_SLUG } = await import(`file://${resolve(root, 'site/src/lib/ports.ts')}`)
 const PORTS = PORT_DEFS.map((p) => p.slug)
-const { KNOWN_PORTS, resolvePortBody, resolvePortContent } = await import(`file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`)
+const { KNOWN_PORTS, resolvePortBody, resolvePortContent } = await import(
+  `file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`
+)
 const SHARED = join(root, 'site/src/content/_workspace-shared')
 const CONTENT = join(root, 'site/src/content/docs')
 const started = Date.now()
@@ -42,12 +55,19 @@ if (!Object.keys(models).length) {
 const resolver = new Resolver(Object.values(models))
 for (const port of PORTS) {
   const identity = PORT_BY_SLUG[port]
-  const dependencies = [...(identity.parentLibrary ? [identity.parentLibrary.slug] : []), ...(identity.apiDependencies ?? [])]
-  for (const dependency of dependencies) resolver.addInventory('Library API', '', parentInventory(models[dependency],
-    (symbol) => `/reference/${dependency}/${symbol.slug}/`), [port])
+  const dependencies = [
+    ...(identity.parentLibrary ? [identity.parentLibrary.slug] : []),
+    ...(identity.apiDependencies ?? []),
+  ]
+  for (const dependency of dependencies)
+    resolver.addInventory(
+      'Library API',
+      '',
+      parentInventory(models[dependency], (symbol) => `/reference/${dependency}/${symbol.slug}/`),
+      [port],
+    )
 }
 
-
 /*
  * The same federated inventories the linker loads, scoped the same way.
  *
@@ -58,7 +78,12 @@ for (const port of PORTS) {
  */
 const INVENTORIES = [
   { file: 'python.inv', project: 'Python', baseUrl: 'https://docs.python.org/3/', langs: ['py'] },
-  { file: 'jdk.inv', project: 'Java SE', baseUrl: 'https://docs.oracle.com/en/java/javase/21/docs/api/', langs: ['java', 'kotlin', 'scala'] },
+  {
+    file: 'jdk.inv',
+    project: 'Java SE',
+    baseUrl: 'https://docs.oracle.com/en/java/javase/21/docs/api/',
+    langs: ['java', 'kotlin', 'scala'],
+  },
   { file: 'dom.inv', project: 'MDN', baseUrl: 'https://developer.mozilla.org/', langs: ['ts'] },
   { file: 'julia.inv', project: 'Julia', baseUrl: 'https://docs.julialang.org/en/v1/', langs: ['julia'] },
 ]
@@ -150,7 +175,9 @@ const sharedRaw = files.length ? new Map() : sharedWorkspaceRaw()
 const targets = files.length
   ? files.map((f) => resolve(f))
   : [
-      ...globSync('{topics,guides,concepts,examples,ports}/**/*.{md,mdx}', { cwd: CONTENT }).map((f) => join(CONTENT, f)),
+      ...globSync('{topics,guides,concepts,examples,ports}/**/*.{md,mdx}', { cwd: CONTENT }).map((f) =>
+        join(CONTENT, f),
+      ),
       ...sharedRaw.keys(),
     ]
 
@@ -161,22 +188,34 @@ const missingFiles = []
 for (const file of targets) {
   const raw = sharedRaw.get(file) ?? readFileSync(file, 'utf8')
   const frontmatter = /^---\r?\n([\s\S]*?)\r?\n---/.exec(raw)?.[1] ?? ''
-  const authoredPort = /^port:\s*['"]?([a-z]+)['"]?\s*$/m.exec(frontmatter)?.[1]
-    ?? /^ports\/([^/]+)\//.exec(file.replace(`${CONTENT}/`, ''))?.[1]
+  const authoredPort =
+    /^port:\s*['"]?([a-z]+)['"]?\s*$/m.exec(frontmatter)?.[1] ??
+    /^ports\/([^/]+)\//.exec(file.replace(`${CONTENT}/`, ''))?.[1]
   // Match rehype-api-links: native wrapper guides have no shared API model.
   if (PORT_BY_SLUG[authoredPort]?.referenceKind === 'guide') continue
-  const product = /^product:\s*['"]?(core|workspace|mcp)['"]?\s*$/m.exec(frontmatter)?.[1]
-    ?? /^ports\/[^/]+\/(workspace|mcp)\//.exec(file.replace(`${CONTENT}/`, ''))?.[1]
+  const product =
+    /^product:\s*['"]?(core|workspace|mcp)['"]?\s*$/m.exec(frontmatter)?.[1] ??
+    /^ports\/[^/]+\/(workspace|mcp)\//.exec(file.replace(`${CONTENT}/`, ''))?.[1]
   const selected = resolvePortContent(raw, authoredPort)
-  for (const { text, port: ctxPort, before, line, linked } of proseMentions(selected.body, PORT_BY_LABEL, selected.portAt)) {
-    if (linked) { tally.alreadyLinked++; continue }
+  for (const { text, port: ctxPort, before, line, linked } of proseMentions(
+    selected.body,
+    PORT_BY_LABEL,
+    selected.portAt,
+  )) {
+    if (linked) {
+      tally.alreadyLinked++
+      continue
+    }
     const pagePort = authoredPort ?? ctxPort
 
     const protocol = decideMcpMention(text, { pagePort, product, before })
     if (protocol) {
       if (protocol.kind === 'link') tally.willLink++
       else if (protocol.kind === 'skip') tally.notASymbol++
-      else { tally.unresolved++; unresolved.push({ file, line, text, why: protocol.why }) }
+      else {
+        tally.unresolved++
+        unresolved.push({ file, line, text, why: protocol.why })
+      }
       continue
     }
 
@@ -184,25 +223,40 @@ for (const file of targets) {
       const d = decideFilePath(text, { before, pagePort }, trees)
       if (d.kind === 'link') tally.file++
       else if (d.kind === 'skip') tally.notASymbol++
-      else { tally.fileMissing++; missingFiles.push({ file, line, text, why: d.why }) }
+      else {
+        tally.fileMissing++
+        missingFiles.push({ file, line, text, why: d.why })
+      }
       continue
     }
     // The same two filters the linker applies, in the same order. This lint
     // exists to agree with the build; applying one fewer of them made it
     // report 124 where the build reported 61, which is the disagreement it
     // was written to prevent.
-    if (notASymbol(text) || !looksLikeApiMention(text)) { tally.notASymbol++; continue }
-
+    if (notASymbol(text) || !looksLikeApiMention(text)) {
+      tally.notASymbol++
+      continue
+    }
 
-    const decisions = (pagePort ? [pagePort] : PORTS)
-      .map((port) => decideMention(text, { pagePort: port, product, before }, resolver, models))
+    const decisions = (pagePort ? [pagePort] : PORTS).map((port) =>
+      decideMention(text, { pagePort: port, product, before }, resolver, models),
+    )
     // `notApiReason` gates *reporting*, not linking — exactly as the plugin
     // does. A span it names still gets offered to the resolver, because a
     // `TMUX_TMPDIR` that happens to resolve is a link worth having; it simply
     // is not a dangling reference when it does not.
     if (decisions.some((decision) => decision.kind === 'link')) tally.willLink++
-    else if (decisions.some((decision) => decision.kind === 'skip') || !isLikelyReference(text) || notApiReason(text) || EXCEPTIONS.has(text)) tally.notASymbol++
-    else { tally.unresolved++; unresolved.push({ file, line, text }) }
+    else if (
+      decisions.some((decision) => decision.kind === 'skip') ||
+      !isLikelyReference(text) ||
+      notApiReason(text) ||
+      EXCEPTIONS.has(text)
+    )
+      tally.notASymbol++
+    else {
+      tally.unresolved++
+      unresolved.push({ file, line, text })
+    }
   }
 }
 
diff --git a/scripts/check-canonicals.mjs b/scripts/check-canonicals.mjs
index cd1dbbe01..d7b94e119 100644
--- a/scripts/check-canonicals.mjs
+++ b/scripts/check-canonicals.mjs
@@ -24,10 +24,11 @@ import { join, dirname } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { referenceDirs } from './reference-trees.mjs'
 
-const { PORTS: PORT_DEFS } = await import(`file://${join(dirname(fileURLToPath(import.meta.url)), '../site/src/lib/ports.ts')}`)
+const { PORTS: PORT_DEFS } = await import(
+  `file://${join(dirname(fileURLToPath(import.meta.url)), '../site/src/lib/ports.ts')}`
+)
 const PORTS = PORT_DEFS.map((p) => p.slug)
 
-
 const repoRoot = dirname(dirname(fileURLToPath(import.meta.url)))
 const defaultSite = join(repoRoot, '_site')
 const siteDir = process.argv.slice(2).find((a) => !a.startsWith('--')) ?? defaultSite
@@ -61,10 +62,12 @@ if (siteDir === defaultSite && existsSync(lock)) {
  * publishing one prefix is its own default, and Python's two make `stable`
  * the canonical one.
  */
-const DEFAULTS = Object.fromEntries(PORTS.map((port) => {
-  const built = referenceDirs(siteDir, port).map((dir) => dir.split('/').at(-2))
-  return [port, built.includes('stable') ? 'stable' : built[0]]
-}).filter(([, version]) => version))
+const DEFAULTS = Object.fromEntries(
+  PORTS.map((port) => {
+    const built = referenceDirs(siteDir, port).map((dir) => dir.split('/').at(-2))
+    return [port, built.includes('stable') ? 'stable' : built[0]]
+  }).filter(([, version]) => version),
+)
 
 const roots = PORTS.flatMap((port) => referenceDirs(siteDir, port, { products: true }))
 if (!roots.length) {
@@ -111,8 +114,9 @@ for (const file of pages) {
   const refresh = html.match(REFRESH)
   // Contextual glossaries render the shared definitions inside each sidebar.
   // Only these exact routes may use the existing shared glossary canonical.
-  const contextualGlossary = ['', 'workspace/', 'mcp/'].some((product) =>
-    own === `/${port}/${version}/${product}reference/glossary/`)
+  const contextualGlossary = ['', 'workspace/', 'mcp/'].some(
+    (product) => own === `/${port}/${version}/${product}reference/glossary/`,
+  )
   if (contextualGlossary && declared === '/reference/glossary/') {
     checked += 1
     if (!glossaryCanonical || glossaryCanonical !== found[1] || refresh || REFRESH.test(glossaryHtml)) {
@@ -129,19 +133,25 @@ for (const file of pages) {
     const targetFile = join(siteDir, declared, 'index.html')
     const target = existsSync(targetFile) ? readFileSync(targetFile, 'utf8') : ''
     const targetCanonical = target.match(CANONICAL)
-    const valid = /<meta\s+name="robots"\s+content="noindex"/i.test(html) &&
+    const valid =
+      /<meta\s+name="robots"\s+content="noindex"/i.test(html) &&
       destination.href === new URL(found[1]).href &&
-      fallback && new URL(fallback[1], found[1]).href === destination.href &&
-      declared !== own && declared.startsWith(prefix) && targetCanonical &&
-      new URL(targetCanonical[1]).origin === destination.origin && !REFRESH.test(target)
+      fallback &&
+      new URL(fallback[1], found[1]).href === destination.href &&
+      declared !== own &&
+      declared.startsWith(prefix) &&
+      targetCanonical &&
+      new URL(targetCanonical[1]).origin === destination.origin &&
+      !REFRESH.test(target)
     checked += 1
     if (valid) redirects += 1
     else wrong.push({ file, want: `${own} (a noindex redirect within ${prefix})`, got: declared })
     continue
   }
-  const want = DEFAULTS[port] && DEFAULTS[port] !== version
-    ? own.replace(`/${port}/${version}/`, `/${port}/${DEFAULTS[port]}/`)
-    : own
+  const want =
+    DEFAULTS[port] && DEFAULTS[port] !== version
+      ? own.replace(`/${port}/${version}/`, `/${port}/${DEFAULTS[port]}/`)
+      : own
   checked += 1
   if (declared !== want) wrong.push({ file, want, got: declared })
 }
diff --git a/scripts/check-canonicals.negative.mjs b/scripts/check-canonicals.negative.mjs
index c5ae11f00..67e25a29b 100644
--- a/scripts/check-canonicals.negative.mjs
+++ b/scripts/check-canonicals.negative.mjs
@@ -21,7 +21,13 @@ const ORIGIN = 'https://libtmux.org'
 /** A reference tree whose canonical for each page is `canonicalFor(path)`. */
 function site(canonicalFor) {
   const dir = mkdtempSync(join(tmpdir(), 'check-canonicals-'))
-  const pages = ['reference', 'py/latest/reference', 'ts/latest/reference', 'py/latest/reference/pane', 'ts/latest/reference/pane']
+  const pages = [
+    'reference',
+    'py/latest/reference',
+    'ts/latest/reference',
+    'py/latest/reference/pane',
+    'ts/latest/reference/pane',
+  ]
   for (const page of pages) {
     mkdirSync(join(dir, page), { recursive: true })
     const href = `${ORIGIN}${canonicalFor(`/${page}/`)}`
@@ -87,24 +93,33 @@ const check = (name, ok, detail) => {
 for (const variant of ['valid', 'missing', 'foreign', 'origin', 'fallback', 'indexable', 'chain']) {
   const dir = site((p) => p)
   const old = '/ts/latest/reference/old-pane/'
-  const destination = variant === 'missing' ? '/ts/latest/reference/missing/'
-    : variant === 'foreign' ? '/py/latest/reference/pane/' : '/ts/latest/reference/pane/'
+  const destination =
+    variant === 'missing'
+      ? '/ts/latest/reference/missing/'
+      : variant === 'foreign'
+        ? '/py/latest/reference/pane/'
+        : '/ts/latest/reference/pane/'
   const href = variant === 'origin' ? `https://example.invalid${destination}` : destination
   mkdirSync(join(dir, old), { recursive: true })
-  writeFileSync(join(dir, old, 'index.html'), `<html><head>
+  writeFileSync(
+    join(dir, old, 'index.html'),
+    `<html><head>
     ${variant === 'indexable' ? '' : '<meta name="robots" content="noindex">'}
     <link rel="canonical" href="${variant === 'origin' ? href : `${ORIGIN}${destination}`}">
     <noscript><meta http-equiv="refresh" content="0;url=${href}"></noscript>
-    </head><body><a href="${variant === 'fallback' ? old : href}">Continue</a></body></html>`)
+    </head><body><a href="${variant === 'fallback' ? old : href}">Continue</a></body></html>`,
+  )
   if (variant === 'chain') {
-    writeFileSync(join(dir, destination, 'index.html'), `<html><head>
+    writeFileSync(
+      join(dir, destination, 'index.html'),
+      `<html><head>
       <meta name="robots" content="noindex"><link rel="canonical" href="${ORIGIN}${old}">
       <noscript><meta http-equiv="refresh" content="0;url=${old}"></noscript>
-      </head><body><a href="${old}">Continue</a></body></html>`)
+      </head><body><a href="${old}">Continue</a></body></html>`,
+    )
   }
   const { code, out } = run(dir)
-  check(`reference redirect ${variant}`, variant === 'valid' ? code === 0 : code !== 0,
-    `exited ${code}:\n${out}`)
+  check(`reference redirect ${variant}`, variant === 'valid' ? code === 0 : code !== 0, `exited ${code}:\n${out}`)
   rmSync(dir, { recursive: true, force: true })
 }
 
@@ -115,19 +130,35 @@ for (const prefix of ['', '/pr-139']) {
     const shared = join(dir, 'reference/glossary')
     if (variant !== 'missing') {
       mkdirSync(shared, { recursive: true })
-      writeFileSync(join(shared, 'index.html'), `<link rel="canonical" href="${variant === 'wrong-target' ? `${ORIGIN}/elsewhere/` : href}">
-        ${variant === 'redirect' ? '<meta http-equiv="refresh" content="0;url=/elsewhere/">' : ''}`)
+      writeFileSync(
+        join(shared, 'index.html'),
+        `<link rel="canonical" href="${variant === 'wrong-target' ? `${ORIGIN}/elsewhere/` : href}">
+        ${variant === 'redirect' ? '<meta http-equiv="refresh" content="0;url=/elsewhere/">' : ''}`,
+      )
     }
-    const scopes = variant === 'declaration' ? ['py/latest/reference/pane']
-      : variant === 'nested' ? ['py/latest/reference/other/glossary']
-      : ['py/latest/reference/glossary', 'ts/latest/workspace/reference/glossary', 'ts/latest/mcp/reference/glossary']
+    const scopes =
+      variant === 'declaration'
+        ? ['py/latest/reference/pane']
+        : variant === 'nested'
+          ? ['py/latest/reference/other/glossary']
+          : [
+              'py/latest/reference/glossary',
+              'ts/latest/workspace/reference/glossary',
+              'ts/latest/mcp/reference/glossary',
+            ]
     for (const scope of scopes) {
       mkdirSync(join(dir, scope), { recursive: true })
-      writeFileSync(join(dir, scope, 'index.html'), `<link rel="canonical" href="${variant === 'foreign' ? href.replace(ORIGIN, 'https://example.invalid') : href}">`)
+      writeFileSync(
+        join(dir, scope, 'index.html'),
+        `<link rel="canonical" href="${variant === 'foreign' ? href.replace(ORIGIN, 'https://example.invalid') : href}">`,
+      )
     }
     const { code, out } = run(dir, { ...process.env, LIBTMUX_DOCS_LOCALES_ROOT: prefix })
-    check(`shared glossary ${variant} (${prefix || 'production'})`, variant === 'valid' ? code === 0 : code !== 0,
-      `exited ${code}:\n${out}`)
+    check(
+      `shared glossary ${variant} (${prefix || 'production'})`,
+      variant === 'valid' ? code === 0 : code !== 0,
+      `exited ${code}:\n${out}`,
+    )
     rmSync(dir, { recursive: true, force: true })
   }
 }
diff --git a/scripts/check-citations.mjs b/scripts/check-citations.mjs
index ee3801ee7..436fea96b 100644
--- a/scripts/check-citations.mjs
+++ b/scripts/check-citations.mjs
@@ -144,7 +144,9 @@ if (asJson) {
   for (const c of checked) byPort[c.port] = (byPort[c.port] ?? 0) + 1
   console.log(
     `check-citations: ${checked.length} cited paths across ${Object.keys(byPort).length} ports ` +
-      `(${Object.entries(byPort).map(([p, n]) => `${p}:${n}`).join(' ')})`,
+      `(${Object.entries(byPort)
+        .map(([p, n]) => `${p}:${n}`)
+        .join(' ')})`,
   )
   for (const p of problems) {
     console.error(`  MISSING  ${p.file}:${p.line}  [${p.kind}]  ${p.port}: ${p.path}`)
diff --git a/scripts/check-edge-extensions.mjs b/scripts/check-edge-extensions.mjs
index 7f800bbcb..4b2588c30 100644
--- a/scripts/check-edge-extensions.mjs
+++ b/scripts/check-edge-extensions.mjs
@@ -104,7 +104,8 @@ if (missing.length || extensionless.length) {
   console.error(`check-edge-extensions: the edge function would redirect these away from their own files.`)
   for (const ext of missing) console.error(`  .${ext.padEnd(12)} e.g. ${found.get(ext)}`)
   for (const path of extensionless) console.error(`  no extension   ${path}`)
-  if (missing.length) console.error(`\nAdd the missing extensions to ASSET_EXTENSIONS in ${fnPath.slice(repoRoot.length + 1)}.`)
+  if (missing.length)
+    console.error(`\nAdd the missing extensions to ASSET_EXTENSIONS in ${fnPath.slice(repoRoot.length + 1)}.`)
   if (extensionless.length) console.error(`\nRename extensionless files and their links to use an allowed extension.`)
   process.exit(1)
 }
diff --git a/scripts/check-edge-extensions.negative.mjs b/scripts/check-edge-extensions.negative.mjs
index 6c6aeb729..fe90fce9d 100644
--- a/scripts/check-edge-extensions.negative.mjs
+++ b/scripts/check-edge-extensions.negative.mjs
@@ -98,13 +98,18 @@ const check = (name, ok, detail) => {
   const license = join(dir, 'reference', 'py', 'LICENSE')
   writeFileSync(license, 'Copyright and license notice')
   const broken = run(dir, fn)
-  check('an extensionless file fails even when every extension is allowed',
+  check(
+    'an extensionless file fails even when every extension is allowed',
     broken.code !== 0 && broken.out.includes('no extension') && broken.out.includes('/LICENSE'),
-    `exited ${broken.code}:\n${broken.out}`)
+    `exited ${broken.code}:\n${broken.out}`,
+  )
   renameSync(license, `${license}.txt`)
   const corrected = run(dir, fn)
-  check('an allowed text extension makes the same notice routable', corrected.code === 0,
-    `exited ${corrected.code}:\n${corrected.out}`)
+  check(
+    'an allowed text extension makes the same notice routable',
+    corrected.code === 0,
+    `exited ${corrected.code}:\n${corrected.out}`,
+  )
   rmSync(dir, { recursive: true, force: true })
 }
 
@@ -117,7 +122,11 @@ const check = (name, ok, detail) => {
   const f = join(fnDir, 'nofn.js')
   writeFileSync(f, 'export default 1\n')
   const { code, out } = run(dir, f)
-  check('a function file with no table fails loudly', code !== 0 && out.includes('no ASSET_EXTENSIONS'), `exited ${code}:\n${out}`)
+  check(
+    'a function file with no table fails loudly',
+    code !== 0 && out.includes('no ASSET_EXTENSIONS'),
+    `exited ${code}:\n${out}`,
+  )
   rmSync(dir, { recursive: true, force: true })
 }
 
@@ -125,7 +134,11 @@ const check = (name, ok, detail) => {
   const dir = mkdtempSync(join(tmpdir(), 'check-edge-ext-absent-'))
   rmSync(dir, { recursive: true, force: true })
   const { code, out } = run(dir, script)
-  check('an absent site directory fails rather than passing empty', code !== 0 && out.includes('no site at'), `exited ${code}:\n${out}`)
+  check(
+    'an absent site directory fails rather than passing empty',
+    code !== 0 && out.includes('no site at'),
+    `exited ${code}:\n${out}`,
+  )
 }
 
 if (failures) {
diff --git a/scripts/check-edge-function-copy.mjs b/scripts/check-edge-function-copy.mjs
index 58dc23740..aa608eeda 100755
--- a/scripts/check-edge-function-copy.mjs
+++ b/scripts/check-edge-function-copy.mjs
@@ -38,9 +38,7 @@ const expandHome = (p) => (p.startsWith('~/') ? join(homedir(), p.slice(2)) : p)
 
 const ours = resolve(arg('--ours', join(root, 'infra', 'cloudfront-function.js')))
 const tfConfig = expandHome(process.env.LIBTMUX_TF_CONFIG ?? '~/work/tf-config')
-const theirs = resolve(
-  arg('--theirs', join(tfConfig, 'terraform', 'sites', 'libtmux.org', 'cloudfront-function.js')),
-)
+const theirs = resolve(arg('--theirs', join(tfConfig, 'terraform', 'sites', 'libtmux.org', 'cloudfront-function.js')))
 
 if (!existsSync(ours)) {
   console.error(`check-edge-function-copy: no function at ${ours}`)
@@ -75,6 +73,6 @@ console.error(`  theirs: ${theirs}`)
 console.error(`  first difference at line ${i + 1}:`)
 console.error(`    ours:   ${al[i] ?? '<end of file>'}`)
 console.error(`    theirs: ${bl[i] ?? '<end of file>'}`)
-console.error('\nCopy this repository\'s function over the Terraform one and commit it there:')
+console.error("\nCopy this repository's function over the Terraform one and commit it there:")
 console.error(`  cp ${ours} ${theirs}`)
 process.exit(1)
diff --git a/scripts/check-edge-function-copy.negative.mjs b/scripts/check-edge-function-copy.negative.mjs
index 6e8320dfb..64d7a393d 100755
--- a/scripts/check-edge-function-copy.negative.mjs
+++ b/scripts/check-edge-function-copy.negative.mjs
@@ -26,7 +26,7 @@ function run(args) {
 const dir = mkdtempSync(join(tmpdir(), 'edge-function-copy-'))
 const ours = join(dir, 'ours.js')
 const theirs = join(dir, 'theirs.js')
-const BODY = "function handler(event) {\n    var uri = event.request.uri\n    return event.request\n}\n"
+const BODY = 'function handler(event) {\n    var uri = event.request.uri\n    return event.request\n}\n'
 
 let failures = 0
 const check = (name, ok, detail) => {
@@ -49,11 +49,7 @@ writeFileSync(theirs, BODY)
 writeFileSync(theirs, BODY.replace('var uri = event.request.uri', 'var uri = event.request.uri // stale'))
 {
   const res = run(['--ours', ours, '--theirs', theirs])
-  check(
-    'a drifted copy is caught',
-    res.code === 1 && /drifted/.test(res.out),
-    `exit ${res.code}: ${res.out.trim()}`,
-  )
+  check('a drifted copy is caught', res.code === 1 && /drifted/.test(res.out), `exit ${res.code}: ${res.out.trim()}`)
   check(
     'the report names the first differing line',
     /first difference at line 2/.test(res.out),
diff --git a/scripts/check-links.mjs b/scripts/check-links.mjs
index 05429a130..f007a4a18 100755
--- a/scripts/check-links.mjs
+++ b/scripts/check-links.mjs
@@ -72,9 +72,7 @@ const idsOf = (page) => {
   return ids.get(page)
 }
 
-const pattern = all
-  ? /href="([^"#]*)(?:#([^"]*))?"/g
-  : /href="([^"#]*)#([^"]+)"\s+class="api-mention"/g
+const pattern = all ? /href="([^"#]*)(?:#([^"]*))?"/g : /href="([^"#]*)#([^"]+)"\s+class="api-mention"/g
 
 /**
  * A URI scheme, which means the link leaves the site.
@@ -127,9 +125,13 @@ function resolveHref(fromPage, href) {
 
 let checked = 0
 const broken = []
-const recordBrokenLink = (page, path, anchor, why) => broken.push({
-  page, path: copyText(path), anchor: copyText(anchor), why,
-})
+const recordBrokenLink = (page, path, anchor, why) =>
+  broken.push({
+    page,
+    path: copyText(path),
+    anchor: copyText(anchor),
+    why,
+  })
 for (const page of pages) {
   const html = readFileSync(join(root, page), 'utf8')
   for (const m of html.matchAll(pattern)) {
@@ -150,8 +152,11 @@ for (const page of pages) {
     // A cache-busting query is not part of the path on a static site.
     const clean = path.replace(/\?.*$/, '')
     const resolved = resolveHref(page, clean)
-    const target = !clean ? page
-      : clean.endsWith('/') || resolved === '' ? `${resolved}/index.html`.replace(/^\//, '') : resolved
+    const target = !clean
+      ? page
+      : clean.endsWith('/') || resolved === ''
+        ? `${resolved}/index.html`.replace(/^\//, '')
+        : resolved
     const targetIds = idsOf(target)
     if (targetIds === undefined) recordBrokenLink(page, path, anchor, 'no page')
     else if (anchor && !hasAnchor(targetIds, anchor)) recordBrokenLink(page, path, anchor, 'no anchor')
@@ -184,8 +189,7 @@ for (const [key, { count, from }] of targets.slice(0, 30)) {
 if (targets.length > 30) console.log(`  ... and ${targets.length - 30} more targets`)
 if (vendored.length && broken.length && ours.length === 0) {
   console.log(
-    '\nall of them come from a vendored generator\'s own output; ' +
-      'reported, but not this build\'s to fail on',
+    "\nall of them come from a vendored generator's own output; " + "reported, but not this build's to fail on",
   )
 }
 process.exit(ours.length ? 1 : 0)
diff --git a/scripts/check-nav.mjs b/scripts/check-nav.mjs
index 7277a2495..411db04a2 100755
--- a/scripts/check-nav.mjs
+++ b/scripts/check-nav.mjs
@@ -94,8 +94,7 @@ const failures = []
 const label = (nav, id) => nav.unplaced.find((s) => s.id === id)?.name ?? id
 
 /** Every bucket id in the tree, children included — what a page can render. */
-const renderable = (buckets) =>
-  buckets.flatMap((b) => [b.id, ...renderable(b.children ?? [])])
+const renderable = (buckets) => buckets.flatMap((b) => [b.id, ...renderable(b.children ?? [])])
 
 for (const nav of navs) {
   const d = nav.diagnostics
diff --git a/scripts/check-nav.negative.mjs b/scripts/check-nav.negative.mjs
index 46e071b45..475a9211b 100755
--- a/scripts/check-nav.negative.mjs
+++ b/scripts/check-nav.negative.mjs
@@ -44,10 +44,7 @@ const CASES = {
         // No `not` clauses: exactly the CapturePaneRequest case, where two
         // unrelated buckets both claim and declaration order decides.
         symbols: [sym('FooBar')],
-        buckets: [
-          bucket('foo', { kind: 'name', prefix: 'Foo' }),
-          bucket('bar', { kind: 'name', suffix: 'Bar' }),
-        ],
+        buckets: [bucket('foo', { kind: 'name', prefix: 'Foo' }), bucket('bar', { kind: 'name', suffix: 'Bar' })],
       },
     },
   },
@@ -128,16 +125,12 @@ let failures = 0
 for (const [name, spec] of Object.entries(CASES)) {
   const dir = mkdtempSync(join(tmpdir(), `check-nav-${name}-`))
   try {
-    for (const [port, { symbols, buckets, unsettled, hideChildren, extraChild, model }] of Object.entries(
-      spec.ports,
-    )) {
+    for (const [port, { symbols, buckets, unsettled, hideChildren, extraChild, model }] of Object.entries(spec.ports)) {
       if (model) writeFileSync(join(dir, `${port}.json`), JSON.stringify({ port, symbols: model }))
       // The compiled nav knows about the child; the written tree will not.
       const withChild = extraChild
         ? buckets.map((b, i) =>
-            i === 0
-              ? { ...b, children: [{ id: extraChild.id, label: extraChild.id, match: extraChild.match }] }
-              : b,
+            i === 0 ? { ...b, children: [{ id: extraChild.id, label: extraChild.id, match: extraChild.match }] } : b,
           )
         : buckets
       const nav = compileNav({ port, buckets: withChild, unsettled }, symbols, ctx)
diff --git a/scripts/check-palette.mjs b/scripts/check-palette.mjs
index 58b82b35f..ceef684ee 100755
--- a/scripts/check-palette.mjs
+++ b/scripts/check-palette.mjs
@@ -25,8 +25,7 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..')
 /* `--ceiling` points at a different record so `check-palette.negative.mjs` can
  * exercise --update without rewriting the ceiling this repo ships. */
 const ceilingArg = process.argv.indexOf('--ceiling')
-const CEILING_FILE =
-  ceilingArg === -1 ? join(root, 'scripts/palette-ceiling.json') : process.argv[ceilingArg + 1]
+const CEILING_FILE = ceilingArg === -1 ? join(root, 'scripts/palette-ceiling.json') : process.argv[ceilingArg + 1]
 const PATTERN = /(?:bg|text|border|ring|divide|from|via|to)-(?:slate|gray|zinc|neutral|stone)-\d{2,3}/g
 
 const args = process.argv.slice(2)
@@ -34,7 +33,10 @@ const dir = args.includes('--dir') ? args[args.indexOf('--dir') + 1] : join(root
 
 const files = execFileSync('rg', ['-l', '--glob', '*.{astro,ts,tsx,css}', PATTERN.source, dir], {
   encoding: 'utf8',
-}).trim().split('\n').filter(Boolean)
+})
+  .trim()
+  .split('\n')
+  .filter(Boolean)
 
 /** Strip block comments and `//` lines so prose about the old classes is free. */
 const stripComments = (src) =>
@@ -76,9 +78,7 @@ const { ceiling } = JSON.parse(readFileSync(CEILING_FILE, 'utf8'))
 if (hits.length > ceiling) {
   const byFile = new Map()
   for (const h of hits) byFile.set(h.file, (byFile.get(h.file) ?? 0) + 1)
-  console.error(
-    `check-palette: ${hits.length} hard-coded palette utilities, ceiling is ${ceiling}.\n`,
-  )
+  console.error(`check-palette: ${hits.length} hard-coded palette utilities, ceiling is ${ceiling}.\n`)
   for (const [f, n] of [...byFile].sort((a, b) => b[1] - a[1]).slice(0, 10)) {
     console.error(`    ${String(n).padStart(3)}  ${f}`)
   }
@@ -91,9 +91,7 @@ if (hits.length > ceiling) {
 }
 
 if (hits.length < ceiling) {
-  console.log(
-    `check-palette: ${hits.length} hard-coded palette utilities, below the ceiling of ${ceiling}.`,
-  )
+  console.log(`check-palette: ${hits.length} hard-coded palette utilities, below the ceiling of ${ceiling}.`)
   console.log(`Lower it: node scripts/check-palette.mjs --update`)
   process.exit(1)
 }
diff --git a/scripts/check-palette.negative.mjs b/scripts/check-palette.negative.mjs
index 297ca16b8..d3ee86620 100755
--- a/scripts/check-palette.negative.mjs
+++ b/scripts/check-palette.negative.mjs
@@ -13,9 +13,7 @@ import { fileURLToPath } from 'node:url'
 
 const script = join(dirname(fileURLToPath(import.meta.url)), 'check-palette.mjs')
 const ceilingFile = join(dirname(fileURLToPath(import.meta.url)), 'palette-ceiling.json')
-const { ceiling } = JSON.parse(
-  execFileSync('cat', [ceilingFile], { encoding: 'utf8' }),
-)
+const { ceiling } = JSON.parse(execFileSync('cat', [ceilingFile], { encoding: 'utf8' }))
 
 /** A source tree carrying exactly `n` hard-coded palette utilities. */
 function tree(n) {
@@ -86,7 +84,14 @@ function update(dir, start, force) {
 }
 
 const GUARDS = [
-  { name: 'raising refused', n: ceiling + 5, start: ceiling, wantCode: 1, wantCeiling: ceiling, says: 'refusing to raise' },
+  {
+    name: 'raising refused',
+    n: ceiling + 5,
+    start: ceiling,
+    wantCode: 1,
+    wantCeiling: ceiling,
+    says: 'refusing to raise',
+  },
   { name: 'raising forced', n: ceiling + 5, start: ceiling, force: true, wantCode: 0, wantCeiling: ceiling + 5 },
   { name: 'lowering allowed', n: ceiling - 5, start: ceiling, wantCode: 0, wantCeiling: ceiling - 5 },
 ]
@@ -106,7 +111,9 @@ for (const c of GUARDS) {
       failures++
     } else {
       const how = c.force ? ' --force' : ''
-      console.log(`ok   ${c.name.padEnd(18)} ${c.n} vs ceiling ${c.start}${how} -> exit ${code}, ceiling now ${recorded}`)
+      console.log(
+        `ok   ${c.name.padEnd(18)} ${c.n} vs ceiling ${c.start}${how} -> exit ${code}, ceiling now ${recorded}`,
+      )
     }
   } finally {
     rmSync(dir, { recursive: true, force: true })
diff --git a/scripts/check-sidebar-refs.mjs b/scripts/check-sidebar-refs.mjs
index 9df2be99b..b2eac9a66 100755
--- a/scripts/check-sidebar-refs.mjs
+++ b/scripts/check-sidebar-refs.mjs
@@ -54,13 +54,19 @@ function pageUnder(portDir) {
   return undefined
 }
 
-const window = new Window({ settings: { enableJavaScriptEvaluation: false, disableCSSFileLoading: true, disableJavaScriptFileLoading: true } })
+const window = new Window({
+  settings: { enableJavaScriptEvaluation: false, disableCSSFileLoading: true, disableJavaScriptFileLoading: true },
+})
 const template = window.document.createElement('template')
 const labelOf = (element) => element.textContent.replace(/\s+/g, ' ').trim()
 const hrefOf = (link) => link.getAttribute('href') ?? ''
 const owned = (link) => hrefOf(link).startsWith(servedRoot)
 const hostOf = (href) => {
-  try { return new URL(href).hostname } catch { return undefined }
+  try {
+    return new URL(href).hostname
+  } catch {
+    return undefined
+  }
 }
 
 const failures = []
@@ -78,8 +84,9 @@ for (const port of PORTS) {
     failures.push(`${port}: expected one shared documentation picker, found ${pickers.length}`)
     continue
   }
-  const cores = [...pickers[0].querySelectorAll('[data-surface-group]')].filter((group) =>
-    group.querySelector(':scope > summary strong')?.textContent.trim() === 'Core Library')
+  const cores = [...pickers[0].querySelectorAll('[data-surface-group]')].filter(
+    (group) => group.querySelector(':scope > summary strong')?.textContent.trim() === 'Core Library',
+  )
   if (cores.length !== 1) {
     failures.push(`${port}: expected one Core Library group, found ${cores.length}`)
     continue
@@ -91,11 +98,14 @@ for (const port of PORTS) {
   // The sampled page supplies the version; a valid link to another version
   // must not satisfy the current context's native-reference contract.
   const version = relative(join(SITE, port), file).split('/')[0]
-  const expected = version === 'concepts' ? new RegExp(`^/${port}/[^/]+/reference/$`)
-    : new RegExp(`^/${port}/${version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/reference/$`)
+  const expected =
+    version === 'concepts'
+      ? new RegExp(`^/${port}/[^/]+/reference/$`)
+      : new RegExp(`^/${port}/${version.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}/reference/$`)
   const ours = sections.filter((link) => owned(link) && expected.test(pathOf(hrefOf(link))))
   if (ours.length !== 1) failures.push(`${port}: Core Library does not offer exactly one current native reference`)
-  else if (labelOf(ours[0]) !== 'API Reference') failures.push(`${port}: native reference is not labelled API Reference`)
+  else if (labelOf(ours[0]) !== 'API Reference')
+    failures.push(`${port}: native reference is not labelled API Reference`)
 
   const host = ECOSYSTEM[port]
   if (host) {
@@ -126,15 +136,22 @@ for (const port of PORTS) {
     const path = pathOf(href).replace(/^\//, '')
     if (!existsSync(join(SITE, path, 'index.html'))) failures.push(`${port}: ${href} is linked but not built`)
   }
-  const refs = links.filter((link) => hrefOf(link).includes('/reference/') ||
-    Object.values(ECOSYSTEM).includes(hostOf(hrefOf(link))) || /\/py\/[^/]+\/api\//.test(hrefOf(link)))
+  const refs = links
+    .filter(
+      (link) =>
+        hrefOf(link).includes('/reference/') ||
+        Object.values(ECOSYSTEM).includes(hostOf(hrefOf(link))) ||
+        /\/py\/[^/]+\/api\//.test(hrefOf(link)),
+    )
     .map((link) => ({ label: labelOf(link), external: Boolean(hostOf(hrefOf(link))) }))
 
   rows.push({ port, refs })
 }
 
 for (const { port, refs } of rows) {
-  console.log(`check-sidebar-refs: ${port.padEnd(7)} ${refs.map((r) => `${r.label}${r.external ? ' ↗' : ''}`).join('  |  ')}`)
+  console.log(
+    `check-sidebar-refs: ${port.padEnd(7)} ${refs.map((r) => `${r.label}${r.external ? ' ↗' : ''}`).join('  |  ')}`,
+  )
 }
 if (failures.length) {
   console.error(`\ncheck-sidebar-refs: ${failures.length} problem(s):`)
diff --git a/scripts/check-source-links.mjs b/scripts/check-source-links.mjs
index 403a3a7c6..a2edafb65 100755
--- a/scripts/check-source-links.mjs
+++ b/scripts/check-source-links.mjs
@@ -90,10 +90,14 @@ for (const [port, where] of Object.entries(CHECKOUT)) {
 
   const model = JSON.parse(readFileSync(modelPath, 'utf8'))
   const units = new Map()
-  const locations = model.symbols.flatMap((symbol) => [symbol,
-    ...symbol.signatures.filter((signature) => signature.source).map((signature, index) => ({
-      id: `${symbol.id} signature ${index + 1}`, source: signature.source,
-    })),
+  const locations = model.symbols.flatMap((symbol) => [
+    symbol,
+    ...symbol.signatures
+      .filter((signature) => signature.source)
+      .map((signature, index) => ({
+        id: `${symbol.id} signature ${index + 1}`,
+        source: signature.source,
+      })),
   ])
   for (const symbol of locations) {
     const repository = symbol.source.repo ?? model.repo
@@ -103,74 +107,74 @@ for (const [port, where] of Object.entries(CHECKOUT)) {
     units.get(key).symbols.push(symbol)
   }
   for (const unit of units.values()) {
-  const repo = expand(PRODUCT_CHECKOUT[unit.repository] ?? where)
-  const rev = unit.revision
-  if (!rev) {
-    report(port, 'model records no revision, so every source link is unbuildable')
-    continue
-  }
-
-  // 1. The commit has to exist here at all.
-  if (git(repo, 'rev-parse', '--verify', '--quiet', `${rev}^{commit}`) === undefined) {
-    report(port, `revision ${rev.slice(0, 8)} is not in ${where}`)
-    continue
-  }
-
-  // 2. And it has to be reachable from a remote a reader can fetch.
-  const remotes = (git(repo, 'branch', '-r', '--contains', rev) ?? '')
-    .split('\n')
-    .map((l) => l.trim())
-    .filter(Boolean)
-    .map((l) => l.split('/')[0])
-  const publicRemotes = [...new Set(remotes)].filter((r) => !PRIVATE_REMOTES.has(r))
-  if (!publicRemotes.length) {
-    report(
-      port,
-      `revision ${rev.slice(0, 8)} is on no public remote (${[...new Set(remotes)].join(', ') || 'no remote'}) — ` +
-        'every source link for this port 404s',
-    )
-    continue
-  }
-
-  // 3. Every path has to exist at that commit, and every line has to be
-  //    inside the file. A line past the end scrolls nowhere and is the shape
-  //    a bad remap would take.
-  const lengths = new Map()
-  let missing = 0
-  let past = 0
-  let firstMissing = ''
-  let noLine = 0
-  for (const s of unit.symbols) {
-    const file = s.source?.file
-    if (!file) continue
-    if (file.startsWith('..') || file.startsWith('/')) {
-      if (!firstMissing) firstMissing = file
-      missing++
+    const repo = expand(PRODUCT_CHECKOUT[unit.repository] ?? where)
+    const rev = unit.revision
+    if (!rev) {
+      report(port, 'model records no revision, so every source link is unbuildable')
       continue
     }
-    if (!lengths.has(file)) {
-      const blob = git(repo, 'show', `${rev}:${file}`)
-      lengths.set(file, blob === undefined ? null : blob.split('\n').length)
+
+    // 1. The commit has to exist here at all.
+    if (git(repo, 'rev-parse', '--verify', '--quiet', `${rev}^{commit}`) === undefined) {
+      report(port, `revision ${rev.slice(0, 8)} is not in ${where}`)
+      continue
     }
-    const n = lengths.get(file)
-    if (n === null) {
-      if (!firstMissing) firstMissing = file
-      missing++
+
+    // 2. And it has to be reachable from a remote a reader can fetch.
+    const remotes = (git(repo, 'branch', '-r', '--contains', rev) ?? '')
+      .split('\n')
+      .map((l) => l.trim())
+      .filter(Boolean)
+      .map((l) => l.split('/')[0])
+    const publicRemotes = [...new Set(remotes)].filter((r) => !PRIVATE_REMOTES.has(r))
+    if (!publicRemotes.length) {
+      report(
+        port,
+        `revision ${rev.slice(0, 8)} is on no public remote (${[...new Set(remotes)].join(', ') || 'no remote'}) — ` +
+          'every source link for this port 404s',
+      )
       continue
     }
-    if (s.source.line === undefined) noLine++
-    else if (s.source.line < 1 || s.source.line > n) past++
-  }
 
-  if (missing) report(port, `${missing} symbols name a path absent at ${rev.slice(0, 8)}, e.g. ${firstMissing}`)
-  if (past) report(port, `${past} symbols point past the end of their file at ${rev.slice(0, 8)}`)
-  if (!missing && !past) {
-    console.log(
-      `check-source-links: ${port} ${unit.repository} ${unit.symbols.length} declaration and method locations, ${lengths.size} files ` +
-        `at ${rev.slice(0, 8)} (${publicRemotes.join(', ')})` +
-        (noLine ? `, ${noLine} without a line` : ''),
-    )
-  }
+    // 3. Every path has to exist at that commit, and every line has to be
+    //    inside the file. A line past the end scrolls nowhere and is the shape
+    //    a bad remap would take.
+    const lengths = new Map()
+    let missing = 0
+    let past = 0
+    let firstMissing = ''
+    let noLine = 0
+    for (const s of unit.symbols) {
+      const file = s.source?.file
+      if (!file) continue
+      if (file.startsWith('..') || file.startsWith('/')) {
+        if (!firstMissing) firstMissing = file
+        missing++
+        continue
+      }
+      if (!lengths.has(file)) {
+        const blob = git(repo, 'show', `${rev}:${file}`)
+        lengths.set(file, blob === undefined ? null : blob.split('\n').length)
+      }
+      const n = lengths.get(file)
+      if (n === null) {
+        if (!firstMissing) firstMissing = file
+        missing++
+        continue
+      }
+      if (s.source.line === undefined) noLine++
+      else if (s.source.line < 1 || s.source.line > n) past++
+    }
+
+    if (missing) report(port, `${missing} symbols name a path absent at ${rev.slice(0, 8)}, e.g. ${firstMissing}`)
+    if (past) report(port, `${past} symbols point past the end of their file at ${rev.slice(0, 8)}`)
+    if (!missing && !past) {
+      console.log(
+        `check-source-links: ${port} ${unit.repository} ${unit.symbols.length} declaration and method locations, ${lengths.size} files ` +
+          `at ${rev.slice(0, 8)} (${publicRemotes.join(', ')})` +
+          (noLine ? `, ${noLine} without a line` : ''),
+      )
+    }
   }
 }
 
diff --git a/scripts/check-type-links.mjs b/scripts/check-type-links.mjs
index 9abd5e9a8..6afc0b069 100644
--- a/scripts/check-type-links.mjs
+++ b/scripts/check-type-links.mjs
@@ -28,10 +28,7 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..')
 /* `--ceiling` points at a different record so the negative test can drive this
  * script rather than a copy of its logic. */
 const ceilingArg = process.argv.indexOf('--ceiling')
-const CEILING_FILE =
-  ceilingArg === -1
-    ? join(root, 'scripts/type-links-ceiling.json')
-    : process.argv[ceilingArg + 1]
+const CEILING_FILE = ceilingArg === -1 ? join(root, 'scripts/type-links-ceiling.json') : process.argv[ceilingArg + 1]
 const { API_MODEL_PORTS: PORT_DEFS } = await import(`file://${join(root, 'site/src/lib/ports.ts')}`)
 const PORTS = PORT_DEFS.map((p) => p.slug)
 
@@ -124,7 +121,9 @@ if (args.includes('--list')) {
       .slice(0, 8)
       .map(([n, c]) => `${n}(${c})`)
       .join(' ')
-    console.log(`${p.padEnd(7)} ${String(resolved).padStart(6)} linked  ${String(unresolved).padStart(5)} plain  ${share.padStart(5)}% linked`)
+    console.log(
+      `${p.padEnd(7)} ${String(resolved).padStart(6)} linked  ${String(unresolved).padStart(5)} plain  ${share.padStart(5)}% linked`,
+    )
     console.log(`        ${top}`)
   }
   process.exit(0)
@@ -192,7 +191,9 @@ if (over.length) {
   console.error('check-type-links: more type names render plain than the ceiling allows.')
   for (const p of over) {
     const top = [...results[p].names.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5)
-    console.error(`  ${p.padEnd(7)} ${ceiling[p]} -> ${results[p].unresolved}   ${top.map(([n, c]) => `${n}(${c})`).join(' ')}`)
+    console.error(
+      `  ${p.padEnd(7)} ${ceiling[p]} -> ${results[p].unresolved}   ${top.map(([n, c]) => `${n}(${c})`).join(' ')}`,
+    )
   }
   console.error('\nSee them all: node scripts/check-type-links.mjs --list')
   process.exit(1)
diff --git a/scripts/check-type-links.negative.mjs b/scripts/check-type-links.negative.mjs
index 176e15530..8d7c721b9 100644
--- a/scripts/check-type-links.negative.mjs
+++ b/scripts/check-type-links.negative.mjs
@@ -33,9 +33,7 @@ function site({ n = 0, mangled = false } = {}) {
     const d = join(dir, p, 'latest', 'reference', 'thing')
     mkdirSync(d, { recursive: true })
     const body =
-      linked('Server') +
-      Array.from({ length: n }, (_, i) => plain(`Plain${i}`)).join('') +
-      (mangled ? usr() : '')
+      linked('Server') + Array.from({ length: n }, (_, i) => plain(`Plain${i}`)).join('') + (mangled ? usr() : '')
     writeFileSync(join(d, 'index.html'), `<html><body>${body}</body></html>`)
   }
   return dir
diff --git a/scripts/check-xrefs.mjs b/scripts/check-xrefs.mjs
index ca9fabe17..2d82807a2 100755
--- a/scripts/check-xrefs.mjs
+++ b/scripts/check-xrefs.mjs
@@ -27,8 +27,7 @@ const root = join(dirname(fileURLToPath(import.meta.url)), '..')
 /* `--floor` points at a different record so `check-xrefs.negative.mjs` can
  * drive this script rather than a copy of its logic. */
 const floorArg = process.argv.indexOf('--floor')
-const FLOOR_FILE =
-  floorArg === -1 ? join(root, 'scripts/xref-floor.json') : process.argv[floorArg + 1]
+const FLOOR_FILE = floorArg === -1 ? join(root, 'scripts/xref-floor.json') : process.argv[floorArg + 1]
 const { API_MODEL_PORTS: PORT_DEFS } = await import(`file://${join(root, 'site/src/lib/ports.ts')}`)
 const PORTS = PORT_DEFS.map((p) => p.slug)
 
@@ -55,18 +54,22 @@ function countIn(dir) {
 // Core and companion references share one floor within a version. Count each
 // version separately: a healthy stable tree must not conceal broken latest
 // references, and building both versions must not double the recorded floor.
-const versionCounts = Object.fromEntries(PORTS.map((port) => {
-  const versions = {}
-  for (const dir of referenceDirs(site, port, { products: true })) {
-    const version = relative(join(site, port), dir).split(sep)[0]
-    versions[version] = (versions[version] ?? 0) + countIn(dir)
-  }
-  return [port, versions]
-}))
-const counts = Object.fromEntries(PORTS.map((port) => {
-  const values = Object.values(versionCounts[port])
-  return [port, values.length ? Math.min(...values) : 0]
-}))
+const versionCounts = Object.fromEntries(
+  PORTS.map((port) => {
+    const versions = {}
+    for (const dir of referenceDirs(site, port, { products: true })) {
+      const version = relative(join(site, port), dir).split(sep)[0]
+      versions[version] = (versions[version] ?? 0) + countIn(dir)
+    }
+    return [port, versions]
+  }),
+)
+const counts = Object.fromEntries(
+  PORTS.map((port) => {
+    const values = Object.values(versionCounts[port])
+    return [port, values.length ? Math.min(...values) : 0]
+  }),
+)
 
 if (args.includes('--update')) {
   /*
@@ -122,8 +125,12 @@ const below = PORTS.filter((p) => counts[p] < floor[p])
 for (const p of PORTS) {
   const f = floor[p]
   const mark = counts[p] < f ? 'FELL' : counts[p] > f ? 'up' : 'ok'
-  const versions = Object.entries(versionCounts[p]).map(([version, count]) => `${version}: ${count}`).join(', ')
-  console.log(`${p.padEnd(7)} ${String(counts[p]).padStart(7)} resolved  (floor ${f})  ${mark}  [${versions || 'no versions'}]`)
+  const versions = Object.entries(versionCounts[p])
+    .map(([version, count]) => `${version}: ${count}`)
+    .join(', ')
+  console.log(
+    `${p.padEnd(7)} ${String(counts[p]).padStart(7)} resolved  (floor ${f})  ${mark}  [${versions || 'no versions'}]`,
+  )
 }
 
 if (below.length) {
diff --git a/scripts/check-xrefs.negative.mjs b/scripts/check-xrefs.negative.mjs
index 0216e39e9..aa2743e7a 100755
--- a/scripts/check-xrefs.negative.mjs
+++ b/scripts/check-xrefs.negative.mjs
@@ -59,16 +59,28 @@ const CASES = [
    */
   { name: 'port unrecorded', built: 0, floor: 10, omit: ['go'], mustFail: true, says: 'no floor recorded for go' },
   {
-    name: 'version masks fall', built: 10, floor: 10, mustFail: true,
-    setup: (dir) => { version(dir, 'py', 'latest', 2); version(dir, 'py', 'stable', 20) },
+    name: 'version masks fall',
+    built: 10,
+    floor: 10,
+    mustFail: true,
+    setup: (dir) => {
+      version(dir, 'py', 'latest', 2)
+      version(dir, 'py', 'stable', 20)
+    },
     says: 'resolution fell on py',
   },
   {
-    name: 'both versions hold', built: 10, floor: 10, mustFail: false,
+    name: 'both versions hold',
+    built: 10,
+    floor: 10,
+    mustFail: false,
     setup: (dir) => version(dir, 'py', 'stable', 10),
   },
   {
-    name: 'products share version', built: 10, floor: 10, mustFail: false,
+    name: 'products share version',
+    built: 10,
+    floor: 10,
+    mustFail: false,
     setup: (dir) => {
       version(dir, 'py', 'latest', 6)
       version(dir, 'py', 'latest/mcp', 4)
@@ -127,13 +139,26 @@ const GUARDS = [
   { name: 'lowering forced', built: 2, floor: 10, force: true, wantCode: 0, wantFloor: 2 },
   { name: 'raising allowed', built: 10, floor: 2, wantCode: 0, wantFloor: 10 },
   {
-    name: 'version lowering refused', built: 10, floor: 10, wantCode: 1, wantFloor: 10,
-    port: 'py', says: 'refusing to lower',
-    setup: (dir) => { version(dir, 'py', 'latest', 2); version(dir, 'py', 'stable', 20) },
+    name: 'version lowering refused',
+    built: 10,
+    floor: 10,
+    wantCode: 1,
+    wantFloor: 10,
+    port: 'py',
+    says: 'refusing to lower',
+    setup: (dir) => {
+      version(dir, 'py', 'latest', 2)
+      version(dir, 'py', 'stable', 20)
+    },
   },
   {
-    name: 'version count not added', built: 10, floor: 10, wantCode: 0, wantFloor: 10,
-    port: 'py', setup: (dir) => version(dir, 'py', 'stable', 10),
+    name: 'version count not added',
+    built: 10,
+    floor: 10,
+    wantCode: 0,
+    wantFloor: 10,
+    port: 'py',
+    setup: (dir) => version(dir, 'py', 'stable', 10),
   },
 ]
 
@@ -154,7 +179,9 @@ for (const c of GUARDS) {
       failures++
     } else {
       const how = c.force ? ' --force' : ''
-      console.log(`ok   ${c.name.padEnd(16)} built ${c.built} vs floor ${c.floor}${how} -> exit ${code}, floor now ${recorded}`)
+      console.log(
+        `ok   ${c.name.padEnd(16)} built ${c.built} vs floor ${c.floor}${how} -> exit ${code}, floor now ${recorded}`,
+      )
     }
   } finally {
     rmSync(dir, { recursive: true, force: true })
diff --git a/scripts/check_example_width.py b/scripts/check_example_width.py
new file mode 100644
index 000000000..b29949890
--- /dev/null
+++ b/scripts/check_example_width.py
@@ -0,0 +1,3066 @@
+r"""Fail when code a reader sees in rendered documentation is too wide.
+
+Shared by every libtmux port; change it in all of them together. It
+enforces the example rules in WRITING.md. Configuration lives in
+``.github/example-width.toml``::
+
+    width = 80
+    tab_width = 4
+    markdown = ["**/*.md"]
+    sources = ["examples/**/*.rs"]
+    doc_comments = ["src/**/*.rs"]
+    shared_digest = "<sha256 printed by --digest>"
+    checker_digest = "<sha256 printed by --digest>"
+    allow_ceiling = 1
+
+    [[exclude]]
+    glob = "docs/decisions/**"
+    reason = "dated decision records, not reader-facing examples"
+
+    [[formatter_copies]]
+    copy = "examples/rustfmt.toml"
+    root = "rustfmt.toml"
+    key = "max_width"
+
+    [[allow]]
+    path = "README.md"
+    line = "the exact line, as it appears in the file"
+    reason = "why breaking it would make the example worse"
+
+It checks code in ``markdown`` files (fences, indented blocks, including
+one four columns past a list item's text, and ``<pre>`` blocks; literal
+and ``code-block`` blocks in a ``.rst`` one), every line of ``sources``
+files, and the code inside doc comments of ``doc_comments`` files:
+fences, read as a Markdown page reads them, ``>>>`` doctests, and reST
+literal blocks in Python docstrings. Output is not checked: fences
+tagged ``text``, and the lines a session prints (a ``console``,
+``shell-session`` or ``pycon`` block, or a ``python`` fence that opens
+with ``>>> ``). A command runs on through an open quote, heredoc, loop,
+conditional or brace block and past a trailing ``\``, backtick, pipe,
+``&&`` or ``||``; a ``$ `` command must continue with ``\`` and a
+``PS> `` command with a backtick. An untagged Markdown fence is code,
+and a ``text`` fence that opens with a ``$ `` or ``PS> `` prompt is a
+console session. A line that is only a URL (after an optional comment, list or
+quote marker) and a hidden line (a rustdoc ``# `` line, a doctest marked
+``# doctest: +HIDE``) are skipped. Wide characters count as two columns;
+a tab advances to the next multiple of 4.
+
+``width`` must be 80, the shared rule, and ``tab_width``, if set, 4.
+Every key must be known, at the top level and inside each ``[[...]]``
+entry, so a key written below a table header cannot be swallowed by that
+entry; every entry must hold
+the keys the check reads, and every value must have the type it reads.
+Every glob must match a tracked file, and every exclusion a checked file
+or a file under ``examples``;
+every exclusion and allow entry must give a reason, and every allow
+entry must match a line. Every tracked file under a directory named
+``examples`` must be checked or excluded, so a new example file cannot
+go unread. ``allow_ceiling`` must equal the number of allow entries, so
+the list grows only through a reviewed change to that number and a fixed
+line must lower it. Each formatter copy must equal its root file once
+its ``key`` value is set aside, and the digests of this checker and of
+WRITING.md's shared section must equal ``checker_digest`` and
+``shared_digest``, both required, so a local edit to either fails until
+every port changes together. A WRITING.md without both shared markers is
+reported by name. AGENTS.md must hold a Markdown link that resolves to
+this WRITING.md and the heading the shared section sits under, so an
+agent is routed to the rules, and WRITING.md's
+``### In this repository`` block must hold the four labelled bullets in
+order, then one Bad and one Good example, with the Bad example still
+past 80 columns.
+
+Run ``--self-test`` to prove the checker can fail. ``--digest`` prints the
+SHA-256 of this file and of WRITING.md's shared example section (between
+``<!-- shared:examples -->`` and ``<!-- /shared:examples -->``), so a job
+that reads every port can confirm they still agree.
+"""
+
+from __future__ import annotations
+
+import argparse
+import dataclasses
+import hashlib
+import json
+import os
+import pathlib
+import re
+import subprocess
+import sys
+import typing as t
+import unicodedata
+
+try:
+    import tomllib
+except ModuleNotFoundError:  # tomllib is in the standard library from 3.11.
+    sys.exit("check_example_width.py needs Python 3.11 or newer")
+
+CONFIG = pathlib.PurePosixPath(".github/example-width.toml")
+KEYS = frozenset(
+    {
+        "width",
+        "tab_width",
+        "markdown",
+        "sources",
+        "doc_comments",
+        "exclude",
+        "allow",
+        "allow_ceiling",
+        "formatter_copies",
+        "shared_digest",
+        "checker_digest",
+    }
+)
+# Keys each [[table]] entry holds.
+TABLE_KEYS = {
+    "exclude": frozenset({"glob", "reason"}),
+    "allow": frozenset({"path", "line", "reason"}),
+    "formatter_copies": frozenset({"copy", "root", "key"}),
+}
+GLOB_KEYS = ("markdown", "sources", "doc_comments")
+# The reason the printed allow entry carries until someone writes a real one.
+PLACEHOLDER = "why breaking this line would make the example worse"
+# The type each top-level value must have; a TOML string where a list belongs
+# would otherwise be read one character at a time.
+VALUE_TYPES: dict[str, tuple[type, str]] = {
+    "width": (int, "an integer"),
+    "tab_width": (int, "an integer"),
+    "allow_ceiling": (int, "an integer"),
+    "shared_digest": (str, "a string"),
+    "checker_digest": (str, "a string"),
+}
+CODE_DIRECTIVES = frozenset({"code-block", "code", "code-cell", "sourcecode"})
+# gp-libs hides a doctest line carrying this directive from the rendered page.
+HIDDEN = re.compile(r"^\s*(?:>>>|\.\.\.) .*# doctest: \+HIDE\b")
+OUTPUT_TAGS = frozenset({"text"})
+# Fences that mix prompted commands with the output they print.
+SESSION_TAGS = frozenset({"console", "shell-session", "pycon"})
+# Fences of shell script, with no prompts and no output.
+SCRIPT_TAGS = frozenset({"sh", "bash", "zsh", "shell", "powershell", "pwsh", "ps1"})
+# A Python fence that opens with a doctest prompt is a session too.
+PYTHON_TAGS = frozenset({"python", "py", "python3"})
+PROMPTS = ("$ ", "PS> ", ">>> ", "... ")
+# Shell words that open and close a block a command continues through.
+SHELL_OPEN = frozenset({"if", "for", "while", "until", "case", "select"})
+SHELL_CLOSE = frozenset({"fi", "done", "esac"})
+HEREDOC = re.compile(r"(?<!<)<<-?[ \t]*(['\"]?)(?P<word>[A-Za-z_]\w*)\1")
+# A reST line that opens an indented code block: a paragraph ending in
+# ``::`` or a code directive. Other directives, such as toctree, hold no code.
+REST_BLOCK = re.compile(
+    r"^\s*(?!\.\. )\S.*::\s*$|^\s*\.\. (code-block|code|sourcecode)::"
+)
+FENCE = re.compile(r"^(?P<indent>\s*)(?P<mark>`{3,}|~{3,})\s*(?P<info>[^`]*)$")
+RUSTDOC_TAGS = frozenset({"rust", "no_run", "ignore", "should_panic", "compile_fail"})
+SHARED = re.compile(
+    r"<!-- shared:examples -->\n(?P<body>.*?)<!-- /shared:examples -->", re.DOTALL
+)
+DOC_LINE = re.compile(r"^\s*(?:///|//!|\*(?!/)|#'|--- ?)\s?")
+# Files under examples/ with no text lines to measure.
+BINARY = (
+    ".png",
+    ".jpg",
+    ".jpeg",
+    ".gif",
+    ".ico",
+    ".webp",
+    ".pdf",
+    ".woff",
+    ".woff2",
+    ".ttf",
+    ".zip",
+    ".gz",
+    ".tar",
+    ".wasm",
+    ".so",
+    ".dll",
+    ".exe",
+    ".jar",
+    ".class",
+    ".bin",
+    ".dylib",
+    ".a",
+    ".o",
+    ".db",
+    ".sqlite",
+)
+# Comments a test compares or a copy step reads: Go's `// Output:` and
+# `// docs:` lines, java's `// →` results, and region markers.
+MARKER = re.compile(
+    r"(?:Output:|Unordered output:|docs:|→|#?(?:end)?region\b)", re.IGNORECASE
+)
+# Shell and PowerShell scripts, whose lines continue the way a console command does.
+SCRIPTS = (".sh", ".bash", ".zsh", ".ps1", ".psm1")
+# Go marks doc-comment code with a tab after a bare //.
+GO_DOC = re.compile(r"^\s*//\t")
+DOCTEST = re.compile(r"(?:>>>|\.\.\.) ")
+BLOCK_OPEN = re.compile(r"<pre>\s*\{@code|<code>\s*$")
+BLOCK_CLOSE = re.compile(r"\}\s*</pre>|^\s*</code>")
+URL = re.compile(r"^(?:(?:#+|//+!?|-+|\*|>|<!--)\s*)?<?[a-z][a-z0-9+.-]*://\S+$")
+EXAMPLE_DIR = re.compile(r"(^|/)examples/", re.IGNORECASE)
+HEADING = re.compile(r"^(#{1,6}) (.+)$", re.MULTILINE)
+# A Markdown link target: [text](target).
+LINK = re.compile(
+    r"""(?<![!\\])\[[^\[\]]*\]\(<?([^)\s>]+)>?(?:\s+(?:"[^"]*"|'[^']*'))?\)"""
+    r"""|^\s*\[[^\]]+\]:\s*<?([^\s>]+)>?""",
+    re.MULTILINE,
+)
+PORT_BLOCK = re.compile(
+    r"^### In this repository\n(?P<body>.*?)(?=^#{1,3} |\Z)", re.MULTILINE | re.DOTALL
+)
+PORT_LABELS = (
+    "- **Hard limit:**",
+    "- **Not formatted:**",
+    "- **Runs, compiles, exempt:**",
+    "- **Compared output and copied blocks:**",
+)
+# Where every port lists its copy, so a digest change reaches all of them.
+PORTS = "PORTS in libtmux/docs scripts/check_shared_examples.py"
+
+
+def fence_tag(info: str) -> str:
+    """Return a fence's language, reading past a MyST ``{directive}``.
+
+    >>> fence_tag("rust,no_run")
+    'rust'
+    >>> fence_tag("{code-block} python")
+    'python'
+    >>> [fence_tag(f"{{{d}}} sh") for d in ("code", "code-cell", "sourcecode")]
+    ['sh', 'sh', 'sh']
+    >>> fence_tag("{note}")
+    'text'
+    >>> fence_tag("")
+    ''
+    """
+    words = info.strip().lower().split()
+    if words and words[0].startswith("{"):
+        if words[0].strip("{}") not in CODE_DIRECTIVES:
+            return "text"
+        words = words[1:]
+    return words[0].split(",")[0] if words else ""
+
+
+@dataclasses.dataclass(frozen=True)
+class Finding:
+    """One line wider than the configured width."""
+
+    path: str
+    number: int
+    columns: int
+    width: int
+    # The line as an allow entry must quote it.
+    text: str = ""
+    # Where the line sits, which decides the fix: "command" (a console
+    # command), "note" (a comment above one), "promptless" (a console fence
+    # with no prompt), "doc" (code in a doc comment), "source" (an example
+    # program), or "" (other code in Markdown).
+    kind: str = ""
+
+    def __str__(self) -> str:
+        """Render as ``path:line: width > limit``.
+
+        >>> print(Finding("README.md", 3, 90, 80))
+        README.md:3: 90 columns > 80
+        """
+        return f"{self.path}:{self.number}: {self.columns} columns > {self.width}"
+
+
+def columns(text: str) -> int:
+    """Return the columns a line occupies; wide characters take two.
+
+    >>> columns("abc")
+    3
+    >>> columns("日本")
+    4
+    """
+    return sum(2 if unicodedata.east_asian_width(c) in "WF" else 1 for c in text)
+
+
+def is_url(text: str) -> bool:
+    """Return whether a line is one URL, which cannot be broken.
+
+    >>> is_url("    https://example.com/" + "x" * 90)
+    True
+    >>> is_url("// <https://example.com/a>")
+    True
+    >>> is_url('let body=reqwest::get("https://example.com/").await?;')
+    False
+    >>> is_url("server.sessions().stream().filter(s->s.isAttached()).toList()")
+    False
+    """
+    return bool(URL.match(text.strip()))
+
+
+class Shell(t.NamedTuple):
+    """What a shell command still holds open at the end of a line."""
+
+    dialect: str = "$ "
+    quote: str | None = None
+    heredoc: str | None = None
+    depth: int = 0
+
+
+def other_continuation(code: str, dialect: str) -> bool:
+    r"""Return whether a line ends with the other shell's continuation.
+
+    A ``$ `` line ending in an unpaired backtick, or a ``PS> `` line ending
+    in a ``\`` after a space, continues the way the other shell would.
+
+    >>> other_continuation("$ ls `", "$ "), other_continuation("$ echo `date`", "$ ")
+    (True, False)
+    >>> ps = "PS> "
+    >>> other_continuation("PS> dir \\", ps), other_continuation("PS> cd C:\\", ps)
+    (True, False)
+    """
+    if dialect == "$ ":
+        return code.endswith("`") and code.count("`") % 2 == 1
+    return code.endswith(" \\")
+
+
+def scan(text: str, state: Shell) -> tuple[str | None, str, bool, int]:
+    r"""Return a line's open quote, unquoted text, trailing escape and comment.
+
+    A backslash (a backtick in PowerShell) escapes the next character
+    outside single quotes, and an unquoted # starts a comment, so the last
+    value is where the code ends:
+
+    >>> scan('echo "a # b" `', Shell()), scan("ls  # see `ls`", Shell())
+    ((None, 'echo  `', False, 14), (None, 'ls  ', False, 4))
+    >>> scan("'it", Shell()), scan("dir `", Shell("PS> "))
+    (("'", '', False, 3), (None, 'dir ', True, 5))
+    """
+    escape = "\\" if state.dialect == "$ " else "`"
+    quote, plain, escaped, cut = state.quote, [], False, len(text)
+    for index, char in enumerate(text):
+        if escaped:
+            escaped = False
+            if quote is None:
+                plain.append(char)
+        elif char == escape and quote != "'":
+            escaped = True
+        elif (
+            quote is None and char == "#" and (index == 0 or text[index - 1].isspace())
+        ):
+            cut = index
+            break
+        elif quote is None and char in "'\"":
+            quote = char
+        elif char == quote:
+            quote = None
+        elif quote is None:
+            plain.append(char)
+    return quote, "".join(plain), escaped, cut
+
+
+def shell_after(line: str, state: Shell, following: str | None = None) -> Shell | None:
+    r"""Return what the command holds open after a line, or None if it ended.
+
+    A command goes on past an open quote, an open heredoc, a ``\`` or
+    backtick, a trailing pipe, ``&&`` or ``||``, and an unclosed loop,
+    conditional or brace block:
+
+    >>> def after(lines: list[str]) -> Shell | None:
+    ...     state = None
+    ...     for line in lines:
+    ...         state = shell_after(line, state or Shell())
+    ...     return state
+    >>> after(["$ julia -e 'using Pkg"]).quote
+    "'"
+    >>> after(["$ julia -e 'using Pkg", "Pkg.add(1)'"]) is None
+    True
+    >>> after(["$ for pane in a b; do", "  echo $pane"]).depth
+    1
+    >>> after(["$ for pane in a b; do", "  echo $pane", "done"]) is None
+    True
+    >>> opens = ["if x; then", "while x; do", "until x; do", "case x in"]
+    >>> opens.append("select x in a; do")
+    >>> [after([f"$ {line}", "  y"]).depth for line in opens]
+    [1, 1, 1, 1, 1]
+    >>> [after(["$ if x; then", "  y", "fi"]), after(["$ case x in", "esac"])]
+    [None, None]
+    >>> after(["$ make &&"]) is None, after(["$ echo $("]) is None
+    (False, False)
+    >>> after(["$ cat <<EOF", "... a line"]).heredoc
+    'EOF'
+    >>> after(["$ cat <<-EOF", "\tbody"]).heredoc, after(["$ cat <<-EOF", "\tEOF"])
+    ('EOF', None)
+    >>> after(["$ git commit -F - <<'EOF'", 'say "hi'])
+    Shell(dialect='$ ', quote=None, heredoc='EOF', depth=0)
+    >>> after(["$ git commit -F - <<'EOF'", 'say "hi', "EOF"]) is None
+    True
+    >>> after(["PS> if ($x) {", "  Get-Item"]).depth
+    1
+    >>> after(["PS> if ($x) {", "  Get-Item", "}"]) is None
+    True
+    >>> after(['$ echo "a b" | tr a b']) is None
+    True
+    >>> after(["$ ls  # a comment ending in {"]) is None
+    True
+    >>> after(["$ ls  # don't"]) is None, after([r"$ echo it\'s"]) is None
+    (True, True)
+    >>> after(["$ ls |"]) is None, after(["$ ls |", "  grep x"]) is None
+    (False, True)
+    >>> after(["$ ls `"]) is None, after(["PS> Get-Item \\"]) is None
+    (False, False)
+    >>> after(["$ ls \\"]) is None, after(["PS> Get-Item `"]) is None
+    (False, False)
+
+    A ``<<`` inside quotes or arithmetic opens no heredoc, and a ``\`` after
+    ``PS> `` names a path unless an indented line follows it:
+
+    >>> after(['$ echo "type <<EOF to start"']), after(["$ echo $((x<<y))"])
+    (None, None)
+    >>> shell_after("PS> Get-ChildItem \\", Shell("PS> "), "")
+    >>> shell_after("PS> Get-ChildItem \\", Shell("PS> "), "    -Force").dialect
+    'PS> '
+    >>> shell_after("PS> Get-ChildItem \\", Shell("PS> "), "    ") is None
+    True
+    """
+    text = line.lstrip()
+    # A prompt-like line inside a heredoc, quote or block is that command's text.
+    held = state.heredoc or state.quote or state.depth
+    if text.startswith((">>> ", "... ")) and not held:
+        return None
+    if state.heredoc is not None:
+        if line.strip() == state.heredoc:
+            state = state._replace(heredoc=None)
+            return state if state.quote or state.depth else None
+        return state
+    for prompt in ("$ ", "PS> "):
+        if text.startswith(prompt):
+            state, text = Shell(dialect=prompt), text[len(prompt) :]
+    quote, bare, escaped, cut = scan(text, state)
+    depth = state.depth
+    for segment in re.split(r"[;&|()]", bare):
+        words = segment.split()
+        if state.dialect == "$ " and words and words[0] in SHELL_OPEN:
+            depth += 1
+        if state.dialect == "$ " and words and words[0] in SHELL_CLOSE:
+            depth -= 1
+        depth += sum(w.endswith("{") for w in words)
+        depth -= sum(w.startswith("}") for w in words)
+    arithmetic = re.sub(r"\(\(.*?\)\)", lambda m: " " * len(m[0]), text[:cut])
+    opened = [
+        m["word"]
+        for m in HEREDOC.finditer(arithmetic)
+        if scan(text[: m.start()], state)[0] is None
+    ]
+    heredoc = opened[0] if opened else None
+    state = Shell(state.dialect, quote, heredoc, max(depth, 0))
+    # A trailing \ or backtick continues the command under either prompt, so
+    # a line continued the other shell's way is still measured.
+    tail = text[:cut].rstrip()
+    other = other_continuation(tail, state.dialect)
+    if other and state.dialect == "PS> " and following is not None:
+        other = following[:1].isspace() and bool(following.strip())
+    ends = escaped or other
+    ends = ends or bare.rstrip().endswith(("|", "&&", "("))
+    return state if quote or state.heredoc or state.depth or ends else None
+
+
+LIST_ITEM = re.compile(r"^\s*([-*+]|\d+[.)])\s")
+
+
+def indent_code(line: str) -> bool:
+    """Return whether a Markdown line is indented far enough to be code."""
+    return line.startswith(("    ", "\t"))
+
+
+def depth(line: str) -> int:
+    """Return the column a Markdown line's text starts at, tabs stopping at 4."""
+    expanded = line.expandtabs(4)
+    return len(expanded) - len(expanded.lstrip())
+
+
+def has_prompt(lines: list[str], mark: str) -> bool:
+    """Return whether a session fence holds a prompt before it closes.
+
+    >>> has_prompt(["$ ls", "```"], "```"), has_prompt(["ls", "```", "$ x"], "```")
+    (True, False)
+    """
+    for line in lines:
+        match = FENCE.match(line)
+        if match and match["mark"].startswith(mark) and not match["info"].strip():
+            return False
+        if line.lstrip().startswith(PROMPTS):
+            return True
+    return False
+
+
+def comments_a_command(lines: list[str], mark: str) -> bool:
+    """Return whether ``# `` lines lead to a prompt before the fence closes.
+
+    A comment above a console command is code a reader copies; a ``# `` line
+    among a command's output is output.
+
+    >>> comments_a_command(["# and", "$ ls", "```"], "```")
+    True
+    >>> comments_a_command(["more output", "```"], "```"), comments_a_command([], "`")
+    (False, False)
+    """
+    for line in lines:
+        match = FENCE.match(line)
+        if match and match["mark"].startswith(mark) and not match["info"].strip():
+            return False
+        stripped = line.lstrip()
+        if not stripped.startswith("# "):
+            return stripped.startswith(PROMPTS)
+    return False
+
+
+def doctest_first(lines: list[str], mark: str) -> bool:
+    """Return whether a fence's first code line is a ``>>>`` doctest prompt.
+
+    >>> doctest_first(["", ">>> 1 + 1", "2", "```"], "```")
+    True
+    >>> doctest_first(["x = 1", ">>> x", "```"], "```")
+    False
+    """
+    for line in lines:
+        match = FENCE.match(line)
+        if match and match["mark"].startswith(mark) and not match["info"].strip():
+            return False
+        if line.strip():
+            return line.lstrip().startswith(">>> ")
+    return False
+
+
+def selected(config: dict[str, t.Any], path: str) -> bool:
+    """Return whether a glob key of the config selects a path.
+
+    >>> selected({"sources": ["examples/*.rs"]}, "examples/a.rs")
+    True
+    >>> selected({"sources": ["examples/*.rs"]}, "examples/a.toml")
+    False
+    """
+    return matches(path, [g for key in GLOB_KEYS for g in config.get(key, [])])
+
+
+def untracked_matches(config: dict[str, t.Any], untracked: list[str]) -> list[str]:
+    """Return untracked files the check would read once git tracks them.
+
+    >>> untracked_matches({"markdown": ["*.md"]}, ["new.md", "build.log"])
+    ['new.md']
+    >>> excluded = {"exclude": [{"glob": "examples/x/**", "reason": "r"}]}
+    >>> untracked_matches(excluded, ["examples/new.rs", "examples/x/y.rs"])
+    ['examples/new.rs']
+    """
+    read = [g for key in GLOB_KEYS for g in config.get(key, [])]
+    skip = [entry["glob"] for entry in entries(config, "exclude")]
+    return [
+        path
+        for path in untracked
+        if (matches(path, read) or EXAMPLE_DIR.search(path)) and not matches(path, skip)
+    ]
+
+
+def markdown_lines(
+    text: str, indented: bool = True, kinds: dict[int, str] | None = None
+) -> list[tuple[int, str]]:
+    r"""Return the code lines of the fences a reader runs or copies.
+
+    Output fences are skipped, and so are the lines a ``console`` block
+    prints after its ``$`` commands. An untagged fence counts as code.
+
+    >>> doc = "\n".join([
+    ...     "```rust", "let a = 1;", "```",
+    ...     "```text", "output", "```",
+    ...     "```", "untagged();", "```",
+    ...     "```console", "$ cargo test \\", "    --doc", "ok", "```",
+    ... ])
+    >>> [line for _, line in markdown_lines(doc)]
+    ['let a = 1;', 'untagged();', '$ cargo test \\', '    --doc']
+    >>> rust = "```rust\n# let hidden = 1;\nlet shown = 2;\n```"
+    >>> [line for _, line in markdown_lines(rust)]
+    ['let shown = 2;']
+    >>> session = "```{}\n$ ls\nout\n```"
+    >>> [markdown_lines(session.format(t)) for t in ("console", "shell-session")]
+    [[(2, '$ ls')], [(2, '$ ls')]]
+    >>> doctest = "```{}\n>>> for x in y:\n...     f(x)\nout\n```"
+    >>> [len(markdown_lines(doctest.format(t))) for t in ("pycon", "py", "python3")]
+    [2, 2, 2]
+    >>> hidden = "```{}\n# hidden()\nshown()\n```"
+    >>> tags = ("no_run", "ignore", "should_panic", "compile_fail")
+    >>> [markdown_lines(hidden.format(t)) for t in tags]
+    [[(3, 'shown()')], [(3, 'shown()')], [(3, 'shown()')], [(3, 'shown()')]]
+    >>> markdown_lines("~~~text\nout\n~~~\n~~~sh\nls\n~~~")
+    [(5, 'ls')]
+    >>> myst = "```{code-block} text\nplain output\n```"
+    >>> markdown_lines(myst)
+    []
+    >>> ps = "```console\nPS> Get-Item `\n    -Path x\nok\n```"
+    >>> [line for _, line in markdown_lines(ps)]
+    ['PS> Get-Item `', '    -Path x']
+    >>> quoted = "```console\n$ julia -e '\n    using Pkg'\nok\n```"
+    >>> [line for _, line in markdown_lines(quoted)]
+    ["$ julia -e '", "    using Pkg'"]
+    >>> listing = "```console\nPS> Get-ChildItem \\\n\n    Directory: C:\\\n```"
+    >>> [line for _, line in markdown_lines(listing)]
+    ['PS> Get-ChildItem \\']
+    >>> noted = "```console\n# Install the tool\n$ ls\n# not a note\n```"
+    >>> [line for _, line in markdown_lines(noted)]
+    ['# Install the tool', '$ ls']
+    >>> kinds: dict[int, str] = {}
+    >>> build = "```console\n# Build\n$ cmake \\\n    -DX=1\nok\n```"
+    >>> _ = markdown_lines(build, True, kinds)
+    >>> kinds
+    {2: 'note', 3: 'command', 4: 'command'}
+    >>> data: dict[int, str] = {}
+    >>> heredoc = "```console\n$ cat <<EOF\nbody\nEOF\n>>> x\n```"
+    >>> _ = markdown_lines(heredoc, True, data)
+    >>> [n for n, kind in data.items() if kind == "command"], data[3]
+    ([2], 'session')
+    >>> bare: dict[int, str] = {}
+    >>> _ = markdown_lines("```console\ncargo test\n```", True, bare)
+    >>> bare
+    {2: 'promptless'}
+    >>> script: dict[int, str] = {}
+    >>> _ = markdown_lines("```bash\nmake all\n```", True, script)
+    >>> script
+    {2: 'script'}
+
+    A ``console`` block with no prompt line holds no output to skip, so it is
+    measured as code:
+
+    >>> bare = "```console\ncargo test --doc\n```"
+    >>> [line for _, line in markdown_lines(bare)]
+    ['cargo test --doc']
+    >>> pydoc = "```python\n>>> pane.capture()\n['output line']\n```"
+    >>> [line for _, line in markdown_lines(pydoc)]
+    ['>>> pane.capture()']
+
+    A ``text`` fence that opens with a prompt is a console session, and an
+    indented code block or a ``<pre>`` block outside a list is code:
+
+    >>> prompted = "```text\n$ ls -l\ntotal 0\n```"
+    >>> [line for _, line in markdown_lines(prompted)]
+    ['$ ls -l']
+    >>> markdown_lines("## Setup\n    make\nText\n    more text")
+    [(2, '    make')]
+    >>> markdown_lines("Text\n```sh\nls\n```\n    make")
+    [(3, 'ls'), (5, '    make')]
+    >>> page = "Before:\n\n    new Server()\n\n- item\n\n    more of the item"
+    >>> [line for _, line in markdown_lines(page)]
+    ['    new Server()']
+    >>> [line for _, line in markdown_lines("1. item\n\n       code()\n   text")]
+    ['       code()']
+    >>> [line for _, line in markdown_lines("<pre><code>run()\n</code></pre>")]
+    ['<pre><code>run()', '</code></pre>']
+    """
+    found: list[tuple[int, str]] = []
+    fence: tuple[str, str] | None = None
+    first = promptless = False
+    shell: Shell | None = None
+    blank, in_list, in_block, in_pre = True, False, False, False
+    content = 0
+    lines = text.splitlines()
+    for number, line in enumerate(lines, 1):
+        match = FENCE.match(line)
+        if fence is None and match:
+            fence = (match["mark"], fence_tag(match["info"]))
+            if fence[1] in PYTHON_TAGS and doctest_first(lines[number:], fence[0]):
+                fence = (fence[0], "pycon")
+            promptless = fence[1] in SESSION_TAGS
+            if promptless and not has_prompt(lines[number:], fence[0]):
+                fence = (fence[0], "sh")
+            promptless = promptless and fence[1] == "sh"
+            first, shell, in_block = True, None, False
+            continue
+        if fence is None:
+            if not indented:
+                continue
+            stripped = line.strip()
+            if in_pre or stripped.startswith("<pre"):
+                found.append((number, line))
+                in_pre = "</pre>" not in line
+            elif not stripped:
+                blank = True
+                continue
+            elif item := LIST_ITEM.match(line):
+                in_list, in_block = True, False
+                # Content starts after the marker and up to four spaces; more
+                # than that and the extra spaces open an indented block.
+                gap = len(line) - item.end() - len(line[item.end() :].lstrip(" "))
+                content = item.end() + (gap if gap < 4 else 0)
+            elif indent_code(line) and not in_list and (blank or in_block):
+                found.append((number, line))
+                in_block = True
+            elif in_list and (blank or in_block) and depth(line) >= content + 4:
+                # Four columns past a list item's content is code in the item.
+                found.append((number, line))
+                in_block = True
+            else:
+                in_list = in_list and line.startswith((" ", "\t"))
+                in_block = False
+            # Only a paragraph keeps an indented line from starting code.
+            blank = bool(HEADING.match(line))
+            continue
+        if match and match["mark"].startswith(fence[0]) and not match["info"].strip():
+            fence, blank = None, True
+            continue
+        if first and line.strip():
+            first = False
+            if fence[1] in OUTPUT_TAGS and line.lstrip().startswith(("$ ", "PS> ")):
+                fence = (fence[0], "console")
+        tag = fence[1]
+        if tag in OUTPUT_TAGS:
+            continue
+        if tag in RUSTDOC_TAGS and (
+            line.strip() == "#" or line.lstrip().startswith("# ")
+        ):
+            continue
+        kind = "promptless" if promptless else "script" if tag in SCRIPT_TAGS else ""
+        if tag in SESSION_TAGS:
+            prompt = line.lstrip().startswith(PROMPTS)
+            note = not (prompt or shell) and line.lstrip().startswith("# ")
+            note = note and comments_a_command(lines[number:], fence[0])
+            if not (prompt or shell or note):
+                continue
+            kind = "note" if note else ""
+            if not note:
+                # A line inside a quote or heredoc is data, which a shell
+                # continuation would change.
+                level = line.lstrip().startswith(("$ ", "PS> ")) or bool(
+                    shell and not (shell.quote or shell.heredoc)
+                )
+                following = lines[number] if number < len(lines) else ""
+                shell = shell_after(line, shell or Shell(), following)
+                kind = "command" if level else "session"
+        if kinds is not None and kind:
+            kinds[number] = kind
+        found.append((number, line))
+    return found
+
+
+def prompt_mismatches(text: str) -> list[tuple[int, str]]:
+    r"""Return lines that continue a command the other shell's way.
+
+    A ``$ `` command continues with ``\``, a ``PS> `` one with a backtick.
+
+    >>> prompt_mismatches("```console\n$ ls `\n  -l\nPS> dir \\\n  -x\n```")
+    [(2, '$ '), (4, 'PS> ')]
+    >>> prompt_mismatches("```console\n$ ls \\\n  -l\nPS> dir `\n  -x\n```")
+    []
+    >>> prompt_mismatches("```console\n$ ls\n```\n```go\nName string `json`\n```")
+    []
+    >>> prompt_mismatches("```console\n$ echo `date`\n$ ls  # see `ls`\n```")
+    []
+    >>> prompt_mismatches("```console\n$ ls `\n  -l `\n  -a\n```")
+    [(2, '$ ')]
+
+    Only a line the command goes on to is a continuation, so a ``\`` that
+    names a path, or a ``#`` inside quotes, is read as code:
+
+    >>> prompt_mismatches("```console\nPS> cd \\\nPS> dir\n```")
+    []
+    >>> prompt_mismatches("```console\n$ echo '# a' `\n  -n\n```")
+    [(2, '$ ')]
+    >>> prompt_mismatches("```console\n$ echo 'a `\n  b'\n```")
+    []
+    >>> prompt_mismatches("```console\nPS> Get-ChildItem \\\nName\n```")
+    []
+    >>> blank = "```console\nPS> Get-ChildItem \\\n\n    Directory: C:\\\n```"
+    >>> prompt_mismatches(blank), prompt_mismatches(blank.replace("\n\n", "\n"))
+    ([], [(2, 'PS> ')])
+    """
+    found: list[tuple[int, str]] = []
+    state: Shell | None = None
+    pending: tuple[int, str] | None = None
+    last = first = 0
+    for number, line in markdown_lines(text):
+        stripped = line.lstrip()
+        prompt = stripped.startswith(("$ ", "PS> "))
+        if pending and number == last + 1 and not prompt and pending not in found:
+            found.append(pending)
+        pending = None
+        if prompt:
+            state = Shell(dialect=stripped[: stripped.index(" ") + 1])
+            first = number
+        elif state is None or number != last + 1:
+            state = None
+            continue
+        dialect, last = state.dialect, number
+        quote, _, _, cut = scan(line, state)
+        if quote is None and other_continuation(line[:cut].rstrip(), dialect):
+            pending = (first, dialect)
+        state = shell_after(line, state)
+    return found
+
+
+def prompt_problems(
+    root: pathlib.Path, config: dict[str, t.Any], files: list[str]
+) -> list[str]:
+    """Return console commands in Markdown and doc comments continued wrongly."""
+    skip = [entry["glob"] for entry in entries(config, "exclude")]
+    fix = {
+        "$ ": "this `$ ` command is continued with a backtick; end the line with "
+        "`\\` instead, or use a `PS> ` prompt for a PowerShell command",
+        "PS> ": "this `PS> ` command is continued with `\\`; end the line with a "
+        "backtick instead, or, if `\\` ends a path, keep the blank line PowerShell "
+        "prints between the command and its output",
+    }
+    problems = []
+    for path in files:
+        markdown = matches(path, config.get("markdown", []))
+        doc = not markdown and matches(path, config.get("doc_comments", []))
+        if not (markdown or doc) or matches(path, skip) or path.endswith(".rst"):
+            continue
+        try:
+            text = (root / path).read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        found: list[tuple[int, str]] = []
+        if doc:
+            doc_comment_lines(text, pathlib.PurePath(path).suffix, prompts=found)
+        else:
+            found = prompt_mismatches(text)
+        problems += [f"{path}:{n}: {fix[d]}" for n, d in found]
+    return problems
+
+
+def rest_block_lines(text: str) -> list[tuple[int, str]]:
+    r"""Return the lines of reST literal and code-directive blocks.
+
+    A block is every line indented past the line that opens it, up to the
+    next non-blank line at or left of that indent.
+
+    >>> doc = "Use it::\n\n    pane.run(1)\n\nProse.\n.. code-block:: sh\n\n   ls\n"
+    >>> [line for _, line in rest_block_lines(doc)]
+    ['    pane.run(1)', '   ls']
+    >>> rest_block_lines(".. toctree::\n\n   capture\n")
+    []
+    """
+    found: list[tuple[int, str]] = []
+    opener: int | None = None
+    for number, line in enumerate(text.splitlines(), 1):
+        indent = len(line) - len(line.lstrip())
+        if opener is not None and line.strip():
+            if indent > opener:
+                found.append((number, line))
+                continue
+            opener = None
+        if REST_BLOCK.search(line) and not line.lstrip().startswith((">>>", "...")):
+            opener = indent
+    return found
+
+
+def doc_comment_lines(
+    text: str,
+    suffix: str,
+    kinds: dict[int, str] | None = None,
+    prompts: list[tuple[int, str]] | None = None,
+) -> list[tuple[int, str]]:
+    r"""Return code inside doc comments: fences and ``{@code}``/``<code>``.
+
+    Python docstrings contribute their doctest lines and reST literal
+    blocks, Go doc comments their tab-indented code blocks, and Julia
+    docstrings their fences. A fence is read the way a Markdown page
+    reads it, so output, hidden rustdoc lines and the output in a console
+    session are skipped. A plain ``//`` comment is not a doc comment.
+
+    >>> src = "\n".join([
+    ...     "/// ```", "/// let wide = 1;", "/// # hidden();", "/// ```",
+    ...     "/// ```text", "/// output", "/// ```",
+    ...     "// ```", "// not a doc comment", "// ```",
+    ...     "/// prose is not code", "fn f() {}",
+    ... ])
+    >>> [line for _, line in doc_comment_lines(src, ".rs")]
+    ['/// let wide = 1;']
+    >>> cs = "/// <code>\n/// var x = 1;\n/// </code>\n/// prose"
+    >>> [line for _, line in doc_comment_lines(cs, ".cs")]
+    ['/// var x = 1;']
+    >>> py = '    >>> pane.send_keys("x")\n    plain prose'
+    >>> [line for _, line in doc_comment_lines(py, ".py")]
+    ['    >>> pane.send_keys("x")']
+    >>> literal = '    Example::\n\n        server.cmd("x")\n    Prose.'
+    >>> [line for _, line in doc_comment_lines(literal, ".py")]
+    ['        server.cmd("x")']
+    >>> go = "// Run starts a pane:\n//\tpane.Run(ctx)\nfunc Run() {}"
+    >>> [line for _, line in doc_comment_lines(go, ".go")]
+    ['//\tpane.Run(ctx)']
+    >>> java = " * <pre>{@code\n * pane.run();\n * }</pre>\n * prose"
+    >>> [line for _, line in doc_comment_lines(java, ".java")]
+    [' * pane.run();']
+    >>> tsdoc = " * ```ts\n * pane.run();\n * ```\n * prose"
+    >>> [line for _, line in doc_comment_lines(tsdoc, ".ts")]
+    [' * pane.run();']
+    >>> rs = "/// ```console\n/// $ cargo run\n/// " + "x" * 90 + "\n/// ```"
+    >>> [line for _, line in doc_comment_lines(rs, ".rs")]
+    ['/// $ cargo run']
+    >>> fence = ["```console", "$ ls `", "    -l", "# note", "$ ls", "```"]
+    >>> console = "\n".join("/// " + line for line in fence)
+    >>> data: dict[int, str] = {}
+    >>> wrong: list[tuple[int, str]] = []
+    >>> _ = doc_comment_lines(console, ".rs", data, wrong)
+    >>> data, wrong
+    ({2: 'doc:command', 3: 'doc:command', 4: 'doc:note', 5: 'doc:command'}, [(2, '$ ')])
+    >>> data, wrong = {}, []
+    >>> jdoc = "```console\n$ julia `\n  -e 1\n```"
+    >>> _ = doc_comment_lines(jdoc, ".jl", data, wrong)
+    >>> data, wrong
+    ({2: 'doc:command', 3: 'doc:command'}, [(2, '$ ')])
+    >>> hidden = "/// ```\n/// # use std::io;\n/// let x = 1;\n/// ```"
+    >>> [line for _, line in doc_comment_lines(hidden, ".rs")]
+    ['/// let x = 1;']
+    >>> jl = "    f(x)\n\nRun it:\n\n```julia\nf(1)\n```"
+    >>> [line for _, line in doc_comment_lines(jl, ".jl")]
+    ['f(1)']
+    """
+    if suffix == ".jl":
+        local: dict[int, str] = {}
+        lines = markdown_lines(text, indented=False, kinds=local)
+        if kinds is not None:
+            kinds.update((n, "doc:" + kind) for n, kind in local.items())
+        if prompts is not None:
+            prompts.extend(prompt_mismatches(text))
+        return lines
+    if suffix == ".py":
+        doctests = [
+            (number, line)
+            for number, line in enumerate(text.splitlines(), 1)
+            if line.lstrip().startswith((">>> ", "... "))
+        ]
+        return sorted(set(doctests + rest_block_lines(text)))
+    found: list[tuple[int, str]] = []
+    inside = False
+    fenced: list[tuple[int, str, str]] | None = None
+    info = ""
+
+    def flush() -> None:
+        if fenced:
+            block = "\n".join([f"```{info}", *[b for _, _, b in fenced], "```"])
+            # The fence's lines carry their Markdown kind, so a console line
+            # in a doc comment is advised as one.
+            local: dict[int, str] = {}
+            kept = {n for n, _ in markdown_lines(block, indented=False, kinds=local)}
+            for i, (n, line, _) in enumerate(fenced, 2):
+                if i in kept:
+                    found.append((n, line))
+                    if kinds is not None and i in local:
+                        kinds[n] = "doc:" + local[i]
+            if prompts is not None:
+                prompts.extend(
+                    (fenced[i - 2][0], d) for i, d in prompt_mismatches(block)
+                )
+
+    for number, line in enumerate(text.splitlines(), 1):
+        if suffix == ".go":
+            if line.lstrip().startswith("//\t"):
+                found.append((number, line))
+            continue
+        if BLOCK_OPEN.search(line):
+            inside = not BLOCK_CLOSE.search(line)
+            continue
+        prefix = DOC_LINE.match(line)
+        if prefix is None:
+            flush()
+            inside, fenced = False, None
+            continue
+        body = line[prefix.end() :]
+        fence = FENCE.match(body)
+        if fenced is not None:
+            if fence and not fence["info"].strip():
+                flush()
+                fenced = None
+            else:
+                fenced.append((number, line, body))
+            continue
+        if fence:
+            # rustdoc runs an untagged fence as Rust.
+            info = fence["info"].strip() or ("rust" if suffix == ".rs" else "")
+            fenced = []
+            continue
+        if inside and BLOCK_CLOSE.search(body):
+            inside = False
+            continue
+        if inside:
+            found.append((number, line))
+    flush()
+    return found
+
+
+def glob_regex(pattern: str) -> re.Pattern[str]:
+    """Translate a glob: ``*`` stays within a directory, ``**`` spans them.
+
+    >>> bool(glob_regex("docs/*.md").fullmatch("docs/plans/a.md"))
+    False
+    >>> bool(glob_regex("docs/**/*.md").fullmatch("docs/a.md"))
+    True
+    """
+    out = []
+    i = 0
+    while i < len(pattern):
+        if pattern.startswith("**/", i):
+            out.append("(?:.*/)?")
+            i += 3
+        elif pattern.startswith("**", i):
+            out.append(".*")
+            i += 2
+        elif pattern[i] == "*":
+            out.append("[^/]*")
+            i += 1
+        elif pattern[i] == "?":
+            out.append("[^/]")
+            i += 1
+        else:
+            out.append(re.escape(pattern[i]))
+            i += 1
+    return re.compile("".join(out))
+
+
+def matches(path: str, patterns: list[str]) -> bool:
+    """Return whether a repository-relative path matches any glob.
+
+    >>> matches("README.md", ["**/README.md"])
+    True
+    >>> matches("docs/a/b.md", ["docs/**/*.md"])
+    True
+    >>> matches("src/a.rs", ["docs/**/*.md"])
+    False
+    """
+    return any(glob_regex(pattern).fullmatch(path) for pattern in patterns)
+
+
+def allow_hint(finding: Finding) -> str:
+    r"""Return an ``[[allow]]`` entry for a finding, ready to paste.
+
+    JSON string escapes are valid TOML basic-string escapes, so a tab or a
+    quote in the line survives the copy.
+
+    >>> print(allow_hint(Finding("main.go", 3, 90, 80, '\tx := "y"')))
+    [[allow]]
+    path = "main.go"
+    line = "\tx := \"y\""
+    reason = "why breaking this line would make the example worse"
+    """
+    return "\n".join(
+        [
+            "[[allow]]",
+            f"path = {json.dumps(finding.path, ensure_ascii=False)}",
+            f"line = {json.dumps(finding.text, ensure_ascii=False)}",
+            f"reason = {json.dumps(PLACEHOLDER)}",
+        ]
+    )
+
+
+def plural(count: int, one: str, many: str | None = None) -> str:
+    """Return a count with its noun in the matching number.
+
+    >>> plural(1, "wide line"), plural(2, "wide line")
+    ('1 wide line', '2 wide lines')
+    """
+    return f"{count} {one if count == 1 else (many or one + 's')}"
+
+
+def literal(value: t.Any) -> str:
+    """Return a config value as TOML writes it, for a message to quote.
+
+    >>> literal(True), literal("80"), literal(["a", 5]), literal({"glob": "x"})
+    ('true', '"80"', '["a", 5]', '{glob = "x"}')
+    """
+    if isinstance(value, bool):
+        return "true" if value else "false"
+    if isinstance(value, str):
+        return json.dumps(value)
+    if isinstance(value, list):
+        return "[" + ", ".join(literal(item) for item in value) + "]"
+    if isinstance(value, dict):
+        pairs = ", ".join(f"{key} = {literal(item)}" for key, item in value.items())
+        return "{" + pairs + "}"
+    return str(value)
+
+
+def article(table: str) -> str:
+    """Return the article for a table name: an [[allow]], a [[formatter_copies]].
+
+    >>> article("allow"), article("exclude"), article("formatter_copies")
+    ('an', 'an', 'a')
+    """
+    return "an" if table[0] in "aeiou" else "a"
+
+
+def glob_key(path: str) -> str:
+    """Return the config key whose glob should select ``path``.
+
+    >>> [glob_key(f"a.{suffix}") for suffix in ("md", "markdown", "mdx", "rst", "rs")]
+    ['markdown', 'markdown', 'markdown', 'markdown', 'sources']
+    """
+    return (
+        "markdown" if path.endswith((".md", ".markdown", ".mdx", ".rst")) else "sources"
+    )
+
+
+def select_advice(path: str) -> str:
+    """Return how to select or exclude an unselected file under examples/.
+
+    >>> select_advice("examples/a.md")
+    'add "examples/a.md" to markdown, or to [[exclude]] with a reason'
+    >>> select_advice("examples/blob.bin").split("; ")[1]
+    'a binary file holds no lines'
+    >>> select_advice("examples/logo.png")
+    'add "examples/logo.png" to [[exclude]] with a reason; a binary file holds no lines'
+    """
+    if path.lower().endswith(BINARY):
+        return (
+            f'add "{path}" to [[exclude]] with a reason; a binary file holds no lines'
+        )
+    return f'add "{path}" to {glob_key(path)}, or to [[exclude]] with a reason'
+
+
+def syntax_hint(pattern: str) -> str:
+    """Return a note for a glob that uses syntax the check reads literally.
+
+    >>> syntax_hint("docs/{a,b}.md"), syntax_hint("docs/*.md")
+    ('; globs here take `*`, `**` and `?`, not `{a,b}` or `[...]`', '')
+    """
+    if re.search(r"[{\[]", pattern):
+        return "; globs here take `*`, `**` and `?`, not `{a,b}` or `[...]`"
+    return ""
+
+
+def misspelled(entry: dict[str, t.Any], key: str) -> bool:
+    """Return whether an entry carries an unknown key close to ``key``.
+
+    >>> misspelled({"reson": "r"}, "reason"), misspelled({"path": "a"}, "reason")
+    (True, False)
+    """
+    return any(nearest(other, {key}) for other in entry if other != key)
+
+
+def nearest(key: str, keys: t.Collection[str] = KEYS) -> str:
+    """Return a "did you mean" clause for a misspelled config key, or "".
+
+    >>> nearest("widht"), nearest("zzz"), nearest("reson", {"path", "reason"})
+    ('did you mean width? ', '', 'did you mean reason? ')
+    """
+    match = meant(key, keys)
+    return f"did you mean {match}? " if match else ""
+
+
+def meant(key: str, keys: t.Collection[str] = KEYS) -> str:
+    """Return the known key a misspelled one is closest to, or "".
+
+    >>> meant("allow_cieling"), meant("zzz")
+    ('allow_ceiling', '')
+    """
+    import difflib
+
+    match = difflib.get_close_matches(key, sorted(keys), n=1)
+    return match[0] if match else ""
+
+
+def suggest(key: str, keys: t.Collection[str], rest: str) -> str:
+    """Return the "did you mean" clause, if any, then the keys a table takes.
+
+    >>> suggest("widht", {"width"}, "the config takes width")
+    'did you mean width? The config takes width'
+    >>> suggest("zzz", {"width"}, "the config takes width")
+    'the config takes width'
+    """
+    hint = nearest(key, keys)
+    return hint + rest[:1].upper() + rest[1:] if hint else rest
+
+
+def type_problems(config: dict[str, t.Any]) -> list[str]:
+    """Return values whose type the check cannot use.
+
+    >>> for problem in type_problems({"width": "80", "markdown": "**/*.md"}):
+    ...     print(problem)
+    width must be an integer, not "80"
+    markdown must be a list of globs, not "**/*.md"
+    >>> type_problems({"width": 80, "markdown": ["**/*.md"], "exclude": []})
+    []
+    >>> type_problems({"exclude": [{"glob": 5, "reason": "r"}]})
+    ['glob in an [[exclude]] entry must be a string, not 5: {glob = 5, reason = "r"}']
+    >>> type_problems({"allow_ceiling": True})
+    ['allow_ceiling must be an integer, not true']
+    """
+    problems = [
+        f"{key} must be {name}, not {literal(config[key])}"
+        for key, (kind, name) in VALUE_TYPES.items()
+        if key in config
+        and (not isinstance(config[key], kind) or isinstance(config[key], bool))
+    ]
+    for key in GLOB_KEYS:
+        value = config.get(key, [])
+        if not isinstance(value, list) or not all(isinstance(g, str) for g in value):
+            problems.append(f"{key} must be a list of globs, not {literal(value)}")
+    problems.extend(
+        f"{table} must be written as [[{table}]] entries"
+        for table in TABLE_KEYS
+        if not isinstance(config.get(table, []), list)
+    )
+    for table, keys in TABLE_KEYS.items():
+        table_entries = config.get(table, [])
+        if not isinstance(table_entries, list):
+            continue
+        problems.extend(
+            f"{key} in {article(table)} [[{table}]] entry must be a string, "
+            f"not {literal(entry[key])}: {literal(entry)}"
+            for entry in table_entries
+            if isinstance(entry, dict)
+            for key in sorted(keys & set(entry))
+            if not isinstance(entry[key], str)
+        )
+    return problems
+
+
+def config_problems(config: dict[str, t.Any], files: list[str]) -> list[str]:
+    """Return configuration mistakes that would silently weaken the check.
+
+    >>> config = {"widht": 80, "markdown": ["nope/*.md"], "allow_ceiling": 0}
+    >>> [problem.split(";")[0] for problem in config_problems(config, ["README.md"])]
+    ['unknown key: widht', 'markdown glob matches no tracked file: nope/*.md']
+    >>> config_problems({"reason": "r", "allow_ceiling": 0}, [])[0]
+    'unknown key: reason; reason belongs inside an [[...]] entry, below its header'
+
+    >>> config_problems({"tab_width": 0, "allow_ceiling": 0}, [])[0].split("; ")[::2]
+    ['tab_width is 0', 'set it to 4']
+    >>> config_problems(config, ["README.md"])[1].split("; ")[1]
+    'fix the glob or remove it'
+    >>> held = {"markdown": ["docs/{a,b}.md"], "allow_ceiling": 0}
+    >>> held["exclude"] = [{"glob": "notes/*", "reason": "r"}]
+    >>> len(config_problems(held, ["docs/a.md", "notes/b.md", "examples/c.md"]))
+    1
+    >>> braces = {"markdown": ["docs/{a,b}.md"], "allow_ceiling": 0}
+    >>> config_problems(braces, ["docs/a.md"])[0].split("; ")[-1]
+    'globs here take `*`, `**` and `?`, not `{a,b}` or `[...]`'
+    >>> config = {"allow": [{"path": "a", "line": "b"}], "allow_ceiling": 1}
+    >>> config_problems(config, ["a"])
+    ['allow entry for a has no reason: "b"']
+    >>> for problem in config_problems({"width": 100, "exclude": ["a"]}, ["a"]):
+    ...     print(problem)
+    an [[exclude]] entry is not a table: "a"
+    width is 100; the shared rule is 80
+    allow_ceiling is missing; set it to 0, the number of allow entries
+    >>> excluded = {"glob": "notes/*.md", "reason": "drafts"}
+    >>> config = {"markdown": ["*.md"], "exclude": [excluded], "allow_ceiling": 0}
+    >>> unused = config_problems(config, ["a.md", "notes/b.md"])[0].split("; ")
+    >>> unused[0]
+    'exclude glob matches no checked file or file under examples/: notes/*.md'
+    >>> unused[1]
+    'fix the glob or delete the entry'
+    >>> copy = {"copy": "notes/x.toml", "root": "x.toml", "key": "width"}
+    >>> moved = {"glob": "notes/x.toml", "reason": "formatter copy"}
+    >>> config = dict(config, exclude=[moved], formatter_copies=[copy])
+    >>> config_problems(config, ["a.md"])
+    []
+    >>> config = {"markdwn": ["**/*.md"], "exclude": [excluded], "allow_ceiling": 0}
+    >>> [problem.split(";")[0] for problem in config_problems(config, ["notes/b.md"])]
+    ['unknown key: markdwn']
+    >>> config = {"sources": ["examples/*.go"], "allow_ceiling": 0}
+    >>> files = ["examples/a.go", "examples/go.mod"]
+    >>> unread = config_problems(config, files)[0].split("; ")
+    >>> unread[0]
+    'examples/go.mod is under examples/ but neither checked nor excluded'
+    >>> unread[1]
+    'add "examples/go.mod" to sources, or to [[exclude]] with a reason'
+    >>> typo = {"globb": "examples/go.mod", "reason": "module file"}
+    >>> found = config_problems(dict(config, exclude=[typo]), files)
+    >>> [problem for problem in found if "neither" in problem]
+    []
+    >>> mod = {"glob": "examples/go.mod", "reason": "module file"}
+    >>> config_problems(dict(config, exclude=[mod]), files)
+    []
+    >>> config["exclude"] = [dict(mod, doc_comments=["*.go"])]
+    >>> config_problems(config, files)[0].split(";")[0]
+    'unknown key in an [[exclude]] entry: doc_comments'
+    >>> nested = {"exclude": [{"glob": "x", "reason": "r", "sources": ["*.go"]}]}
+    >>> [p.split(";")[0] for p in config_problems(nested, ["examples/a.go"])]
+    ['unknown key in an [[exclude]] entry: sources', 'allow_ceiling is missing']
+    >>> below = {"path": "a", "line": "b", "reason": "r", "allow_ceiling": 1}
+    >>> [p.split(";")[0] for p in config_problems({"allow": [below]}, ["a"])]
+    ['unknown key in an [[allow]] entry: allow_ceiling']
+    >>> config = {"allow": [{"file": "a", "line": "b", "reason": "c"}]}
+    >>> config_problems(dict(config, allow_ceiling=1), ["a"])[1]
+    'an [[allow]] entry has no path: {file = "a", line = "b", reason = "c"}'
+    >>> pasted = {"path": "a", "line": "b", "reason": PLACEHOLDER}
+    >>> config_problems({"allow": [pasted], "allow_ceiling": 1}, ["a"])[0]
+    'allow entry for a keeps the placeholder reason; say why this line cannot break'
+    >>> misspelled = {"markdwn": ["*.md"], "allow_ceiling": 0}
+    >>> config_problems({"widht": 80, "allow_ceiling": 0}, [])[0].split("; ")[1][:24]
+    'did you mean width? The '
+    >>> [p.split(";")[0] for p in config_problems({"allow_cieling": 0}, [])]
+    ['unknown key: allow_cieling']
+    >>> broken = {"glob": "examples/LICENS[E]", "reason": "license text"}
+    >>> config = {"sources": ["examples/*.go"], "exclude": [broken], "allow_ceiling": 0}
+    >>> found = config_problems(config, ["examples/a.go", "examples/LICENSE"])
+    >>> [p.split(";")[0] for p in found]
+    ['exclude glob matches no checked file or file under examples/: examples/LICENS[E]']
+    >>> found = config_problems(misspelled, ["examples/a.md"])
+    >>> [problem.split(";")[0] for problem in found]
+    ['unknown key: markdwn']
+    >>> typo = {"path": "a", "line": "b", "reson": "r"}
+    >>> found = config_problems({"allow": [typo], "allow_ceiling": 1}, ["a"])
+    >>> found[0].split("; ")[1].split("?")[0], len(found)
+    ('did you mean reason', 1)
+    >>> typo = {"glob": "a", "reson": "r"}
+    >>> len(config_problems({"exclude": [typo], "allow_ceiling": 0}, ["a"]))
+    1
+    >>> typo = {"globb": "a", "reason": "r"}
+    >>> len(config_problems({"exclude": [typo], "allow_ceiling": 0}, ["a"]))
+    1
+    >>> bracket = {"glob": "docs/[ab].md", "reason": "r"}
+    >>> config = {"markdown": ["*.md"], "exclude": [bracket], "allow_ceiling": 0}
+    >>> config_problems(config, ["a.md"])[0].split("; ")[-1][:20]
+    'globs here take `*`,'
+    """
+    entry_keys = set().union(*TABLE_KEYS.values())
+    problems = [
+        f"unknown key: {key}; "
+        + (
+            f"{key} belongs inside an [[...]] entry, below its header"
+            if key in entry_keys
+            else suggest(key, KEYS, f"the config takes {', '.join(sorted(KEYS))}")
+        )
+        for key in sorted(set(config) - KEYS)
+    ]
+    for table, keys in TABLE_KEYS.items():
+        for entry in config.get(table, []):
+            if not isinstance(entry, dict):
+                problems.append(
+                    f"{article(table)} [[{table}]] entry is not a table: "
+                    f"{literal(entry)}"
+                )
+                continue
+            problems.extend(
+                f"unknown key in {article(table)} [[{table}]] entry: {key}; "
+                + (
+                    "TOML puts every key below a [[...]] header into that "
+                    "entry, so top-level keys go above the first one"
+                    if key in KEYS
+                    else suggest(
+                        key,
+                        keys,
+                        f"{article(table)} [[{table}]] entry takes "
+                        f"{', '.join(sorted(keys))}",
+                    )
+                )
+                for key in sorted(set(entry) - keys)
+            )
+            problems.extend(
+                f"{article(table)} [[{table}]] entry has no {key}: {literal(entry)}"
+                for key in sorted(keys - set(entry) - {"reason"})
+                if not misspelled(entry, key)
+            )
+    if config.get("width", 80) != 80:
+        problems.append(f"width is {config['width']}; the shared rule is 80")
+    if config.get("tab_width", 4) != 4:
+        problems.append(
+            f"tab_width is {config['tab_width']}; the check counts a tab as 4 "
+            "columns, as the formatters here do; set it to 4"
+        )
+    globs = [(key, pattern) for key in GLOB_KEYS for pattern in config.get(key, [])]
+    problems.extend(
+        f"{key} glob matches no tracked file: {pattern}; fix the glob or remove it"
+        + syntax_hint(pattern)
+        for key, pattern in globs
+        if not any(glob_regex(pattern).fullmatch(path) for path in files)
+    )
+    checked = [path for path in files if matches(path, [p for _, p in globs])]
+    examples = [path for path in files if EXAMPLE_DIR.search(path)]
+    # An unknown top-level key is usually a misspelled glob key, which leaves
+    # files unchecked: exclusions look unused and example files look unread.
+    # Report the key alone until it is fixed.
+    known = not set(config) - KEYS and not any(
+        isinstance(entry, dict) and (set(entry) & KEYS or set(entry) - keys)
+        for table, keys in TABLE_KEYS.items()
+        for entry in config.get(table, [])
+    )
+    # A glob that matches nothing leaves its files unread, so exclusions and
+    # example files would look wrong until it is fixed.
+    known = known and all(
+        any(glob_regex(pattern).fullmatch(path) for path in files)
+        for _, pattern in globs
+    )
+    excluded: list[str] = []
+    dead = False
+    for entry in config.get("exclude", []):
+        if not isinstance(entry, dict):
+            continue
+        if not str(entry.get("reason", "")).strip() and not misspelled(entry, "reason"):
+            problems.append(f"exclude entry has no reason: {literal(entry)}")
+            continue
+        if "glob" not in entry:
+            continue
+        excluded.append(entry["glob"])
+        pattern = glob_regex(entry["glob"])
+        # A missing formatter copy is reported by the copy check instead.
+        copies = [pair.get("copy", "") for pair in config.get("formatter_copies", [])]
+        unread = not any(pattern.fullmatch(path) for path in checked + examples)
+        if known and unread and not any(pattern.fullmatch(c) for c in copies):
+            dead = True
+            problems.append(
+                "exclude glob matches no checked file or file under examples/: "
+                f"{entry['glob']}; fix the glob or delete the entry"
+                + syntax_hint(entry["glob"])
+            )
+    # A broken exclusion glob leaves its file looking unexcluded; asking for a
+    # new entry would duplicate the one that needs fixing.
+    if known and not dead:
+        problems.extend(
+            f"{path} is under examples/ but neither checked nor excluded; "
+            + select_advice(path)
+            for path in examples
+            if path not in checked and not matches(path, excluded)
+        )
+    count = len(config.get("allow", []))
+    ceiling = config.get("allow_ceiling")
+    nested = any(
+        isinstance(entry, dict) and "allow_ceiling" in entry
+        for table in TABLE_KEYS
+        for entry in config.get(table, [])
+    ) or any(meant(key) == "allow_ceiling" for key in set(config) - KEYS)
+    if ceiling is None:
+        # Written below a [[...]] header or misspelled, the key is already
+        # reported; asking for it again would invite a second copy.
+        if not nested:
+            problems.append(
+                f"allow_ceiling is missing; set it to {count}, "
+                "the number of allow entries"
+            )
+    elif count > int(ceiling):
+        problems.append(
+            f"allow_ceiling {ceiling} is below the "
+            f"{plural(count, 'allow entry', 'allow entries')}; delete the new "
+            "entry and shorten its line, or raise the ceiling in a change that "
+            "gives the reason"
+        )
+    elif count < int(ceiling):
+        problems.append(
+            f"allow_ceiling {ceiling} is above the "
+            f"{plural(count, 'allow entry', 'allow entries')}; lower it"
+        )
+    problems.extend(
+        f"allow entry for {entry.get('path')} has no reason: "
+        f"{literal(entry.get('line'))}"
+        for entry in config.get("allow", [])
+        if isinstance(entry, dict)
+        and not str(entry.get("reason", "")).strip()
+        and not misspelled(entry, "reason")
+    )
+    problems.extend(
+        f"allow entry for {entry.get('path')} keeps the placeholder reason; "
+        "say why this line cannot break"
+        for entry in config.get("allow", [])
+        if isinstance(entry, dict) and entry.get("reason") == PLACEHOLDER
+    )
+    return problems
+
+
+def entries(config: dict[str, t.Any], table: str) -> list[dict[str, t.Any]]:
+    """Return the ``[[table]]`` entries that hold every key the check reads.
+
+    ``config_problems`` reports the others, so the check skips them.
+
+    >>> entries({"allow": [{"path": "a", "line": "b"}, {"line": "c"}]}, "allow")
+    [{'path': 'a', 'line': 'b'}]
+    """
+    need = TABLE_KEYS[table] - {"reason"}
+    return [
+        entry
+        for entry in config.get(table, [])
+        if isinstance(entry, dict) and need <= set(entry)
+    ]
+
+
+def setting_text(line: str) -> str:
+    """Return a config line without its comment, quoted text left alone.
+
+    >>> setting_text("max_width = 80  # was 120"), setting_text("# all comment")
+    ('max_width = 80', '')
+    >>> setting_text('"name": "a # b", // note')
+    '"name": "a # b",'
+    """
+    quote = None
+    for index, char in enumerate(line):
+        if quote:
+            quote = None if char == quote else quote
+        elif char in "'\"":
+            quote = char
+        elif line.startswith(("#", "//", ";"), index) and (
+            index == 0 or line[index - 1].isspace()
+        ):
+            return line[:index].rstrip()
+    return line.rstrip()
+
+
+def copy_problems(root: pathlib.Path, config: dict[str, t.Any]) -> list[str]:
+    """Return formatter copies that drifted from their root file.
+
+    A copy may differ from its root only in the width key's value and the
+    comment on that line; every other setting, on that line too, must match.
+    A drifted copy is reported against its own path, the file to change.
+    """
+    problems = []
+    for pair in entries(config, "formatter_copies"):
+        missing = [
+            pair[side] for side in ("copy", "root") if not (root / pair[side]).is_file()
+        ]
+        if missing:
+            problems.extend(
+                f"{CONFIG}: formatter copy file does not exist: {m}" for m in missing
+            )
+            continue
+
+        def kept(path: str, key: str = pair["key"]) -> list[str]:
+            # The key's value becomes a placeholder, so another setting written
+            # on the same line still has to match.
+            value = rf'("?{re.escape(key)}"?\s*[=:]\s*"?)\w+'
+            lines = (root / path).read_text(encoding="utf-8").splitlines()
+            return [
+                re.sub(value, r"\g<1>width", setting_text(line))
+                if key in line
+                else line
+                for line in lines
+            ]
+
+        lines = (root / pair["copy"]).read_text(encoding="utf-8").splitlines()
+        key = re.escape(pair["key"])
+        code = "\n".join(setting_text(line) for line in lines)
+        setting = rf'(?:^|[\s{{,])"?{key}"?\s*[=:]\s*"?(\w+)'
+        sets = re.findall(setting, code, re.MULTILINE)
+        if len(sets) > 1:
+            # JSON keeps the last of two equal keys, so a second setting wins.
+            problems.append(
+                f"{pair['copy']}: sets {pair['key']} {len(sets)} times; keep one "
+                "setting, set to 80"
+            )
+        elif sets != ["80"]:
+            problems.append(
+                f"{pair['copy']}: {pair['key']} is not 80; set it to 80, the "
+                "width every example keeps"
+            )
+        if kept(pair["copy"]) != kept(pair["root"]):
+            problems.append(
+                f"{pair['copy']}: differs from {pair['root']} beyond the {pair['key']} "
+                f"value; make it equal to {pair['root']} except that value"
+            )
+    return problems
+
+
+def check(
+    root: pathlib.Path, config: dict[str, t.Any], files: list[str]
+) -> tuple[list[Finding], list[dict[str, str]]]:
+    """Return lines over the width, and allow entries that matched nothing."""
+    width = int(config.get("width", 80))
+    tab_width = int(config.get("tab_width", 4))
+    exclude = [entry["glob"] for entry in entries(config, "exclude")]
+    allow = entries(config, "allow")
+    allowed = {(entry["path"], entry["line"]) for entry in allow}
+    used: set[tuple[str, str]] = set()
+    findings: list[Finding] = []
+    for path in files:
+        if matches(path, exclude):
+            continue
+        suffix = pathlib.PurePosixPath(path).suffix
+        if matches(path, config.get("markdown", [])):
+            kind = "markdown"
+        elif matches(path, config.get("sources", [])):
+            kind = "source"
+        elif matches(path, config.get("doc_comments", [])):
+            kind = "doc"
+        else:
+            continue
+        try:
+            text = (root / path).read_text(encoding="utf-8")
+        except (OSError, UnicodeDecodeError):
+            continue
+        kinds: dict[int, str] = {}
+        if kind == "markdown" and suffix == ".rst":
+            lines = rest_block_lines(text)
+        elif kind == "markdown":
+            lines = markdown_lines(text, kinds=kinds)
+        elif kind == "doc":
+            lines = doc_comment_lines(text, suffix, kinds)
+            kinds = {number: kinds.get(number, "doc") for number, _ in lines}
+        else:
+            lines = list(enumerate(text.splitlines(), 1))
+            kinds = {number: "source" for number, _ in lines}
+        for number, line in lines:
+            shown = line.expandtabs(tab_width).rstrip()
+            wide = columns(shown)
+            if wide <= width or is_url(shown) or HIDDEN.match(shown):
+                continue
+            key = (path, line.rstrip())
+            if key in allowed:
+                used.add(key)
+                continue
+            where = kinds.get(number, "")
+            findings.append(Finding(path, number, wide, width, key[1], where))
+    stale = [entry for entry in allow if (entry["path"], entry["line"]) not in used]
+    return findings, stale
+
+
+def tracked_files(root: pathlib.Path, others: bool = False) -> list[str]:
+    """Return the files git tracks, as POSIX paths relative to the root.
+
+    With ``others``, return instead the untracked files git does not ignore.
+    A symbolic link is left out: its target is checked under its own path, so
+    a link such as CLAUDE.md to AGENTS.md would report every line twice.
+    """
+    untracked = ["--others", "--exclude-standard"] if others else []
+    output = subprocess.run(
+        ["git", "-C", str(root), "ls-files", "-z", *untracked],
+        check=True,
+        capture_output=True,
+        text=True,
+    ).stdout
+    return [p for p in output.split("\0") if p and not (root / p).is_symlink()]
+
+
+def writing_path(root: pathlib.Path) -> pathlib.Path | None:
+    """Return the WRITING.md that carries the shared section, if any."""
+    for name in (".github/WRITING.md", "WRITING.md"):
+        path = root / name
+        if path.is_file() and SHARED.search(path.read_text(encoding="utf-8")):
+            return path
+    return None
+
+
+def writing_file(root: pathlib.Path) -> pathlib.Path | None:
+    """Return the repository's WRITING.md, with or without the markers."""
+    for name in (".github/WRITING.md", "WRITING.md"):
+        if (root / name).is_file():
+            return root / name
+    return None
+
+
+def marker_problems(root: pathlib.Path) -> list[str]:
+    """Return a problem when no WRITING.md holds both shared markers.
+
+    Without them the routing and port-block checks have nothing to read, so
+    the run says so instead of skipping them.
+    """
+    if writing_path(root) is not None:
+        return []
+    writing = writing_file(root)
+    if writing is None:
+        return ["no WRITING.md: add .github/WRITING.md with the shared section"]
+    where = writing.relative_to(root).as_posix()
+    restore = f"`git show HEAD:{where}` or from another port"
+    return [
+        f"{where}: the shared markers are missing or unbalanced; restore the "
+        + f"section from {restore}"
+    ]
+
+
+def slug(heading: str) -> str:
+    """Return the anchor GitHub gives a Markdown heading.
+
+    >>> slug("Documented examples that run")
+    'documented-examples-that-run'
+    >>> slug("Reaching 80")
+    'reaching-80'
+    """
+    text = re.sub(r"[^\w\- ]", "", heading.strip().lower())
+    return text.replace(" ", "-")
+
+
+def unfenced(text: str) -> str:
+    r"""Return Markdown text without its fenced blocks.
+
+    A ``# comment`` inside a shell fence is not a heading.
+
+    >>> unfenced("## A\n```sh\n# not a heading\n```\ntext\n")
+    '## A\ntext\n'
+    """
+    kept, fence = [], ""
+    for line in text.splitlines(keepends=True):
+        mark = FENCE.match(line.rstrip("\n"))
+        if mark and not fence:
+            fence = mark["mark"]
+        elif mark and mark["mark"].startswith(fence) and not mark["info"].strip():
+            fence = ""
+        elif not fence:
+            kept.append(line)
+    return "".join(kept)
+
+
+def prose(text: str) -> str:
+    r"""Return Markdown text without its code and comments.
+
+    Fenced, indented and ``<pre>`` blocks, code spans of any backtick count
+    and HTML comments are dropped, so a link inside one is not a link:
+
+    >>> prose("a `[x](y)` b ``[x](`y`)`` <!-- [x](y) -->\n\n    [x](y)\n- [z](w)\n")
+    'a  b  \n\n- [z](w)\n'
+    >>> prose("```text\n[x](y)\n```\n")
+    ''
+    """
+    text = unfenced(text)
+    code = {number for number, _ in markdown_lines(text)}
+    lines = text.splitlines(keepends=True)
+    text = "".join(line for n, line in enumerate(lines, 1) if n not in code)
+    text = re.sub(r"<!--.*?-->", "", text, flags=re.DOTALL)
+    span = r"(?<!`)(`+)(?!`)(?:(?!\n[ \t]*\n).)+?(?<!`)\1(?!`)"
+    return re.sub(span, "", text, flags=re.DOTALL)
+
+
+def links(text: str) -> list[str]:
+    r"""Return the targets of a Markdown text's inline and reference links.
+
+    >>> links('[A](a.md#x "A"), [B](<b.md>) and [C](c.md \'C\')\n[d]: d.md')
+    ['a.md#x', 'b.md', 'c.md', 'd.md']
+    >>> links("![E](e.md) \\[F](f.md) [G\nH](g.md)")
+    ['g.md']
+    """
+    return [inline or reference for inline, reference in LINK.findall(text)]
+
+
+def routing_problems(root: pathlib.Path) -> list[str]:
+    """Return a problem unless AGENTS.md links the shared section's heading.
+
+    The heading is the last one of level one or two above the shared
+    markers: the section an agent routed from AGENTS.md should land in.
+    """
+    writing = writing_path(root)
+    if writing is None:
+        return []
+    text = writing.read_text(encoding="utf-8")
+    above = unfenced(text[: text.index("<!-- shared:examples -->")])
+    headings = [m[2] for m in HEADING.finditer(above) if len(m[1]) <= 2]
+    if not headings:
+        where = writing.relative_to(root).as_posix()
+        return [f"{where}: no heading above the shared section"]
+    anchor = slug(headings[-1])
+    agents = root / "AGENTS.md"
+    where = f"{writing.relative_to(root).as_posix()}#{anchor}"
+    link = f"[{headings[-1]}]({where})"
+    if not agents.is_file():
+        return [f"AGENTS.md is missing; add it with a link such as {link}"]
+    route = prose(agents.read_text(encoding="utf-8"))
+    for target in links(route):
+        path, _, fragment = target.partition("#")
+        # GitHub reads a leading slash as the repository root.
+        here = root / path.removeprefix("/")
+        if fragment == anchor and here.resolve() == writing.resolve():
+            return []
+    return [
+        f"AGENTS.md: no link to {where}, the section with the example rules; "
+        + f"add one such as {link}"
+    ]
+
+
+def port_block_problems(text: str) -> list[str]:
+    r"""Return how a WRITING.md's ``### In this repository`` block strays.
+
+    >>> labels = "\n".join(label + " x" for label in PORT_LABELS)
+    >>> bad = "```text\n" + "x" * 81 + "\n```"
+    >>> head = f"### In this repository\n\n{labels}\n\n"
+    >>> block = head + f"Bad, over 80:\n\n{bad}\n\nGood, named:\n"
+    >>> port_block_problems(block)
+    []
+    >>> [p.split(";")[0] for p in port_block_problems(block.replace("x" * 81, "x"))]
+    ['In this repository: the Bad example fits in 80 columns']
+    >>> port_block_problems(block.replace("- **Not formatted:**", "- **Other:**"))
+    ['In this repository: no "- **Not formatted:**" bullet in its place']
+    >>> port_block_problems("## Examples\n")
+    ['no "### In this repository" block']
+    >>> port_block_problems(block + "\n" + block)
+    ['2 "### In this repository" blocks; keep one']
+    """
+    blocks = PORT_BLOCK.findall(unfenced(text))
+    if len(blocks) > 1:
+        return [f'{len(blocks)} "### In this repository" blocks; keep one']
+    match = PORT_BLOCK.search(unfenced(text))
+    if match is None:
+        return ['no "### In this repository" block']
+    lines = match["body"].splitlines()
+    problems = []
+    at = 0
+    for label in PORT_LABELS:
+        found = next((i for i, line in enumerate(lines) if line.startswith(label)), -1)
+        if found < at:
+            problems.append(f'In this repository: no "{label}" bullet in its place')
+        else:
+            at = found
+    for example in ("Bad, over 80", "Good"):
+        count = sum(line.startswith(example) for line in lines[at:])
+        if count != 1:
+            problems.append(f'In this repository: {count} "{example}" examples, want 1')
+    # The fence after "Bad, over 80" is stripped above, so read it raw: a
+    # Bad example that a later edit brought within 80 no longer shows a fault.
+    raw = text[text.find("### In this repository") :].splitlines()
+    start = next(
+        (i for i, line in enumerate(raw) if line.startswith("Bad, over 80")), None
+    )
+    if start is not None:
+        opens = [i for i in range(start + 1, len(raw)) if FENCE.match(raw[i])]
+        code = raw[opens[0] + 1 : opens[1]] if len(opens) > 1 else []
+        if not any(columns(line.expandtabs(4)) > 80 for line in code):
+            problems.append(
+                "In this repository: the Bad example fits in 80 columns; "
+                "show a line that does not"
+            )
+    return problems
+
+
+# A comment after code, set off by two spaces as most style guides ask.
+TRAILING = re.compile(r"\S\s{2,}(?://|#|--)\s+(?P<body>.*)$")
+# How a comment line starts in the languages the examples use.
+COMMENTS = ("# ", "// ", "-- ", "/// ", "//! ", "/* ", "* ", "<!-- ")
+
+
+def kept_whole(rules: str) -> str:
+    """Return the rule that sends compared output and marker lines to allow."""
+    return f"Compared output and marker lines stay whole ({rules}#what-never-breaks)"
+
+
+def fix_advice(finding: Finding, rules: str) -> str:
+    r"""Return how to fix a wide line: a command splits, other code changes.
+
+    >>> code = Finding("a.md", 1, 90, 80, "let total = first + second;")
+    >>> fix_advice(code, "W.md").split(":")[0]
+    'Fix a wide line by changing the code, not the line breaks'
+    >>> fix_advice(code, "W.md").split(" ")[-2]
+    'W.md#in-this-repository'
+    >>> flag = Finding("a.md", 2, 90, 80, "    -DCMAKE_BUILD_TYPE=x -DX=1", "command")
+    >>> fix_advice(flag, "W.md").split(":")[0]
+    'Split a wide command the way its shell continues'
+    >>> said = Finding("a.md", 2, 90, 80, "$ ls  # list them", "command")
+    >>> note = Finding("a.md", 2, 90, 80, "# Build the tree", "note")
+    >>> fix_advice(said, "W.md") == fix_advice(note, "W.md")
+    True
+    >>> fix_advice(note, "W.md")
+    'Move the comment out of the block into the prose around it: W.md#code-blocks.'
+    >>> remark = Finding("a.rs", 2, 90, 80, "    // explain the call", "source")
+    >>> fix_advice(remark, "W.md").split(";")[0]
+    'Wrap the comment at 80 (W.md#width)'
+    >>> "(W.md#what-never-breaks)" in fix_advice(remark, "W.md")
+    True
+    >>> "copied" in fix_advice(remark, "W.md")
+    False
+    >>> output = Finding("a_test.go", 9, 90, 80, "\t// Output: " + "x" * 80, "source")
+    >>> fix_advice(output, "W.md").split(":")[0]
+    'Compared output and marker lines stay whole (W.md#what-never-breaks)'
+    >>> token = Finding("a.md", 3, 90, 80, "    --features=" + "x" * 70, "command")
+    >>> fix_advice(token, "W.md").split(":")[0]
+    'Fix a wide line by changing the code, not the line breaks'
+    >>> bare = Finding("a.md", 2, 90, 80, "cargo test --doc", "promptless")
+    >>> fix_advice(bare, "W.md").split(",")[0]
+    'If it is a command'
+    >>> "(W.md#reaching-80)" in fix_advice(bare, "W.md")
+    True
+    >>> fix_advice(bare, "W.md").split("; ")[-1]
+    'if it is output, tag the fence `text`.'
+    >>> fix_advice(Finding("a.md", 2, 90, 80, "# Build it", "promptless"), "W.md")
+    'Move the comment out of the block into the prose around it: W.md#code-blocks.'
+    >>> program = Finding("a.rs", 2, 90, 80, "let total = first + second;", "source")
+    >>> "copied" in fix_advice(program, "W.md"), "copied" in fix_advice(code, "W.md")
+    (False, True)
+    >>> fix_advice(program, "W.md").split(",")[0]
+    'If the port block names a formatter for this file'
+    >>> fix_advice(program, "W.md").split(". ")[-1]
+    'If a Markdown block copies this file, re-copy it as W.md#in-this-repository says.'
+    >>> script = Finding("run.sh", 3, 90, 80, "cmake -S . -B build -DX=1", "source")
+    >>> fix_advice(script, "W.md").split(". ")[-2]
+    'If it is one command, it may instead continue the way its shell does'
+    >>> fenced = Finding("a.md", 3, 90, 80, "cmake -S . -B build -DX=1", "script")
+    >>> fix_advice(fenced, "W.md").split(". ")[1]
+    'If it is one command, it may instead continue the way its shell does'
+    >>> "goes in a `console` fence with its prompt" in fix_advice(fenced, "W.md")
+    True
+    >>> fix_advice(Finding("a.md", 2, 90, 80, "# build it", "script"), "W.md")[:22]
+    'Wrap the comment at 80'
+    >>> html = Finding("a.md", 2, 90, 80, "<!-- a note for the next editor -->")
+    >>> fix_advice(html, "W.md")[:22]
+    'Wrap the comment at 80'
+    >>> doc = Finding("a.rs", 2, 90, 80, "/// // a comment line in doc code", "doc")
+    >>> fix_advice(doc, "W.md")[:22]
+    'Wrap the comment at 80'
+    >>> go = Finding("a.go", 2, 90, 80, "//\t// Wait for the marker line", "doc")
+    >>> pydoc = Finding("a.py", 2, 90, 80, "    >>> # Wait for the marker", "doc")
+    >>> [fix_advice(f, "W.md")[:22] for f in (go, pydoc)]
+    ['Wrap the comment at 80', 'Wrap the comment at 80']
+    >>> said = Finding("a.md", 2, 90, 80, ">>> # Wait for the marker", "session")
+    >>> data = Finding("a.md", 2, 90, 80, "# a heredoc line, not a comment", "session")
+    >>> fix_advice(said, "W.md")[:22]
+    'Wrap the comment at 80'
+    >>> fix_advice(data, "W.md").split(":")[0]
+    'Fix a wide line by changing the code, not the line breaks'
+    >>> doc = Finding("a.rs", 2, 90, 80, "/// let total = first + second;", "doc")
+    >>> fix_advice(doc, "W.md").split(":")[0], "copied" in fix_advice(doc, "W.md")
+    ('Fix a wide line by changing the code, not the line breaks', True)
+    >>> note = Finding("README.md", 3, 84, 80, "// wait until the pane prints it")
+    >>> "copied" in fix_advice(note, "W.md")
+    True
+    >>> line = "/// $ tmux new-session -d -s demo \\"
+    >>> doced = Finding("a.rs", 4, 90, 80, line, "doc:command")
+    >>> fix_advice(doced, "W.md").split(":")[0]
+    'Split a wide command the way its shell continues'
+    >>> noted = Finding("a.rs", 5, 90, 80, "/// # Create a session first", "doc:note")
+    >>> fix_advice(noted, "W.md")[:24]
+    'Move the comment out of '
+    >>> bare_note = Finding("a.rs", 2, 90, 80, "/// # Create it", "doc:promptless")
+    >>> fix_advice(bare_note, "W.md")[:24]
+    'Move the comment out of '
+    >>> labelled = Finding("A.md", 3, 90, 80, "session.name();  // → demo", "")
+    >>> fix_advice(labelled, "W.md").split(": ")[0]
+    'Keep the code and its marker on one line (W.md#what-never-breaks)'
+    >>> "shorten the code before the marker (W.md#reaching-80)" in fix_advice(
+    ...     labelled, "W.md"
+    ... )
+    True
+    >>> remark_copy = fix_advice(remark, "W.md").split(". ")[-1]
+    >>> remark_copy
+    'If a Markdown block copies this file, re-copy it as W.md#in-this-repository says.'
+    >>> command = Finding("a.md", 1, 90, 80, "  PS> Get-Item -Path x")
+    >>> fix_advice(command, "W.md")
+    'Split a wide command the way its shell continues: W.md#reaching-80.'
+    """
+    kind, text = finding.kind, finding.text.lstrip()
+    # A line in a doc-comment fence carries its Markdown kind after "doc:";
+    # read it past its comment marker, as the Markdown line would be read.
+    if kind.startswith("doc:"):
+        marker = GO_DOC if GO_DOC.match(finding.text) else DOC_LINE
+        kind, text = kind[4:], marker.sub("", finding.text, count=1).lstrip()
+    reach = f"{rules}#reaching-80"
+    advice = f"Fix a wide line by changing the code, not the line breaks: {reach}."
+    # Code blocks keeps explanations out of a console block, in the prose.
+    prose = (
+        f"Move the comment out of the block into the prose around it: "
+        f"{rules}#code-blocks."
+    )
+    if kind == "note":
+        return prose
+    if kind == "promptless":
+        if text.startswith("# "):
+            return prose
+        return (
+            "If it is a command, add the prompt its shell takes, `$ ` or `PS> `, "
+            f"and continue it the way that shell does ({reach}); if it is "
+            "output, tag the fence `text`."
+        )
+    if kind == "command" or text.startswith(("$ ", "PS> ")):
+        dialect = "PS> " if text.startswith("PS> ") else "$ "
+        if scan(text, Shell(dialect))[3] < len(text):
+            return prose
+        if len(text.rstrip(" \\`").split()) < 2:
+            # One token has nowhere to split.
+            return advice
+        return f"Split a wide command the way its shell continues: {reach}."
+    if kind == "doc":
+        marker = GO_DOC if GO_DOC.match(finding.text) else DOC_LINE
+        text = marker.sub("", finding.text, count=1).lstrip()
+    # A doctest comment sits behind its prompt. A session line without one is
+    # heredoc or other data, where # starts no comment.
+    doctest = DOCTEST.match(text) if kind in ("doc", "session") else None
+    text = text[doctest.end() :] if doctest else text
+    commented = kind in ("", "source", "doc", "script") or bool(doctest)
+    # Markdown blocks and doc-comment fences can be copies of a source file,
+    # and a source file can be the original a block copies.
+    copied = (
+        " In a block copied from a source file, fix the source, then follow the "
+        f"copy step that {rules}#in-this-repository gives."
+        if kind in ("", "doc", "script")
+        else " If a Markdown block copies this file, re-copy it as "
+        f"{rules}#in-this-repository says."
+        if kind == "source"
+        else ""
+    )
+    if commented and text.startswith(COMMENTS):
+        if MARKER.match(text.split(None, 1)[1] if " " in text else ""):
+            return kept_whole(rules) + ": add this one to [[allow]] with its reason."
+        # Width says comments wrap at 80; What never breaks keeps compared
+        # output and marker lines whole.
+        return (
+            f"Wrap the comment at 80 ({rules}#width); compared output and marker "
+            f"lines stay whole ({rules}#what-never-breaks).{copied}"
+        )
+    # A marker after the code it labels, such as `name();  // → demo`, keeps
+    # its line whole too.
+    trailing = TRAILING.search(text) if commented else None
+    if trailing and MARKER.match(trailing["body"]):
+        return (
+            f"Keep the code and its marker on one line ({rules}#what-never-breaks): "
+            f"shorten the code before the marker ({reach}); add it to [[allow]] only "
+            "if it still runs past 80."
+        )
+    # A script line is a shell command, which breaks at its continuation.
+    script = kind == "script" or (kind == "source" and finding.path.endswith(SCRIPTS))
+    if script and len(text.rstrip(" \\`").split()) > 1:
+        paste = (
+            " A command a reader pastes goes in a `console` fence with its prompt "
+            f"({rules}#code-blocks)."
+            if kind == "script"
+            else ""
+        )
+        return (
+            f"{advice} If it is one command, it may instead continue the way its "
+            f"shell does.{paste}{copied}"
+        )
+    if kind == "source":
+        return (
+            f"If the port block names a formatter for this file, run it. {advice}"
+            + copied
+        )
+    return advice + copied
+
+
+# A line edited in place keeps most of its text; a stale entry and a wide line
+# that share less are a deleted allowed line and a new wide one.
+SIMILAR = 0.6
+
+
+def resemblance(finding: Finding, entry: dict[str, t.Any]) -> float:
+    """Return how alike a wide line and a stale entry's line are, 0 to 1.
+
+    >>> line = Finding("a.md", 1, 90, 80, "print(totals, values)")
+    >>> round(resemblance(line, {"line": "print(total, values)"}), 2)
+    0.98
+    """
+    return alike(finding.text, entry["line"])
+
+
+def alike(one: str, other: str) -> float:
+    """Return how alike two lines are, 0 to 1.
+
+    >>> alike("abcd", "abce")
+    0.75
+    """
+    import difflib
+
+    return difflib.SequenceMatcher(None, one, other).ratio()
+
+
+def edit_pairs(
+    findings: list[Finding],
+    stale: list[dict[str, t.Any]],
+    bad_path: str | None,
+    shortened: list[dict[str, t.Any]] | None = None,
+) -> list[tuple[Finding, dict[str, t.Any]]]:
+    """Pair stale entries with the wide lines that kept most of their text.
+
+    Each stale entry and each wide line joins at most one pair, closest
+    first, so two allowed lines edited in one file make two pairs; the rest
+    of the wide lines are new.
+
+    >>> stale = [{"path": "a.md", "line": "alpha(" + "x" * 80 + ")"}]
+    >>> stale.append({"path": "a.md", "line": "beta(" + "y" * 80 + ")"})
+    >>> one = Finding("a.md", 3, 90, 80, "alpha(" + "x" * 82 + ")")
+    >>> two = Finding("a.md", 7, 90, 80, "beta(" + "y" * 83 + ")")
+    >>> new = Finding("a.md", 9, 90, 80, "z" * 90)
+    >>> pairs = edit_pairs([two, new, one], stale, None)
+    >>> [(f.number, e["line"][:4]) for f, e in pairs]
+    [(7, 'beta'), (3, 'alph')]
+    >>> edit_pairs([one], stale, "a.md")
+    []
+    >>> edit_pairs([one], stale, None, shortened=stale)
+    []
+    """
+    scored = sorted(
+        (
+            (resemblance(f, e), i, j)
+            for i, f in enumerate(findings)
+            for j, e in enumerate(stale)
+            if f.path == e["path"] and f.path != bad_path and e not in (shortened or [])
+        ),
+        reverse=True,
+    )
+    pairs, taken_lines, taken_entries = [], set(), set()
+    for score, i, j in scored:
+        if score < SIMILAR:
+            break
+        if i in taken_lines or j in taken_entries:
+            continue
+        taken_lines.add(i)
+        taken_entries.add(j)
+        pairs.append((i, findings[i], stale[j]))
+    return [(finding, entry) for _, finding, entry in sorted(pairs, key=lambda p: p[0])]
+
+
+def edited_finding(
+    findings: list[Finding], stale: list[dict[str, t.Any]], bad_path: str | None
+) -> Finding | None:
+    """Return the first wide line that is an edited allowed line, if any.
+
+    >>> stale = [{"path": "a.md", "line": "print(total, " + "x" * 80 + ")"}]
+    >>> new = Finding("a.md", 2, 90, 80, "y" * 90)
+    >>> edit = Finding("a.md", 9, 95, 80, "print(totals, " + "x" * 80 + ")")
+    >>> edited_finding([new, edit], stale, None).number
+    9
+    >>> edited_finding([new, edit], stale, "a.md") is None
+    True
+    >>> far = Finding("a.md", 3, 92, 80, "print(total, " + "y" * 20 + "x" * 60 + ")")
+    >>> edited_finding([far, edit], stale, None).number
+    9
+    """
+    pairs = edit_pairs(findings, stale, bad_path)
+    return pairs[0][0] if pairs else None
+
+
+def shortened_entries(
+    root: pathlib.Path,
+    stale: list[dict[str, t.Any]],
+    width: int,
+    tab_width: int,
+) -> list[dict[str, t.Any]]:
+    """Return stale entries whose line was shortened to fit since the last commit.
+
+    Such an entry's file holds a line that fits, resembles the entry and is
+    not in the committed file. A wide line that also resembles the entry is
+    then new, not the allowed line edited, so it gets an entry of its own.
+    """
+    found = []
+    for entry in stale:
+        path = str(entry["path"])
+        shown = subprocess.run(
+            ["git", "-C", str(root), "show", f"HEAD:{path}"],
+            capture_output=True,
+            text=True,
+            check=False,
+        )
+        if shown.returncode != 0:
+            continue
+        before = {line.rstrip() for line in shown.stdout.splitlines()}
+        if any(
+            line not in before
+            and columns(line.expandtabs(tab_width)) <= width
+            and alike(line, str(entry["line"])) >= SIMILAR
+            for line in source_lines(root, entry)
+        ):
+            found.append(entry)
+    return found
+
+
+def source_lines(root: pathlib.Path, entry: dict[str, t.Any]) -> set[str]:
+    """Return the stripped lines of an allow entry's file, or none if unreadable."""
+    try:
+        text = (root / str(entry["path"])).read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError):
+        return set()
+    return {line.rstrip() for line in text.splitlines()}
+
+
+def entry_name(entry: dict[str, t.Any], entries: list[dict[str, t.Any]]) -> str:
+    r"""Name an allow entry by its path, and by its line when the path has two.
+
+    >>> one = {"path": "a.md", "line": "first line"}
+    >>> entry_name(one, [one]), entry_name(one, [one, {"path": "a.md", "line": "x"}])
+    ('a.md', "a.md whose line begins 'first line'")
+    >>> indented = {"path": "a.md", "line": "        first line"}
+    >>> entry_name(indented, [indented, one])
+    "a.md whose line begins 'first line'"
+    >>> long = {"path": "a.md", "line": "print(total, first + second + third + fourth)"}
+    >>> entry_name(long, [long, one])
+    "a.md whose line begins 'print(total, first +'"
+    >>> path = {"path": "a.ps1", "line": r"C:\Users\me\AppData\Local\Temp\run.ps1"}
+    >>> entry_name(path, [path, {"path": "a.ps1", "line": "x"}])
+    "a.ps1 whose line begins 'C:\\Users\\me\\AppData\\Local\\Temp'"
+    """
+    if sum(e.get("path") == entry["path"] for e in entries) < 2:
+        return str(entry["path"])
+    text = entry["line"].strip()
+    if len(text) > 32:
+        # Cut at a space, or else before a backslash, so the quoted start
+        # never ends inside an escape.
+        space, slash = text.find(" ", 20), text.rfind("\\", 20, 33)
+        if 0 < space <= 40:
+            text = text[:space]
+        else:
+            text = text[:slash].rstrip("\\") if slash > 0 else text[:32]
+    return f"{entry['path']} whose line begins {quoted(text)}"
+
+
+def quoted(text: str) -> str:
+    r"""Return a line in single quotes, as a TOML literal string writes it.
+
+    A line that holds a single quote falls back to an escaped basic string.
+
+    >>> print(quoted(r'"C:\Windows"'), quoted("it's"))
+    '"C:\Windows"' "it's"
+    """
+    return f"'{text}'" if "'" not in text else literal(text)
+
+
+def ceiling_hints(
+    findings: list[Finding],
+    stale: list[dict[str, t.Any]],
+    count: int,
+    bad_path: str | None = None,
+    hidden: list[dict[str, t.Any]] | None = None,
+    entries: list[dict[str, t.Any]] | None = None,
+    shortened: list[dict[str, t.Any]] | None = None,
+) -> list[str]:
+    r"""Return what to change in the allow list after a failed run.
+
+    A stale entry in a file that also has a wide line is an edited allowed
+    line, so its entry takes the new text. A stale entry for ``bad_path``,
+    the WRITING.md whose Bad example now fits, asks for a wide Bad line
+    again. Every other stale entry goes, and the last line gives the
+    ceiling all of that leaves.
+
+    >>> wide = Finding("a.md", 3, 90, 80, "x" * 90)
+    >>> ceiling_hints([wide], [], 1)
+    ['Set allow_ceiling to 1 plus one for each line you add to [[allow]].']
+    >>> edited = {"path": "a.md", "line": "x" * 88}
+    >>> for hint in ceiling_hints([wide], [edited], 1):
+    ...     print(hint)
+    a.md: an allowed line changed; put its new text in the stale entry.
+    allow_ceiling stays 1.
+    >>> gone = {"path": "b.md", "line": "old"}
+    >>> for hint in ceiling_hints([wide], [edited, gone], 2):
+    ...     print(hint)
+    a.md: an allowed line changed; put its new text in the stale entry.
+    Delete the stale allow entry for b.md.
+    Lower allow_ceiling to 1.
+    >>> kept = {"path": "b.md", "line": "kept"}
+    >>> ceiling_hints([], [gone], 2, entries=[gone, kept])[0]
+    "Delete the stale allow entry for b.md whose line begins 'old'."
+    >>> second = Finding("a.md", 5, 88, 80, "z" * 88)
+    >>> ceiling_hints([wide, second], [edited], 1)[-1]
+    'Set allow_ceiling to 1 plus one for each line you add to [[allow]].'
+    >>> other = Finding("c.md", 7, 85, 80, "y" * 85)
+    >>> for hint in ceiling_hints([wide, other], [edited], 1):
+    ...     print(hint)
+    a.md: an allowed line changed; put its new text in the stale entry.
+    Set allow_ceiling to 1 plus one for each line you add to [[allow]].
+    >>> both = [edited, {"path": "a.md", "line": "y" * 88}]
+    >>> lines = [wide, Finding("a.md", 5, 90, 80, "y" * 90)]
+    >>> for hint in ceiling_hints(lines, both, 2):
+    ...     print(hint)
+    a.md: an allowed line changed; put its new text in the stale entry.
+    a.md: an allowed line changed; put its new text in the stale entry.
+    allow_ceiling stays 2.
+    >>> kept = {"path": "a.md", "line": "x" * 90}
+    >>> for hint in ceiling_hints([], [kept], 1, hidden=[kept]):
+    ...     print(hint.split(";")[0])
+    a.md: the allowed line is still there but the check no longer reads it as wide
+    allow_ceiling stays 1.
+    >>> unrelated = {"path": "a.md", "line": "old"}
+    >>> for hint in ceiling_hints([wide], [unrelated], 1):
+    ...     print(hint)
+    Delete the stale allow entry for a.md.
+    Set allow_ceiling to 0 plus one for each line you add to [[allow]].
+    >>> bad = {"path": "WRITING.md", "line": "x" * 90}
+    >>> for hint in ceiling_hints([], [bad], 1, "WRITING.md"):
+    ...     print(hint)
+    WRITING.md: restore a Bad example past 80; its [[allow]] entry quotes it.
+    allow_ceiling stays 1.
+    >>> other = Finding("WRITING.md", 9, 85, 80, "x" * 85)
+    >>> for hint in ceiling_hints([other], [bad], 1, "WRITING.md"):
+    ...     print(hint)
+    WRITING.md: restore a Bad example past 80; its [[allow]] entry quotes it.
+    Set allow_ceiling to 1 plus one for each line you add to [[allow]].
+    """
+    pairs = edit_pairs(findings, stale, bad_path, shortened)
+    edited = [entry for _, entry in pairs]
+    hints = [
+        f"{entry['path']}: an allowed line changed; put its new text in the "
+        "stale entry."
+        for entry in edited
+    ]
+    restored = [entry for entry in stale if entry["path"] == bad_path]
+    hints += [
+        f"{bad_path}: restore a Bad example past 80; its [[allow]] entry quotes it."
+    ] * bool(restored)
+    # An allowed line still in its file was hidden by a config change, not
+    # fixed: deleting its entry would only weaken the gate.
+    hidden = [entry for entry in hidden or [] if entry in stale]
+    hints += [
+        f"{entry_name(e, entries or stale)}: the allowed line is still there but "
+        "the check no longer reads it as wide; undo the change that hid it: a "
+        "glob, [[exclude]] or tab_width edit, or a fence tag or comment marker "
+        "around the line."
+        for e in hidden
+    ]
+    gone = [e for e in stale if e not in edited + restored + hidden]
+    hints += [
+        f"Delete the stale allow entry for {entry_name(e, entries or stale)}."
+        for e in gone
+    ]
+    target = count - len(gone)
+    # Every wide line not paired with a stale entry is new.
+    if len(findings) > len(pairs):
+        hints.append(
+            f"Set allow_ceiling to {target} plus one for each line you add "
+            "to [[allow]]."
+        )
+    elif target == count:
+        hints.append(f"allow_ceiling stays {count}.")
+    else:
+        hints.append(f"Lower allow_ceiling to {target}.")
+    return hints
+
+
+def digests(root: pathlib.Path) -> list[str]:
+    """Return ``checker <sha256>`` and ``shared <sha256>`` lines.
+
+    The shared digest covers the text between the markers in WRITING.md;
+    ``shared missing`` means no WRITING.md carries them.
+    """
+    checker = hashlib.sha256(pathlib.Path(__file__).read_bytes()).hexdigest()
+    shared = "missing"
+    writing = writing_path(root)
+    if writing is not None:
+        match = SHARED.search(writing.read_text(encoding="utf-8"))
+        if match:
+            shared = hashlib.sha256(match["body"].encode()).hexdigest()
+    return [f"checker {checker}", f"shared {shared}"]
+
+
+def digest_problems(root: pathlib.Path, config: dict[str, t.Any]) -> list[str]:
+    """Return digests that differ from the ones the configuration records.
+
+    Each message names the file that changed. Both files are the same in
+    every port, so an intended change goes to all of them; an edit meant for
+    one repository is undone instead.
+    """
+    actual = dict(line.split(" ", 1) for line in digests(root))
+    here, top = pathlib.Path(__file__).resolve(), root.resolve()
+    script = here.relative_to(top) if here.is_relative_to(top) else here.name
+    writing = writing_file(root)
+    shared = writing.relative_to(root).as_posix() if writing else "WRITING.md"
+    where = {"checker": script, "shared": shared}
+    names = {"checker": "this checker", "shared": "the shared section"}
+    undo = {
+        "checker": f"it (`git checkout -- {script}`, or a copy from another port)",
+        "shared": (
+            "the text between the shared markers, copied from "
+            f"`git show HEAD:{shared}` so port-block edits stay, or from another "
+            "port once the edit is committed"
+        ),
+    }
+    # A digest written below a [[...]] header or misspelled is reported as
+    # an unknown key already.
+    nested = {
+        key
+        for table in TABLE_KEYS
+        for entry in config.get(table, [])
+        if isinstance(entry, dict)
+        for key in entry
+    } | {meant(key) for key in set(config) - KEYS}
+    missing = [
+        f"{CONFIG}: {name}_digest is missing; run `python3 {script} --digest` "
+        f"and set {name}_digest to the {name} value it prints"
+        for name in ("checker", "shared")
+        if name + "_digest" not in config and name + "_digest" not in nested
+    ]
+    return missing + [
+        f"{where[name]}: {names[name]} has digest {actual[name][:12]}, but "
+        f"{name}_digest in {CONFIG} records {config[name + '_digest'][:12]}.\n"
+        f"  To undo an edit meant for this repository only, restore {undo[name]}.\n"
+        "  To change it everywhere, change libtmux/docs and each repository "
+        f"listed in {PORTS}, which also names where each keeps this checker; "
+        "run each copy with `--digest` and set checker_digest and "
+        "shared_digest to the values it prints."
+        for name in ("checker", "shared")
+        if name + "_digest" in config
+        and actual[name] not in (config[name + "_digest"], "missing")
+    ]
+
+
+def self_test() -> int:
+    """Run the doctests above, plus planted failures and clean controls."""
+    import contextlib
+    import doctest
+    import io
+    import tempfile
+
+    failures, _ = doctest.testmod(sys.modules[__name__])
+
+    def expect(condition: bool, message: str) -> None:
+        nonlocal failures
+        if not condition:
+            print(f"self-test: {message}", file=sys.stderr)
+            failures += 1
+
+    with tempfile.TemporaryDirectory() as scratch:
+        root = pathlib.Path(scratch)
+        wide = "let total = " + " + ".join(["value"] * 12) + ";"
+        (root / "README.md").write_text(f"```rust\n{wide}\n```\n")
+        config: dict[str, t.Any] = {"width": 60, "markdown": ["README.md"]}
+        planted, _ = check(root, config, ["README.md"])
+        expect(len(planted) == 1, "a planted wide line was not reported")
+        if planted:
+            pasted = tomllib.loads(allow_hint(planted[0]))["allow"][0]
+            expect(pasted["line"] == wide, "the allow hint does not round-trip")
+        excluded = dict(config, exclude=[{"glob": "README.md", "reason": "r"}])
+        expect(not check(root, excluded, ["README.md"])[0], "an exclusion was read")
+        config["allow"] = [{"path": "README.md", "line": wide, "reason": "test"}]
+        clean, stale = check(root, config, ["README.md"])
+        expect(not clean and not stale, "an allowed line was reported")
+        url = "https://example.com/" + "x" * 80
+        hidden = ">>> setup = " + "x" * 70 + "  # doctest: +HIDE"
+        (root / "skip.md").write_text(f"```\n{url}\n```\n```python\n{hidden}\n```\n")
+        skipped, _ = check(root, {"width": 80, "markdown": ["skip.md"]}, ["skip.md"])
+        expect(not skipped, "a URL line or a hidden doctest line was reported")
+        body = "x" * 90
+        (root / "here.md").write_text(
+            f"```console\n$ cat <<EOF\n... a line\n{body}\nEOF\n```\n"
+        )
+        here, _ = check(root, {"width": 80, "markdown": ["here.md"]}, ["here.md"])
+        expect(
+            [f.text for f in here] == [body],
+            "a heredoc line after a ... line was read as output",
+        )
+        flag = "    -DCMAKE_BUILD_TYPE=Release -DCMAKE_TOOLCHAIN_FILE=" + "x" * 40
+        (root / "flag.md").write_text(f"```console\n$ cmake \\\n{flag}\n```\n")
+        continued, _ = check(root, {"width": 80, "markdown": ["flag.md"]}, ["flag.md"])
+        expect(
+            len(continued) == 1 and fix_advice(continued[0], "W").startswith("Split"),
+            "a wide continuation line was not given the command advice",
+        )
+        (root / "prog.py").write_text("total = " + "x" * 80 + "\n")
+        program, _ = check(root, {"width": 80, "sources": ["prog.py"]}, ["prog.py"])
+        expect(
+            len(program) == 1 and "copied" not in fix_advice(program[0], "W"),
+            "a wide line in an example program was told to edit a copied block",
+        )
+        doc = "/// ```\n/// let total = " + "x" * 80 + ";\n/// ```\nfn f() {}\n"
+        (root / "doc.rs").write_text(doc)
+        coded, _ = check(root, {"width": 80, "doc_comments": ["doc.rs"]}, ["doc.rs"])
+        expect(
+            len(coded) == 1 and fix_advice(coded[0], "W").startswith("Fix a wide"),
+            "a wide line of doc-comment code was given the comment advice",
+        )
+        (root / "bare.md").write_text("```console\ncargo test " + "x" * 80 + "\n```\n")
+        bare, _ = check(root, {"width": 80, "markdown": ["bare.md"]}, ["bare.md"])
+        expect(
+            len(bare) == 1
+            and fix_advice(bare[0], "W").startswith("If it is a command, add the"),
+            "a wide line in a promptless console fence was not told to add a prompt",
+        )
+        mixed = "```console\n$ ls `\n  -l\n```\n```console\nPS> dir `\n  -x\n```\n"
+        (root / "mixed.md").write_text(mixed)
+        mixed_problems = prompt_problems(root, {"markdown": ["mixed.md"]}, ["mixed.md"])
+        expect(
+            [p.split(":")[1] for p in mixed_problems] == ["2"],
+            "a `$ ` command continued with a backtick passed, or a PS> one failed",
+        )
+        (root / "page.rst").write_text(".. code-block:: sh\n\n   " + "x" * 81 + "\n")
+        rst, _ = check(root, {"width": 80, "markdown": ["page.rst"]}, ["page.rst"])
+        expect(len(rst) == 1, "a wide line in a reST code block passed")
+        config["allow"].append({"path": "README.md", "line": "gone", "reason": "x"})
+        _, stale = check(root, config, ["README.md"])
+        expect(len(stale) == 1, "a stale allow entry was not reported")
+        tabbed = "\t" + wide
+        (root / "main.go").write_text(tabbed + "\n")
+        config = {"width": 60, "sources": ["*.go"]}
+        config["allow"] = [{"path": "main.go", "line": tabbed, "reason": "test"}]
+        clean, stale = check(root, config, ["main.go"])
+        expect(not clean and not stale, "a raw tabbed allow entry did not match")
+        (root / "tab.go").write_text("\t" + "x" * 78 + "\n")
+        tabbed_config = {"width": 80, "tab_width": 4, "sources": ["tab.go"]}
+        expanded, _ = check(root, tabbed_config, ["tab.go"])
+        expect(len(expanded) == 1, "a tab counted as one column")
+        (root / "tab.go").write_text("\t" + "x" * 76 + "\n")
+        expanded, _ = check(root, tabbed_config, ["tab.go"])
+        expect(not expanded, "a tabbed line within 80 was reported")
+        (root / "fmt.toml").write_text("edition = 1\nmax_width = 100\n")
+        (root / "copy.toml").write_text("edition = 1\nmax_width = 80\n")
+        pair = {"copy": "copy.toml", "root": "fmt.toml", "key": "max_width"}
+        copies = {"formatter_copies": [pair]}
+        expect(not copy_problems(root, copies), "a width-only copy was reported")
+        wider_copies = (
+            "max_width = 120",
+            "max_width = 100 # was 80",
+            "# max_width = 80",
+            "# keep max_width = 80\nmax_width = 100",
+            "max_width = 80\nmax_width = 120",
+            "max_width = 80, max_width = 120",
+        )
+        for wider in wider_copies:
+            (root / "copy.toml").write_text(f"edition = 1\n{wider}\n")
+            expect(bool(copy_problems(root, copies)), f"a copy with {wider!r} passed")
+        (root / "copy.toml").write_text(
+            "edition = 1\nmax_width = 80, max_width = 120\n"
+        )
+        doubled = copy_problems(root, copies)
+        expect(bool(doubled) and "2 times" in doubled[0], "a doubled width passed")
+        (root / "copy.toml").write_text("edition = 1\nmax_width = 80  # was 120\n")
+        expect(not copy_problems(root, copies), "a commented width was read twice")
+        (root / "copy.toml").write_text(
+            "edition = 1\nmax_width = 80  # the root sets max_width = 100\n"
+        )
+        expect(
+            not copy_problems(root, copies), "a width named in a comment was counted"
+        )
+        (root / "copy.toml").write_text("edition = 1\nmax_width = 80\n")
+        (root / "copy.toml").write_text("edition = 2\nmax_width = 80\n")
+        expect(bool(copy_problems(root, copies)), "a drifted copy was not reported")
+        (root / "fmt.json").write_text('{\n  "lineLength": 100, "indent": 2\n}\n')
+        (root / "copy.json").write_text('{\n  "lineLength": 80, "indent": 9\n}\n')
+        same_line = {"copy": "copy.json", "root": "fmt.json", "key": "lineLength"}
+        expect(
+            bool(copy_problems(root, {"formatter_copies": [same_line]})),
+            "a setting changed on the width line passed",
+        )
+        (root / "copy.json").write_text('{\n  "lineLength": 80, "indent": 2\n}\n')
+        expect(
+            not copy_problems(root, {"formatter_copies": [same_line]}),
+            "a copy differing only in its width value was reported",
+        )
+        expect(digests(root)[1] == "shared missing", "a missing section was digested")
+        shared = "<!-- shared:examples -->\nrule\n<!-- /shared:examples -->\n"
+        (root / "WRITING.md").write_text(shared)
+        expect(digests(root)[1] != "shared missing", "a shared section was missed")
+        headless = routing_problems(root)
+        expect(
+            bool(headless) and "no heading" in headless[0],
+            "a shared section with no heading above passed",
+        )
+        checker_now = digests(root)[0].split(" ", 1)[1]
+        recorded: dict[str, t.Any] = {
+            "checker_digest": checker_now,
+            "shared_digest": "0" * 64,
+        }
+        changed = digest_problems(root, recorded)
+        expect(
+            bool(changed) and "or from another port" in changed[0],
+            "a shared-section change was missed or offered only HEAD to restore",
+        )
+        shared_now = digests(root)[1].split(" ", 1)[1]
+        recorded = {"checker_digest": checker_now, "shared_digest": shared_now}
+        expect(not digest_problems(root, recorded), "a matching digest was reported")
+        below = {"path": "a", "line": "b", "reason": "r"}
+        below["checker_digest"] = recorded.pop("checker_digest")
+        recorded["allow"] = [below]
+        expect(
+            not digest_problems(root, recorded),
+            "a digest below [[allow]] was also reported missing",
+        )
+        del recorded["allow"]
+        recorded["checker_digset"] = below["checker_digest"]
+        expect(
+            not digest_problems(root, recorded),
+            "a misspelled digest key was also reported missing",
+        )
+        del recorded["checker_digset"]
+        expect(bool(digest_problems(root, recorded)), "a missing digest passed")
+        (root / "WRITING.md").write_text("## Examples\n\n" + shared)
+        alone = root / "alone" / ".github"
+        alone.mkdir(parents=True)
+        section = "## Examples\n\n<!-- shared:examples -->\n"
+        (alone / "WRITING.md").write_text(section)
+        broken = marker_problems(alone.parent)
+        expect(
+            bool(broken) and ".github/WRITING.md" in broken[0],
+            "a missing closing marker passed or named the wrong file",
+        )
+        (alone / "WRITING.md").write_text(section + "x\n<!-- /shared:examples -->\n")
+        expect(not marker_problems(alone.parent), "balanced markers were reported")
+        body = "  echo " + "x" * 80
+        loop = f"```console\n$ for x in a; do\n{body}\ndone\n{'y' * 81}\n```\n"
+        (root / "loop.md").write_text(loop)
+        looped, _ = check(root, {"width": 80, "markdown": ["loop.md"]}, ["loop.md"])
+        expect(
+            [finding.number for finding in looped] == [3],
+            "a wide loop body passed, or printed output was measured",
+        )
+        expect(bool(routing_problems(root)), "a missing AGENTS.md link passed")
+        (root / "AGENTS.md").write_text("Code examples: WRITING.md#examples\n")
+        expect(bool(routing_problems(root)), "a bare anchor counted as a link")
+        (root / "AGENTS.md").write_text("[Examples](docs/WRITING.md#examples)\n")
+        expect(bool(routing_problems(root)), "a link to a missing file passed")
+        (root / "AGENTS.md").write_text("[Examples](WRITING.md#other)\n")
+        expect(bool(routing_problems(root)), "a link to the wrong heading passed")
+        (root / "AGENTS.md").write_text("[Examples](WRITING.md#examples)\n")
+        expect(not routing_problems(root), "a linked section was reported")
+        (root / "AGENTS.md").write_text("[Examples](<WRITING.md#examples>)\n")
+        expect(not routing_problems(root), "an angle-bracket link was reported")
+        (root / "AGENTS.md").write_text("[Examples][ex]\n\n[ex]: WRITING.md#examples\n")
+        expect(not routing_problems(root), "a reference-style link was reported")
+        (root / "AGENTS.md").write_text("[Examples](/WRITING.md#examples)\n")
+        expect(not routing_problems(root), "a root-relative link was reported")
+        for hidden_link in (
+            "- Code examples:\n\n      {}\n",
+            "```\n{}\n```\n",
+            "`{}`\n",
+            "<!-- {} -->\n",
+            "!{}\n",
+            "\\{}\n",
+        ):
+            link = "[Examples](WRITING.md#examples)"
+            (root / "AGENTS.md").write_text(hidden_link.format(link))
+            expect(bool(routing_problems(root)), f"a link in {hidden_link!r} passed")
+        (root / "AGENTS.md").write_text("[Examples](WRITING.md#examples)\n")
+        (root / "AGENTS.md").unlink()
+        gone = routing_problems(root)
+        expect(
+            bool(gone) and "is missing" in gone[0], "a missing AGENTS.md was unnamed"
+        )
+        (root / "AGENTS.md").write_text("[Examples](WRITING.md#examples)\n")
+        labels = "\n".join(label + " x" for label in PORT_LABELS)
+        wide = "```text\n" + "x" * 81 + "\n```"
+        head = f"### In this repository\n\n{labels}\n\n"
+        block = head + f"Bad, over 80:\n\n{wide}\n\nGood, x:\n"
+        expect(not port_block_problems(block), "a complete port block was reported")
+        twice = block + f"\nBad, over 80:\n\n{wide}\n"
+        expect(bool(port_block_problems(twice)), "a second Bad example passed")
+        missing = block.replace(PORT_LABELS[2], "- **Other:**")
+        expect(
+            bool(port_block_problems(missing)), "a port block missing a label passed"
+        )
+        fenced = "## Examples\n\n```sh\n# a comment\n```\n\n" + shared
+        (root / "WRITING.md").write_text(fenced)
+        expect(not routing_problems(root), "a fenced comment read as a heading")
+        nested = tomllib.loads(
+            'allow_ceiling = 0\n[[exclude]]\nglob = "a"\nreason = "r"\n'
+            'doc_comments = ["a"]\n'
+        )
+        nested["markdown"] = ["a"]
+        expect(
+            any("doc_comments" in p for p in config_problems(nested, ["a"])),
+            "a key nested under [[exclude]] passed",
+        )
+        del nested["exclude"][0]["doc_comments"]
+        expect(not config_problems(nested, ["a"]), "a clean [[exclude]] was reported")
+        nested["exclude"][0]["reason"] = " "
+        expect(
+            any("no reason" in p for p in config_problems(nested, ["a"])),
+            "an exclusion without a reason passed",
+        )
+        table = {"exclude": {"glob": "a", "reason": "r"}}
+        expect(bool(type_problems(table)), "[exclude] written as one table passed")
+        typed = {"width": "80", "markdown": "**/*.md"}
+        expect(len(type_problems(typed)) == 2, "a string width or glob list passed")
+        listed = {"allow": [{"path": ["a"], "line": "b", "reason": "c"}]}
+        expect(bool(type_problems(listed)), "a list where a string belongs passed")
+        absent = {"copy": "gone.toml", "root": "fmt.toml", "key": "max_width"}
+        expect(
+            bool(copy_problems(root, {"formatter_copies": [absent]})),
+            "a missing formatter copy passed",
+        )
+        expect(not type_problems({"width": 80, "markdown": ["a"]}), "good types failed")
+        misnamed: dict[str, t.Any] = {
+            "markdown": ["README.md"],
+            "exclude": [{"path": "README.md", "reason": "r"}],
+            "allow": [{"file": "README.md", "line": wide, "reason": "r"}],
+            "formatter_copies": [{"copy": "copy.toml", "root": "fmt.toml"}],
+            "allow_ceiling": 1,
+        }
+        found = " ".join(config_problems(misnamed, ["README.md"]))
+        expect(
+            all(f"has no {key}" in found for key in ("glob", "path", "key")),
+            "an entry missing a key the check reads passed",
+        )
+        try:
+            check(root, misnamed, ["README.md"])
+            copy_problems(root, misnamed)
+        except KeyError as error:
+            expect(False, f"an entry missing {error} crashed the check")
+        entry = {"path": "a", "line": "b", "reason": "c"}
+        ceiling: dict[str, t.Any] = {"allow": [entry, entry], "allow_ceiling": 1}
+        grown = config_problems(ceiling, ["a"])
+        expect(
+            bool(grown) and "delete the new entry" in grown[0],
+            "a grown allow list passed or was not told to delete the new entry",
+        )
+        ceiling = {"allow": [entry], "allow_ceiling": 2}
+        expect(bool(config_problems(ceiling, ["a"])), "a shrunk list kept its ceiling")
+        ceiling = {"allow": [entry], "allow_ceiling": 1}
+        expect(not config_problems(ceiling, ["a"]), "an exact ceiling was reported")
+    with tempfile.TemporaryDirectory() as scratch:
+        top = pathlib.Path(scratch)
+        git = ["git", "-C", scratch, "-c", "init.defaultBranch=main"]
+        subprocess.run([*git, "init", "-q"], check=True)
+        (top / ".github").mkdir()
+        (top / "README.md").write_text("x\n")
+        subprocess.run([*git, "add", "README.md"], check=True)
+        (top / "LINKED.md").symlink_to("README.md")
+        subprocess.run([*git, "add", "LINKED.md"], check=True)
+        expect(
+            tracked_files(top) == ["README.md"],
+            "a tracked symbolic link was read beside its target",
+        )
+
+        def run(config_text: str) -> str:
+            (top / CONFIG).write_text(config_text)
+            out = io.StringIO()
+            with contextlib.redirect_stdout(out):
+                code = main(["--root", scratch])
+            expect(code == 1, "a broken config passed")
+            return out.getvalue()
+
+        expect(
+            "fix the config first" in run('width = "80"\n'),
+            "a string width reached the width pass",
+        )
+        expect(
+            "cannot read the config" in run("width = [\n"),
+            "a config that is not TOML went unreported",
+        )
+        misspelled = (
+            'markdwn = ["*.md"]\nallow_ceiling = 1\n[[allow]]\n'
+            'path = "README.md"\nline = "x"\nreason = "r"\n'
+        )
+        expect(
+            "0 stale allow entries" in run(misspelled),
+            "a misspelled glob key made an allow entry look stale",
+        )
+        allowed = "print(total, " + "x" * 80 + ")"
+        edited = allowed.replace("total", "totals")
+        (top / "README.md").write_text(f"```py\n{'y' * 90}\n{edited}\n```\n")
+        config_text = (
+            'markdown = ["README.md"]\nallow_ceiling = 1\n[[allow]]\n'
+            f'path = "README.md"\nline = "{allowed}"\nreason = "r"\n'
+        )
+        advice = run(config_text)
+        expect(
+            advice.count(f'line = "{edited}"') == 1
+            and f'[[allow]]\npath = "README.md"\nline = "{"y" * 90}"' in advice,
+            "an edited allowed line was paired with another wide line, or the "
+            "new wide line got no entry",
+        )
+        expect(
+            "\nREADME.md: an allowed line changed; its entry says why it stays"
+            in "\n" + advice
+            and "give it an entry of its own" in advice
+            and "Fix a wide line by changing the code" in advice,
+            "an edited allowed line was told to change its code",
+        )
+        (top / "README.md").write_text(f"```go\n// Output: {'o' * 80}\n```\n")
+        marked = run('markdown = ["README.md"]\nallow_ceiling = 0\n')
+        expect(
+            marked.split("\n[[allow]]")[0].count("[[allow]]") == 1
+            and "#what-never-breaks); add the line to [[allow]]" in marked,
+            "a marker line's advice named [[allow]] twice",
+        )
+        (top / "README.md").write_text(f"```py\nprint({'w' * 80})\n```\n")
+        plain = "\n" + run('markdown = ["README.md"]\nallow_ceiling = 0\n')
+        expect(
+            "\nFix a wide line by changing the code" in plain
+            and "\nIf no change keeps the example clear, add the line to" in plain,
+            "a wide line's advice and its allow fallback were not on lines of "
+            "their own",
+        )
+        with tempfile.TemporaryDirectory() as other:
+            repo = pathlib.Path(other)
+            sub = ["git", "-C", other, "-c", "user.name=t", "-c", "user.email=t@t"]
+            subprocess.run([*sub, "init", "-q"], check=True)
+            allowed_line = "print(total, " + "x" * 80 + ")"
+            (repo / "README.md").write_text(f"```py\n{allowed_line}\n```\n")
+            subprocess.run([*sub, "add", "README.md"], check=True)
+            subprocess.run([*sub, "commit", "-qm", "x"], check=True)
+            # The allowed line is shortened to fit, and a new wide line that
+            # resembles it is added: the entry goes, the new line gets its own.
+            fits = "print(total, " + "x" * 40 + ")"
+            new = "print(totals, " + "x" * 80 + ")"
+            (repo / "README.md").write_text(f"```py\n{fits}\n{new}\n```\n")
+            (repo / ".github").mkdir()
+            (repo / CONFIG).write_text(
+                'markdown = ["README.md"]\nallow_ceiling = 1\n[[allow]]\n'
+                f'path = "README.md"\nline = "{allowed_line}"\nreason = "r"\n'
+            )
+            out = io.StringIO()
+            with contextlib.redirect_stdout(out):
+                main(["--root", other])
+            told = out.getvalue()
+            expect(
+                "an allowed line changed" not in told
+                and f"names a line shortened to fit in 80: '{allowed_line}'" in told
+                and "Delete the stale allow entry for README.md." in told
+                and "Set allow_ceiling to 0 plus one" in told,
+                "a new wide line beside a shortened allowed line was taken for "
+                "its edit",
+            )
+            # A short similar line already committed is not a shortening: an
+            # edit to the allowed line still takes its entry.
+            (repo / "README.md").write_text(f"```py\n{fits}\n{allowed_line}\n```\n")
+            subprocess.run([*sub, "commit", "-qam", "y"], check=True)
+            edited_line = allowed_line.replace("total", "totals")
+            (repo / "README.md").write_text(f"```py\n{fits}\n{edited_line}\n```\n")
+            out = io.StringIO()
+            with contextlib.redirect_stdout(out):
+                main(["--root", other])
+            expect(
+                "an allowed line changed" in out.getvalue(),
+                "an edited allowed line beside a committed short line lost its entry",
+            )
+        (top / "lib.rs").write_text("/// ```console\n/// $ ls `\n///     -l\n/// ```\n")
+        subprocess.run([*git, "add", "lib.rs"], check=True)
+        shells = run('doc_comments = ["lib.rs"]\nallow_ceiling = 0\n')
+        expect(
+            "lib.rs:2: this `$ ` command is continued with a backtick" in shells,
+            "a doc-comment console fence continued the other shell's way passed",
+        )
+        subprocess.run([*git, "rm", "-q", "--cached", "lib.rs"], check=True)
+        (top / "lib.rs").unlink()
+        labelled = f"session.name();  // → {'d' * 80}"
+        (top / "README.md").write_text(f"```java\n{labelled}\n```\n")
+        told = run('markdown = ["README.md"]\nallow_ceiling = 0\n')
+        expect(
+            "Keep the code and its marker on one line" in told
+            and told.split("\n[[allow]]")[0].count("[[allow]]") == 1,
+            "a trailing marker line's advice named [[allow]] twice",
+        )
+        output = f"// Output: {'o' * 80}"
+        (top / "README.md").write_text(f"```go\n{edited}\n{output}\n```\n")
+        marked = run(
+            'markdown = ["README.md"]\nallow_ceiling = 1\n[[allow]]\n'
+            f'path = "README.md"\nline = "{allowed}"\nreason = "r"\n'
+        )
+        expect(
+            "#what-never-breaks); add the first other wide line to [[allow]]" in marked,
+            "a marker line after an edited allowed line named [[allow]] twice",
+        )
+        second = "print(count, " + "z" * 80 + ")"
+        moved = second.replace("count", "counts")
+        (top / "README.md").write_text(f"```py\n{edited}\n{moved}\n```\n")
+        both = run(
+            'markdown = ["README.md"]\nallow_ceiling = 2\n[[allow]]\n'
+            f'path = "README.md"\nline = "{allowed}"\nreason = "r"\n'
+            f'[[allow]]\npath = "README.md"\nline = "{second}"\nreason = "r"\n'
+        )
+        expect(
+            "[[allow]]" not in both
+            and f'line = "{moved}"' in both
+            and "allow_ceiling stays 2" in both,
+            "two allowed lines edited in one file were not both paired",
+        )
+        (top / "notes.md").write_text("x\n")
+        subprocess.run([*git, "add", "notes.md"], check=True)
+        (top / "README.md").write_text(f"```py\n{allowed}\n```\n")
+        unread = run(
+            'markdown = ["notes.md"]\nallow_ceiling = 1\n[[allow]]\n'
+            f'path = "README.md"\nline = "{allowed}"\nreason = "r"\n'
+        )
+        expect(
+            "no longer reads it as wide" in unread and "Delete" not in unread,
+            "an allowed line a glob change hid was offered for deletion",
+        )
+        (top / "README.md").write_text("```py\nprint(1)\n```\n")
+        fits = run(
+            'markdown = ["README.md"]\nallow_ceiling = 1\n[[allow]]\n'
+            'path = "README.md"\nline = "print(1)"\nreason = "r"\n'
+        )
+        expect(
+            "Delete the stale allow entry for README.md" in fits
+            and "names a line that now fits in 80" in fits
+            and "no longer reads" not in fits,
+            "an allowed line that now fits was not offered for deletion",
+        )
+        (top / "README.md").write_text(f"```py\n{allowed}\n```\n")
+        (top / "examples").mkdir()
+        (top / "examples" / "new.txt").write_text("x\n")
+        expect(
+            "examples/new.txt: untracked, under examples/ but selected by no glob; "
+            '`git add` it, then add "examples/new.txt" to sources'
+            in run('markdown = ["README.md"]\nallow_ceiling = 0\nwidth = 1\n'),
+            "an untracked, unselected example file went unnamed",
+        )
+        (top / "README.md").write_text("```console\n$ ls `\n  -l\n```\n")
+        expect(
+            "is continued with a backtick"
+            in run('markdown = ["README.md"]\nallow_ceiling = 0\n'),
+            "a run left a `$ ` command continued with a backtick unreported",
+        )
+    print("self-test:", "failed" if failures else "ok")
+    return 1 if failures else 0
+
+
+def main(argv: list[str] | None = None) -> int:
+    """Check the repository, or run the self-test."""
+    parser = argparse.ArgumentParser(description=__doc__.splitlines()[0])
+    parser.add_argument(
+        "--self-test", action="store_true", help="prove the checker can fail"
+    )
+    parser.add_argument(
+        "--digest",
+        action="store_true",
+        help="print digests of this checker and the shared WRITING.md section",
+    )
+    parser.add_argument(
+        "--root", type=pathlib.Path, help="repository root (default: git toplevel)"
+    )
+    args = parser.parse_args(argv)
+    if args.self_test:
+        return self_test()
+    root = args.root or pathlib.Path(
+        subprocess.run(
+            ["git", "rev-parse", "--show-toplevel"],
+            check=True,
+            capture_output=True,
+            text=True,
+        ).stdout.strip()
+    )
+    if args.digest:
+        for line in digests(root):
+            print(line)
+        return 0
+    try:
+        config = tomllib.loads((root / CONFIG).read_text(encoding="utf-8"))
+    except (OSError, tomllib.TOMLDecodeError) as error:
+        print(f"{CONFIG}: cannot read the config: {error}")
+        print("1 setup problem; fix the config first.")
+        return 1
+    wrong = type_problems(config)
+    if wrong:
+        for problem in wrong:
+            print(f"{CONFIG}: {problem}")
+        print(f"{plural(len(wrong), 'setup problem')}; fix the config first.")
+        return 1
+    files = tracked_files(root)
+    writing = writing_path(root)
+    # Each problem names the file to change; routing problems name their own.
+    setup = config_problems(config, files)
+    problems = (
+        [f"{CONFIG}: {problem}" for problem in setup]
+        + copy_problems(root, config)
+        + digest_problems(root, config)
+        + marker_problems(root)
+        + routing_problems(root)
+    )
+    new = untracked_matches(config, tracked_files(root, others=True))
+    chosen = [path for path in new if selected(config, path)]
+    shown = ", ".join(chosen[:3]) + (", ..." if len(chosen) > 3 else "")
+    notice = (
+        f"Not checked until `git add`: {plural(len(chosen), 'untracked file')} "
+        f"the config selects ({shown})."
+        if chosen
+        else ""
+    )
+    # An untracked file does not fail the run, but its wide lines are shown
+    # so a new example can be fixed before it is added.
+    pending, _ = check(root, config, chosen) if chosen and not setup else ([], [])
+    if pending:
+        they = "it fails" if len(chosen) == 1 else "they fail"
+        notice += f" Once added, {they} on {plural(len(pending), 'wide line')}: " + (
+            "; ".join(str(finding) for finding in pending[:3])
+        )
+    notice = "\n".join(
+        [notice] * bool(notice)
+        + [
+            f"{path}: untracked, under examples/ but selected by no glob; `git add` "
+            "it, then " + select_advice(path)
+            for path in new
+            if path not in chosen
+        ]
+    )
+    bad_path = None
+    if writing:
+        where = writing.relative_to(root).as_posix()
+        text = writing.read_text(encoding="utf-8")
+        block = port_block_problems(text)
+        problems += [f"{where}: {problem}" for problem in block]
+        bad_path = where if any("Bad example fits" in p for p in block) else None
+    # A config problem such as a misspelled glob key would make allow entries
+    # look stale, so the width pass waits until the config is right.
+    findings, stale = check(root, config, files) if not setup else ([], [])
+    problems += prompt_problems(root, config, files) if not setup else []
+    annotate = os.environ.get("GITHUB_ACTIONS") == "true"
+    for problem in problems:
+        print(problem)
+    for finding in findings:
+        print(finding)
+        if annotate:
+            print(
+                f"::error file={finding.path},line={finding.number}::"
+                f"{finding.columns} columns > {finding.width}"
+            )
+    # A line still in its file is hidden only while it is still wide; one that
+    # now fits needs its entry deleted.
+    width, tab_width = config.get("width", 80), config.get("tab_width", 4)
+    present = [entry for entry in stale if entry["line"] in source_lines(root, entry)]
+    hidden = [
+        entry
+        for entry in present
+        if columns(entry["line"].expandtabs(tab_width)) > width
+    ]
+    absent = [entry for entry in stale if entry not in present]
+    shortened = shortened_entries(root, absent, width, tab_width) if absent else []
+    for entry in stale:
+        how = (
+            "names a line the check no longer reads"
+            if entry in hidden
+            else f"names a line that now fits in {width}"
+            if entry in present
+            else f"names a line shortened to fit in {width}"
+            if entry in shortened
+            else "matches no line"
+        )
+        print(
+            f"{CONFIG}: allow entry for {entry['path']} {how}: {quoted(entry['line'])}"
+        )
+    if problems or findings or stale:
+        page = writing or writing_file(root)
+        rules = page.relative_to(root).as_posix() if page else "WRITING.md"
+        print(
+            f"{plural(len(problems), 'problem')}, "
+            f"{plural(len(findings), 'wide line')}, "
+            f"{plural(len(stale), 'stale allow entry', 'stale allow entries')}."
+        )
+        if setup:
+            print(f"The width check runs once the problems in {CONFIG} are fixed.")
+        edited = ""
+        # Name an entry by its line when its file has two allow entries.
+        allowed = [e for e in config.get("allow", []) if isinstance(e, dict)]
+        if findings:
+            first = findings[0]
+            many = len(findings) > 1
+            pairs = edit_pairs(findings, stale, bad_path, shortened)
+            if pairs:
+                # An allowed line changed: its entry already says why it stays
+                # whole, so it takes the new text.
+                first, edited = pairs[0][0], pairs[0][0].path
+                named = entry_name(pairs[0][1], allowed)
+                print(
+                    f"{edited}: an allowed line changed; its entry says why it stays "
+                    f"whole. Put its new text in the stale entry for {named} (if the "
+                    "line is new instead, give it an entry of its own):"
+                )
+            else:
+                lead = (
+                    f"The first of {len(findings)}, as an entry:"
+                    if many
+                    else "As an entry:"
+                )
+                advice = fix_advice(first, rules)
+                if "[[allow]]" in advice and not advice.startswith(kept_whole(rules)):
+                    # The advice already says when to allow the line.
+                    print(advice)
+                    print(lead)
+                elif advice.startswith(kept_whole(rules)):
+                    # The rule itself says to allow it; say [[allow]] once.
+                    print(
+                        f"{kept_whole(rules)}; add the line to [[allow]] in "
+                        f"{CONFIG} with its reason. {lead}"
+                    )
+                else:
+                    print(advice)
+                    print(
+                        "If no change keeps the example clear, add the line to "
+                        f"[[allow]] in {CONFIG} with a reason. {lead}"
+                    )
+            hint = allow_hint(first)
+            print(hint.splitlines()[2] if edited else hint)
+            for finding, entry in pairs[1:]:
+                print(f"In the stale entry for {entry_name(entry, allowed)}, put:")
+                print(allow_hint(finding).splitlines()[2])
+            paired = [finding for finding, _ in pairs]
+            others = [finding for finding in findings if finding not in paired]
+            if edited and others:
+                advice = fix_advice(others[0], rules)
+                if advice.startswith(kept_whole(rules)):
+                    print(
+                        f"{kept_whole(rules)}; add the first other wide line to "
+                        f"[[allow]] in {CONFIG} with its reason:"
+                    )
+                else:
+                    print(advice)
+                    print(
+                        "If no change keeps the example clear, add the first "
+                        f"other wide line to [[allow]] in {CONFIG}:"
+                    )
+                print(allow_hint(others[0]))
+        if findings or stale:
+            count = len(config.get("allow", []))
+            for hint in ceiling_hints(
+                findings, stale, count, bad_path, hidden, allowed, shortened
+            ):
+                if not (edited and "an allowed line changed" in hint):
+                    print(hint)
+        if notice:
+            print(notice)
+        return 1
+    read = [g for key in GLOB_KEYS for g in config.get(key, [])]
+    skip = [entry["glob"] for entry in entries(config, "exclude")]
+    count = sum(matches(path, read) and not matches(path, skip) for path in files)
+    print(f"{count} files checked; no example is over {config.get('width', 80)}.")
+    if notice:
+        print(notice)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/check_shared_examples.py b/scripts/check_shared_examples.py
new file mode 100644
index 000000000..2b63b033a
--- /dev/null
+++ b/scripts/check_shared_examples.py
@@ -0,0 +1,414 @@
+#!/usr/bin/env python3
+"""Fail when a libtmux port's shared example rules differ from this repo's.
+
+Every port carries a copy of ``check_example_width.py`` and the text between
+the ``shared:examples`` markers in WRITING.md. The rule is to change both in
+all ports together. This script fetches each port's copy from the default
+branch on raw.githubusercontent.com, digests it the way
+``check_example_width.py --digest`` does, and compares the result with this
+repository's own files.
+
+A port with a missing checker or shared section fails, unless it is listed in
+``PENDING`` with the reason it cannot be read yet and the date it was listed;
+a pending port passes with a notice. A pending port whose checker and shared
+section are both present fails until it leaves ``PENDING``, a port listed for
+more than ``PENDING_DAYS`` days fails, so the list cannot go stale quietly,
+and a port whose file differs fails. Remove a port from ``PENDING`` when its
+example-style change merges.
+
+To roll out a change to the shared text or the checker, record the digests
+the ports still carry in ``PREVIOUS`` with the last day they are accepted:
+a port on that version passes with a notice until then, so ports can merge
+one at a time, and fails after it.
+
+``NOT_FETCHED`` lists a port this script cannot read, such as a private
+repository whose raw files return 404 without a token, with the reason and
+where that port is compared instead; this script prints a notice for it
+rather than fetching. Every port is public, so the list is empty.
+
+A repository of the libtmux organisation that is neither listed nor this
+one is looked up through the GitHub REST API (``GET /orgs/libtmux/repos``,
+public and not archived, paginated; ``GITHUB_TOKEN`` is sent as a bearer
+token when set). If its ``.github/WRITING.md`` or ``WRITING.md`` carries the
+``shared:examples`` markers, the script fails with "<repo> carries the
+shared example section but is not in PORTS", so a new adopter cannot go
+uncompared.
+
+It needs the network, so it runs in CI only, never in the local test loops;
+``--self-test`` needs none.
+"""
+
+from __future__ import annotations
+
+import argparse
+import datetime
+import hashlib
+import json
+import os
+import pathlib
+import sys
+import typing as t
+import urllib.error
+import urllib.request
+
+sys.path.insert(0, str(pathlib.Path(__file__).resolve().parent))
+# Importing the checker must not leave a __pycache__ beside it.
+sys.dont_write_bytecode = True
+import check_example_width as width  # noqa: E402
+
+CHECKER = "check_example_width.py"
+# repository -> (directory holding the checker, path of WRITING.md)
+PORTS: dict[str, tuple[str, str]] = {
+    "libtmux/libtmux-cxx": ("tools/docs", ".github/WRITING.md"),
+    "libtmux/libtmux-dotnet": ("eng/docs", ".github/WRITING.md"),
+    "libtmux/libtmux-go": ("internal/tools", ".github/WRITING.md"),
+    "libtmux/libtmux-java": ("tools", ".github/WRITING.md"),
+    "libtmux/libtmux-julia": ("dev", "WRITING.md"),
+    "libtmux/libtmux-lua": ("scripts", ".github/WRITING.md"),
+    "libtmux/libtmux-powershell": ("eng", ".github/WRITING.md"),
+    "libtmux/libtmux-rs": ("scripts", ".github/WRITING.md"),
+    "libtmux/libtmux-ruby": ("scripts", ".github/WRITING.md"),
+    "libtmux/libtmux-swift": ("Scripts", ".github/WRITING.md"),
+    "libtmux/libtmux-ts": ("scripts", ".github/WRITING.md"),
+    "tmux-python/libtmux": ("scripts", ".github/WRITING.md"),
+}
+# Ports this script never fetches, with the reason and where they are checked.
+NOT_FETCHED: dict[str, str] = {}
+# During a change to the shared text or checker: the digest ports may still
+# carry for each file ("checker" or "shared section"), and the last day it is
+# accepted. Empty between changes.
+PREVIOUS: dict[str, tuple[str, datetime.date]] = {
+    # libtmux-powershell merged this checker before its marker-fallback fix.
+    "checker": (
+        "f261e9a3ef44101ead5fe1ce03331716372aac828f7421ef8f06c83c987ee956",
+        datetime.date(2026, 11, 10),
+    ),
+    # libtmux-powershell merged the shared section before its copy-step wording.
+    "shared section": (
+        "872d3f4cb1eb2b5cd9c5b7adc9cd140a153e4bbed3cb5bd0b7400a905e6dae4d",
+        datetime.date(2026, 11, 10),
+    ),
+}
+# Ports whose missing files are expected: the reason and the date listed.
+PENDING_DAYS = 30
+_UNMERGED = ("example-style change not merged yet", datetime.date(2026, 10, 4))
+PENDING: dict[str, tuple[str, datetime.date]] = {
+    "libtmux/libtmux-cxx": _UNMERGED,
+    "libtmux/libtmux-dotnet": _UNMERGED,
+    "libtmux/libtmux-go": _UNMERGED,
+    "libtmux/libtmux-java": _UNMERGED,
+    "libtmux/libtmux-julia": _UNMERGED,
+    "libtmux/libtmux-lua": _UNMERGED,
+    "libtmux/libtmux-rs": _UNMERGED,
+    "libtmux/libtmux-ruby": _UNMERGED,
+    "libtmux/libtmux-swift": _UNMERGED,
+    "libtmux/libtmux-ts": _UNMERGED,
+    "tmux-python/libtmux": _UNMERGED,
+}
+OWN_REPO = "libtmux/docs"
+ORG = "libtmux"
+ORG_REPOS = "https://api.github.com/orgs/{org}/repos?type=public&per_page=100&page={page}"
+WRITING_PATHS = (".github/WRITING.md", "WRITING.md")
+RAW = "https://raw.githubusercontent.com/{repo}/HEAD/{path}"
+
+Fetch = t.Callable[[str, str], t.Optional[bytes]]
+ListRepos = t.Callable[[], list[str]]
+
+
+def fetch_raw(repo: str, path: str) -> bytes | None:
+    """Return a file from the repo's default branch, or None when absent."""
+    request = urllib.request.Request(RAW.format(repo=repo, path=path))
+    try:
+        with urllib.request.urlopen(request, timeout=30) as response:
+            return response.read()
+    except urllib.error.HTTPError as error:
+        if error.code == 404:
+            return None
+        raise
+
+
+def list_org_repos() -> list[str]:
+    """Return ``org/name`` for each public, non-archived organisation repo."""
+    headers = {"Accept": "application/vnd.github+json"}
+    token = os.environ.get("GITHUB_TOKEN")
+    if token:
+        headers["Authorization"] = f"Bearer {token}"
+    names: list[str] = []
+    page = 1
+    while True:
+        request = urllib.request.Request(
+            ORG_REPOS.format(org=ORG, page=page), headers=headers
+        )
+        with urllib.request.urlopen(request, timeout=30) as response:
+            repos = json.load(response)
+        names += [r["full_name"] for r in repos if not r["archived"]]
+        if len(repos) < 100:
+            return names
+        page += 1
+
+
+def unlisted_adopters(
+    ports: dict[str, tuple[str, str]],
+    list_repos: ListRepos,
+    fetch: Fetch,
+    own_repo: str = OWN_REPO,
+) -> list[str]:
+    """Return a failure for each unlisted repo that carries the markers."""
+    failures: list[str] = []
+    for repo in sorted(list_repos()):
+        if repo == own_repo or repo in ports:
+            continue
+        for path in WRITING_PATHS:
+            if shared_digest(fetch(repo, path)) is not None:
+                failures.append(
+                    f"{repo} carries the shared example section "
+                    "but is not in PORTS"
+                )
+                break
+    return failures
+
+
+def shared_digest(writing: bytes | None) -> str | None:
+    """Digest the shared section of a WRITING.md the way --digest does."""
+    if writing is None:
+        return None
+    match = width.SHARED.search(writing.decode("utf-8"))
+    if not match:
+        return None
+    return hashlib.sha256(match["body"].encode()).hexdigest()
+
+
+def checker_digest(checker: bytes | None) -> str | None:
+    return None if checker is None else hashlib.sha256(checker).hexdigest()
+
+
+def local_digests(root: pathlib.Path) -> tuple[str | None, str | None]:
+    checker = root / "scripts" / CHECKER
+    writing = root / "WRITING.md"
+    return (
+        checker_digest(checker.read_bytes()),
+        shared_digest(writing.read_bytes() if writing.is_file() else None),
+    )
+
+
+def compare(
+    own: tuple[str | None, str | None],
+    ports: dict[str, tuple[str, str]],
+    fetch: Fetch,
+    pending: dict[str, tuple[str, datetime.date]] | None = None,
+    not_fetched: dict[str, str] | None = None,
+    today: datetime.date | None = None,
+    previous: dict[str, tuple[str, datetime.date]] | None = None,
+) -> tuple[list[str], list[str]]:
+    """Return (failures, notices) for every port against ``own``.
+
+    A missing file is a failure unless the port is in ``pending``, and a
+    pending port with both files present is a failure too. A port in
+    ``not_fetched`` is never fetched and gives a notice.
+    """
+    pending = pending or {}
+    not_fetched = not_fetched or {}
+    previous = previous or {}
+    today = today or datetime.datetime.now(datetime.UTC).date()
+    failures: list[str] = [
+        f"{repo}: in PENDING but not in PORTS" for repo in sorted(set(pending) - set(ports))
+    ]
+    notices: list[str] = []
+    for repo, (_, since) in sorted(pending.items()):
+        if (today - since).days > PENDING_DAYS:
+            failures.append(
+                f"{repo}: pending since {since}, more than {PENDING_DAYS} days; "
+                "merge its example-style change or update the reason and date"
+            )
+    for repo, (directory, writing_path) in sorted(ports.items()):
+        if repo in not_fetched:
+            notices.append(f"{repo}: not fetched ({not_fetched[repo]})")
+            continue
+        theirs = (
+            checker_digest(fetch(repo, f"{directory}/{CHECKER}")),
+            shared_digest(fetch(repo, writing_path)),
+        )
+        if repo in pending and None not in theirs:
+            failures.append(f"{repo}: both files present; remove it from PENDING")
+            continue
+        for label, mine, other, path in (
+            ("checker", own[0], theirs[0], f"{directory}/{CHECKER}"),
+            ("shared section", own[1], theirs[1], writing_path),
+        ):
+            if other is None and repo in pending:
+                reason, since = pending[repo]
+                notices.append(f"{repo}: no {label} at {path} ({reason}, since {since})")
+            elif other is None:
+                failures.append(f"{repo}: no {label} at {path}, and not pending")
+            elif other != mine and label in previous and other == previous[label][0]:
+                until = previous[label][1]
+                said = f"{repo}: {label} in {path} is the previous version, accepted"
+                if today > until:
+                    failures.append(f"{said} only until {until}")
+                else:
+                    notices.append(f"{said} until {until}")
+            elif other != mine:
+                failures.append(
+                    f"{repo}: {label} in {path} differs "
+                    f"(theirs {other[:12]}, ours {str(mine)[:12]})"
+                )
+    return failures, notices
+
+
+def summary(failures: list[str]) -> str:
+    """Return the closing line of a failed run, naming what to change.
+
+    >>> summary(["a/one: checker in x differs (theirs 1, ours 2)"])
+    '1 file differs; change the shared rules in every port together'
+    >>> summary(["a: both files present; remove it from PENDING"] * 2)
+    '2 list entries are out of date; edit PORTS, PENDING or PREVIOUS as each line says'
+    """
+    drift = sum(" differs " in f or " only until " in f for f in failures)
+    stale = len(failures) - drift
+    parts = []
+    if drift:
+        files = "1 file differs" if drift == 1 else f"{drift} files differ"
+        parts.append(f"{files}; change the shared rules in every port together")
+    if stale:
+        entries = "1 list entry is" if stale == 1 else f"{stale} list entries are"
+        parts.append(
+            f"{entries} out of date; edit PORTS, PENDING or PREVIOUS as each line says"
+        )
+    return ". ".join(parts)
+
+
+def self_test() -> int:
+    """Plant a mismatch and a missing file, then clean controls."""
+    problems: list[str] = []
+
+    def expect(ok: bool, what: str) -> None:
+        if not ok:
+            problems.append(what)
+
+    marked = b"x\n<!-- shared:examples -->\nrules\n<!-- /shared:examples -->\n"
+    own = (checker_digest(b"checker"), shared_digest(marked))
+    expect(own[1] is not None, "markers were not found in the control text")
+    ports = {"a/one": ("scripts", "WRITING.md")}
+
+    def serve(files: dict[str, bytes]) -> Fetch:
+        return lambda repo, path: files.get(path)
+
+    clean = {"scripts/" + CHECKER: b"checker", "WRITING.md": marked}
+    failures, notices = compare(own, ports, serve(clean))
+    expect(not failures and not notices, "a matching port was reported")
+
+    drifted = dict(clean, **{"scripts/" + CHECKER: b"edited checker"})
+    failures, _ = compare(own, ports, serve(drifted))
+    expect(len(failures) == 1 and "checker" in failures[0], "checker drift passed")
+
+    edited = dict(clean, **{"WRITING.md": marked.replace(b"rules", b"other")})
+    failures, _ = compare(own, ports, serve(edited))
+    expect(len(failures) == 1 and "shared" in failures[0], "text drift passed")
+
+    failures, notices = compare(own, ports, serve({}))
+    expect(len(failures) == 2 and not notices, "a missing file passed")
+
+    today = datetime.date(2026, 10, 4)
+    waiting = {"a/one": ("not merged", today)}
+    failures, notices = compare(own, ports, serve({}), waiting, today=today)
+    expect(not failures and len(notices) == 2, "a pending port failed")
+
+    later = today + datetime.timedelta(days=PENDING_DAYS + 1)
+    failures, _ = compare(own, ports, serve({}), waiting, today=later)
+    expect(len(failures) == 1 and "pending since" in failures[0], "a stale entry passed")
+
+    rolling = {"checker": (checker_digest(b"edited checker") or "", today)}
+    failures, notices = compare(
+        own, ports, serve(drifted), today=today, previous=rolling
+    )
+    expect(not failures and len(notices) == 1, "the previous checker failed early")
+    failures, _ = compare(own, ports, serve(drifted), today=later, previous=rolling)
+    expect(len(failures) == 1 and "only until" in failures[0], "an expired version passed")
+
+    stray = {"b/two": ("not merged", today)}
+    failures, _ = compare(own, ports, serve(clean), stray, today=today)
+    expect(failures == ["b/two: in PENDING but not in PORTS"], "an unknown entry passed")
+
+    half = {"scripts/" + CHECKER: b"edited checker"}
+    failures, notices = compare(own, ports, serve(half), waiting, today=today)
+    expect(
+        len(failures) == 1 and "differs" in failures[0] and len(notices) == 1,
+        "a pending port with drift passed",
+    )
+
+    failures, notices = compare(own, ports, serve(clean), waiting, today=today)
+    expect(
+        len(failures) == 1 and "remove it from PENDING" in failures[0],
+        "a pending port with both files present passed",
+    )
+    expect(not notices, "a pending port with both files gave a notice")
+
+    def refuse(repo: str, path: str) -> bytes | None:
+        raise AssertionError(f"fetched {repo}")
+
+    private = {"a/one": "private; checked by its own job"}
+    failures, notices = compare(own, ports, refuse, None, private)
+    expect(not failures and len(notices) == 1, "a not-fetched port failed")
+    expect("own job" in "".join(notices), "the not-fetched notice lost its reason")
+
+    unmarked = dict(clean, **{"WRITING.md": b"no markers"})
+    failures, notices = compare(own, ports, serve(unmarked))
+    expect(len(failures) == 1 and not notices, "a port without markers passed")
+
+    stranger = {"a/new": {".github/WRITING.md": marked}, "a/plain": {}}
+
+    def stranger_fetch(repo: str, path: str) -> bytes | None:
+        return stranger[repo].get(path)
+
+    def listing() -> list[str]:
+        return ["a/one", "libtmux/docs", "a/new", "a/plain"]
+
+    failures = unlisted_adopters(ports, listing, stranger_fetch)
+    expect(
+        failures == ["a/new carries the shared example section but is not in PORTS"],
+        "an unlisted adopter passed, or a listed or unmarked repo failed",
+    )
+
+    import doctest
+
+    if doctest.testmod(sys.modules[__name__]).failed:
+        problems.append("a doctest failed")
+    for problem in problems:
+        print(f"self-test: {problem}", file=sys.stderr)
+    if not problems:
+        print("self-test: ok")
+    return 1 if problems else 0
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--self-test", action="store_true", help="run without network")
+    parser.add_argument("--root", type=pathlib.Path, help="this repository's root")
+    args = parser.parse_args()
+    if args.self_test:
+        return self_test()
+    root = args.root or pathlib.Path(__file__).resolve().parent.parent
+    own = local_digests(root)
+    if None in own:
+        print("this repository lacks the checker or the shared section", file=sys.stderr)
+        return 1
+    failures, notices = compare(own, PORTS, fetch_raw, PENDING, NOT_FETCHED, previous=PREVIOUS)
+    failures += unlisted_adopters(PORTS, list_org_repos, fetch_raw)
+    for notice in notices:
+        print(f"notice: {notice}")
+    for failure in failures:
+        print(f"error: {failure}", file=sys.stderr)
+    if failures:
+        print(summary(failures), file=sys.stderr)
+        return 1
+    compared = [repo for repo in PORTS if repo not in PENDING and repo not in NOT_FETCHED]
+    print(
+        f"{len(compared)} port{'' if len(compared) == 1 else 's'} compared, "
+        f"{len(PENDING)} pending, "
+        f"{len(NOT_FETCHED)} not fetched, {len(notices)} notices"
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/crawl-site.mjs b/scripts/crawl-site.mjs
index 477c0fa24..f1b5baeea 100644
--- a/scripts/crawl-site.mjs
+++ b/scripts/crawl-site.mjs
@@ -4,23 +4,33 @@ const refs = new Map()
 const queue = ['/']
 const SKIP = /\.(woff2?|ttf|eot|png|jpe?g|gif|svg|ico|css|js|json|xml|inv|txt|map|pf_meta|pf_index|pf_fragment|wasm)$/i
 
-function note(t, f) { (refs.get(t) ?? refs.set(t, new Set()).get(t)).add(f) }
+function note(t, f) {
+  ;(refs.get(t) ?? refs.set(t, new Set()).get(t)).add(f)
+}
 
 while (queue.length) {
   const path = queue.shift()
   if (seen.has(path)) continue
-  let res, body = ''
+  let res,
+    body = ''
   try {
     res = await fetch(ROOT + path)
     seen.set(path, res.status)
     if ((res.headers.get('content-type') || '').includes('text/html')) body = await res.text()
-  } catch { seen.set(path, 'ERR'); continue }
+  } catch {
+    seen.set(path, 'ERR')
+    continue
+  }
   if (!body) continue
   for (const m of body.matchAll(/(?:href|src)="([^"]+)"/g)) {
     const raw = m[1]
     if (/^(https?:|mailto:|#|data:|javascript:)/i.test(raw)) continue
     let u
-    try { u = new URL(raw, ROOT + path) } catch { continue }
+    try {
+      u = new URL(raw, ROOT + path)
+    } catch {
+      continue
+    }
     if (u.origin !== ROOT) continue
     const p = u.pathname
     if (SKIP.test(p)) continue
diff --git a/scripts/fetch-inventories.mjs b/scripts/fetch-inventories.mjs
index ff2c2c8e6..215c48a4c 100644
--- a/scripts/fetch-inventories.mjs
+++ b/scripts/fetch-inventories.mjs
@@ -89,7 +89,9 @@ for (const [name, url] of Object.entries(SOURCES)) {
     const { project, entries } = readInventory(bytes)
     writeFileSync(out, bytes)
     writeSidecar(name, bytes)
-    console.log(`fetch-inventories: ${name} -> ${entries.length} entries (${project}) ${(bytes.length / 1024).toFixed(0)} KB`)
+    console.log(
+      `fetch-inventories: ${name} -> ${entries.length} entries (${project}) ${(bytes.length / 1024).toFixed(0)} KB`,
+    )
   } catch (err) {
     console.error(`fetch-inventories: ${name} failed — ${err.message}`)
     failed++
diff --git a/scripts/gen-api-model.mjs b/scripts/gen-api-model.mjs
index e4915181e..2e242edb2 100644
--- a/scripts/gen-api-model.mjs
+++ b/scripts/gen-api-model.mjs
@@ -75,13 +75,16 @@ function git(repo, ...args) {
 
 /** Read package versions from their owning manifest, independent of docs URL labels. */
 function packageVersion(checkout, port, product) {
-  const read = (file) => existsSync(join(checkout, file)) ? readFileSync(join(checkout, file), 'utf8') : ''
+  const read = (file) => (existsSync(join(checkout, file)) ? readFileSync(join(checkout, file), 'utf8') : '')
   if (port === 'py') return /^version\s*=\s*"([^"]+)"/m.exec(read('pyproject.toml'))?.[1]
-  if (port === 'ts') return JSON.parse(read(`packages/${product === 'core' ? 'libtmux' : product}/package.json`)).version
+  if (port === 'ts')
+    return JSON.parse(read(`packages/${product === 'core' ? 'libtmux' : product}/package.json`)).version
   if (port === 'rs') {
     const crate = product === 'core' ? 'libtmux' : product === 'workspace' ? 'tmux-workspace' : 'tmux-mcp'
-    return /^version\s*=\s*"([^"]+)"/m.exec(read(`crates/${crate}/Cargo.toml`))?.[1]
-      ?? /^version\s*=\s*"([^"]+)"/m.exec(read('Cargo.toml'))?.[1]
+    return (
+      /^version\s*=\s*"([^"]+)"/m.exec(read(`crates/${crate}/Cargo.toml`))?.[1] ??
+      /^version\s*=\s*"([^"]+)"/m.exec(read('Cargo.toml'))?.[1]
+    )
   }
   if (['java', 'kotlin', 'scala'].includes(port)) return /^libtmuxVersion=(.+)$/m.exec(read('gradle.properties'))?.[1]
   if (['csharp', 'fsharp'].includes(port)) {
@@ -214,13 +217,17 @@ const PORTS = {
   },
   powershell: {
     checkout: '~/work/libtmux/libtmux-powershell-docs-site',
-    root: '.', nativeArtifact: 'build/docs/api.json',
-    repo: 'libtmux/libtmux-powershell', options: {},
+    root: '.',
+    nativeArtifact: 'build/docs/api.json',
+    repo: 'libtmux/libtmux-powershell',
+    options: {},
   },
   julia: {
     checkout: '~/work/libtmux/libtmux-julia-docs-site',
-    root: '.', nativeArtifact: 'docs/build/api.json',
-    repo: 'libtmux/libtmux-julia', options: {},
+    root: '.',
+    nativeArtifact: 'docs/build/api.json',
+    repo: 'libtmux/libtmux-julia',
+    options: {},
   },
   lua: {
     checkout: '~/work/libtmux/libtmux-lua-docs',
@@ -253,8 +260,13 @@ const PORTS = {
   },
   java: {
     checkout: '~/work/libtmux/libtmux-java',
-    roots: ['libtmux/src/main/java', 'libtmux/build/generated/sources/fieldCatalog/java/main',
-      'libtmux-workspace/src/main/java', 'libtmux-jackson/src/main/java', 'libtmux-junit5/src/main/java'],
+    roots: [
+      'libtmux/src/main/java',
+      'libtmux/build/generated/sources/fieldCatalog/java/main',
+      'libtmux-workspace/src/main/java',
+      'libtmux-jackson/src/main/java',
+      'libtmux-junit5/src/main/java',
+    ],
     generate: [':libtmux:generateFieldMetamodel'],
     generateWhen: 'build-logic/conventions/src/main/kotlin/libtmux.field-catalog.gradle.kts',
     repo: 'libtmux/libtmux-java',
@@ -271,23 +283,35 @@ const PORTS = {
     roots: ['libtmux-kotlin/src/main/kotlin', 'libtmux-kotlin/build/generated/sources/operations/kotlin'],
     generate: [':libtmux-kotlin:generateOperationWrappers'],
     pathRoots: ['libtmux-kotlin/', 'docs/guide/kotlin.md', 'examples/src/main/kotlin/'],
-    repo: 'libtmux/libtmux-java', options: {},
+    repo: 'libtmux/libtmux-java',
+    options: {},
   },
   scala: {
     checkout: '~/work/libtmux/libtmux-java',
-    roots: ['libtmux-scala/src/main/scala', 'libtmux-scala/build/generated/sources/catalog/scala',
-      'libtmux-scala-cats/src/main/scala', 'libtmux-scala-cats/build/generated/sources/catalog/scala',
-      'libtmux-scala-ox/src/main/scala'],
+    roots: [
+      'libtmux-scala/src/main/scala',
+      'libtmux-scala/build/generated/sources/catalog/scala',
+      'libtmux-scala-cats/src/main/scala',
+      'libtmux-scala-cats/build/generated/sources/catalog/scala',
+      'libtmux-scala-ox/src/main/scala',
+    ],
     generate: [':libtmux-scala:generateScalaSources', ':libtmux-scala-cats:generateScalaSources'],
-    pathRoots: ['libtmux-scala/', 'libtmux-scala-cats/', 'libtmux-scala-ox/',
-      'docs/guide/scala/', 'examples/src/main/scala/'],
-    repo: 'libtmux/libtmux-java', options: {},
+    pathRoots: [
+      'libtmux-scala/',
+      'libtmux-scala-cats/',
+      'libtmux-scala-ox/',
+      'docs/guide/scala/',
+      'examples/src/main/scala/',
+    ],
+    repo: 'libtmux/libtmux-java',
+    options: {},
   },
   fsharp: {
     checkout: '~/work/libtmux/libtmux-dotnet',
     root: 'src/LibTmux.FSharp',
     pathRoots: ['src/LibTmux.FSharp/', 'docs/fsharp/', 'examples/LibTmux.FSharp.'],
-    repo: 'libtmux/libtmux-dotnet', options: {},
+    repo: 'libtmux/libtmux-dotnet',
+    options: {},
   },
   // C++ comes from the Doxygen XML this project's own build already produces:
   // tree-sitter has no preprocessor, so `LIBTMUX_NAMESPACE_BEGIN` derails the
@@ -311,7 +335,8 @@ const PORTS = {
       dir: 'symbolgraph',
       from: 'Sources',
       what: 'symbol graph',
-      build: 'swift build --enable-all-traits -Xswiftc -emit-symbol-graph -Xswiftc -emit-symbol-graph-dir -Xswiftc "$PWD/symbolgraph"',
+      build:
+        'swift build --enable-all-traits -Xswiftc -emit-symbol-graph -Xswiftc -emit-symbol-graph-dir -Xswiftc "$PWD/symbolgraph"',
     },
     repo: 'libtmux/libtmux-swift',
     options: {},
@@ -319,13 +344,18 @@ const PORTS = {
 }
 
 const args = process.argv.slice(2)
-const repositoryPaths = (tree, cfg) => tree.split('\n').filter((path) =>
-  path && (!cfg.pathRoots || !path.includes('/') || cfg.pathRoots.some((prefix) => path.startsWith(prefix))))
+const repositoryPaths = (tree, cfg) =>
+  tree
+    .split('\n')
+    .filter(
+      (path) =>
+        path && (!cfg.pathRoots || !path.includes('/') || cfg.pathRoots.some((prefix) => path.startsWith(prefix))),
+    )
 const only = args.includes('--port') ? args[args.indexOf('--port') + 1] : undefined
 const check = args.includes('--check')
 /** Feed configured upstream C sources through the same Doxygen extractor as C++. */
 function generateTmuxModel() {
-  const value = (flag, fallback) => args.includes(flag) ? args[args.indexOf(flag) + 1] : fallback
+  const value = (flag, fallback) => (args.includes(flag) ? args[args.indexOf(flag) + 1] : fallback)
   const version = value('--version')
   const pins = JSON.parse(readFileSync(join(repoRoot, 'site/src/data/tmux/versions.json'), 'utf8'))
   const pin = pins.versions.find((entry) => entry.version === version)
@@ -337,10 +367,14 @@ function generateTmuxModel() {
   if (!commit || !tree) throw new Error(`Missing pinned tmux Git object ${revision}`)
   const scratch = mkdtempSync(join(tmpdir(), 'libtmux-doxygen-c-'))
   const source = resolve(value('--source-root', join(scratch, 'source')))
-  const run = (command, argv, cwd = source) => execFileSync(command, argv, {
-    cwd, encoding: 'utf8', maxBuffer: 1 << 28, stdio: ['ignore', 'pipe', 'pipe'],
-    env: { ...process.env, LC_ALL: 'C', TZ: 'UTC' },
-  })
+  const run = (command, argv, cwd = source) =>
+    execFileSync(command, argv, {
+      cwd,
+      encoding: 'utf8',
+      maxBuffer: 1 << 28,
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env, LC_ALL: 'C', TZ: 'UTC' },
+    })
   const sha256 = (bytes) => createHash('sha256').update(bytes).digest('hex')
   const quote = (text) => `"${text.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`
   try {
@@ -349,8 +383,21 @@ function generateTmuxModel() {
       const archive = execFileSync('git', ['-C', checkout, 'archive', commit], { maxBuffer: 1 << 28 })
       execFileSync('tar', ['-x', '-C', source], { input: archive })
       run('sh', ['autogen.sh'])
-      execFileSync('./configure', [], { cwd: source, encoding: 'utf8', maxBuffer: 1 << 26,
-        env: { ...process.env, CC: process.env.CC || 'clang-18', CFLAGS: '', CPPFLAGS: '', LDFLAGS: '', LIBS: '', LC_ALL: 'C', TZ: 'UTC' } })
+      execFileSync('./configure', [], {
+        cwd: source,
+        encoding: 'utf8',
+        maxBuffer: 1 << 26,
+        env: {
+          ...process.env,
+          CC: process.env.CC || 'clang-18',
+          CFLAGS: '',
+          CPPFLAGS: '',
+          LDFLAGS: '',
+          LIBS: '',
+          LC_ALL: 'C',
+          TZ: 'UTC',
+        },
+      })
     }
     // A reused configured archive must still contain every exact tracked byte.
     const tracked = (git(checkout, 'ls-tree', '-r', commit) ?? '').split('\n').map((line) => {
@@ -365,12 +412,25 @@ function generateTmuxModel() {
       if (actual !== blob) throw new Error(`Configured tmux input differs from ${commit}: ${file}`)
       sourceHashes[file] = sha256(bytes)
     }
-    const makeWords = (variable) => run('make', ['--no-print-directory', '-s',
-      `--eval=model-values: ; @printf "%s\\0" $(${variable})`, 'model-values']).split('\0').filter(Boolean)
+    const makeWords = (variable) =>
+      run('make', [
+        '--no-print-directory',
+        '-s',
+        `--eval=model-values: ; @printf "%s\\0" $(${variable})`,
+        'model-values',
+      ])
+        .split('\0')
+        .filter(Boolean)
     const compile = makeWords('COMPILE')
     const configuredSources = [...makeWords('dist_tmux_SOURCES'), ...makeWords('nodist_tmux_SOURCES')]
     const trackedPaths = new Set(tracked.map(({ file }) => file))
-    const translationUnits = [...new Set(configuredSources.filter((file) => file.endsWith('.c') && trackedPaths.has(file) && !file.startsWith('compat/')))].sort()
+    const translationUnits = [
+      ...new Set(
+        configuredSources.filter(
+          (file) => file.endsWith('.c') && trackedPaths.has(file) && !file.startsWith('compat/'),
+        ),
+      ),
+    ].sort()
     const headers = [...trackedPaths].filter((file) => !file.includes('/') && file.endsWith('.h')).sort()
     const inputs = [...translationUnits, ...headers].sort()
     const inputSet = new Set(inputs)
@@ -382,26 +442,47 @@ function generateTmuxModel() {
       if (include) includePaths.push(include[1] || compile[++i])
     }
     const doxygenVersion = run(doxygen, ['--version']).trim()
-    if (!/^1\.18\.0(?:\s|$)/.test(doxygenVersion)) throw new Error(`Expected tested Doxygen 1.18.0, got ${doxygenVersion}`)
+    if (!/^1\.18\.0(?:\s|$)/.test(doxygenVersion))
+      throw new Error(`Expected tested Doxygen 1.18.0, got ${doxygenVersion}`)
     const config = [
-      'PROJECT_NAME = tmux', `OUTPUT_DIRECTORY = ${quote(scratch)}`,
-      `INPUT = ${inputs.map(quote).join(' ')}`, 'EXTENSION_MAPPING = c=C h=C',
-      'OPTIMIZE_OUTPUT_FOR_C = YES', 'EXTRACT_ALL = YES', 'EXTRACT_STATIC = YES',
-      'EXTRACT_LOCAL_CLASSES = YES', 'GENERATE_HTML = NO', 'GENERATE_LATEX = NO',
-      'GENERATE_XML = YES', 'XML_PROGRAMLISTING = YES', 'SOURCE_BROWSER = YES',
-      'REFERENCES_RELATION = YES', 'REFERENCED_BY_RELATION = YES',
-      'ENABLE_PREPROCESSING = YES', 'MACRO_EXPANSION = YES', 'EXPAND_ONLY_PREDEF = NO',
-      'SEARCH_INCLUDES = YES', `INCLUDE_PATH = ${[...new Set(includePaths)].map(quote).join(' ')}`,
+      'PROJECT_NAME = tmux',
+      `OUTPUT_DIRECTORY = ${quote(scratch)}`,
+      `INPUT = ${inputs.map(quote).join(' ')}`,
+      'EXTENSION_MAPPING = c=C h=C',
+      'OPTIMIZE_OUTPUT_FOR_C = YES',
+      'EXTRACT_ALL = YES',
+      'EXTRACT_STATIC = YES',
+      'EXTRACT_LOCAL_CLASSES = YES',
+      'GENERATE_HTML = NO',
+      'GENERATE_LATEX = NO',
+      'GENERATE_XML = YES',
+      'XML_PROGRAMLISTING = YES',
+      'SOURCE_BROWSER = YES',
+      'REFERENCES_RELATION = YES',
+      'REFERENCED_BY_RELATION = YES',
+      'ENABLE_PREPROCESSING = YES',
+      'MACRO_EXPANSION = YES',
+      'EXPAND_ONLY_PREDEF = NO',
+      'SEARCH_INCLUDES = YES',
+      `INCLUDE_PATH = ${[...new Set(includePaths)].map(quote).join(' ')}`,
       `PREDEFINED = ${[...compile.filter((arg) => arg.startsWith('-D')).map((arg) => arg.slice(2)), '__attribute__(x)='].map(quote).join(' ')}`,
-      'SKIP_FUNCTION_MACROS = YES', 'QUIET = YES', 'WARNINGS = YES', 'WARN_IF_UNDOCUMENTED = NO',
-      `WARN_LOGFILE = ${quote(join(scratch, 'warnings.log'))}`, 'STRIP_FROM_PATH = .', 'HAVE_DOT = NO',
+      'SKIP_FUNCTION_MACROS = YES',
+      'QUIET = YES',
+      'WARNINGS = YES',
+      'WARN_IF_UNDOCUMENTED = NO',
+      `WARN_LOGFILE = ${quote(join(scratch, 'warnings.log'))}`,
+      'STRIP_FROM_PATH = .',
+      'HAVE_DOT = NO',
     ].join('\n')
     writeFileSync(join(scratch, 'Doxyfile'), `${config}\n`)
     run(doxygen, [join(scratch, 'Doxyfile')])
     const warnings = readFileSync(join(scratch, 'warnings.log'), 'utf8').replaceAll(source, '<source>')
     if (/\berror:/i.test(warnings)) throw new Error(`Doxygen errors: ${warnings}`)
     const referenceDiagnostics = []
-    const extracted = extractDoxygen(join(scratch, 'xml'), source, { language: 'c', onDiagnostic: (message) => referenceDiagnostics.push(message) })
+    const extracted = extractDoxygen(join(scratch, 'xml'), source, {
+      language: 'c',
+      onDiagnostic: (message) => referenceDiagnostics.push(message),
+    })
     const symbols = extracted.filter((symbol) => inputSet.has(symbol.source.file))
     const ids = new Map(symbols.map((symbol) => [symbol.id, symbol]))
     if (ids.size !== symbols.length) throw new Error('Duplicate C declaration identity')
@@ -410,22 +491,31 @@ function generateTmuxModel() {
       symbol.apiScope = 'internal'
       symbol.source = { ...symbol.source, repo: 'tmux/tmux', revision: commit }
       if (symbol.references) symbol.references = symbol.references.filter((ref) => ids.has(ref.target))
-      if (symbol.imports) symbol.imports = Object.fromEntries(Object.entries(symbol.imports).filter(([, target]) => ids.has(target)))
+      if (symbol.imports)
+        symbol.imports = Object.fromEntries(Object.entries(symbol.imports).filter(([, target]) => ids.has(target)))
       symbol.slug = pageSlug(symbol.id)
     }
     const slugs = new Map()
     for (const symbol of symbols) slugs.set(symbol.slug, [...(slugs.get(symbol.slug) ?? []), symbol])
-    for (const group of slugs.values()) if (group.length > 1) for (const symbol of group) symbol.slug += `-${shortHash(symbol.id)}`
+    for (const group of slugs.values())
+      if (group.length > 1) for (const symbol of group) symbol.slug += `-${shortHash(symbol.id)}`
     if (new Set(symbols.map((symbol) => symbol.slug)).size !== symbols.length) throw new Error('C page slug collision')
-    const commands = symbols.filter((symbol) => symbol.type === 'const struct cmd_entry' && symbol.value).map((symbol) => {
-      const name = /\.name\s*=\s*"([^"\\]+)"/.exec(symbol.value)?.[1]
-      const exec = /\.exec\s*=\s*([A-Za-z_]\w*)/.exec(symbol.value)?.[1]
-      if (!name || !exec) throw new Error(`Unresolved command initializer ${symbol.id}`)
-      const callbacks = (symbol.references ?? []).map((ref) => ids.get(ref.target)).filter((target) => target?.kind === 'function' && target.name === exec)
-      if (callbacks.length !== 1) throw new Error(`Command ${name} callback must resolve once through native XML references`)
-      return { name, entry: symbol.id, callback: callbacks[0].id }
-    }).sort((a, b) => a.name.localeCompare(b.name))
-    if (new Set(commands.map((command) => command.name)).size !== commands.length) throw new Error('Duplicate command name')
+    const commands = symbols
+      .filter((symbol) => symbol.type === 'const struct cmd_entry' && symbol.value)
+      .map((symbol) => {
+        const name = /\.name\s*=\s*"([^"\\]+)"/.exec(symbol.value)?.[1]
+        const exec = /\.exec\s*=\s*([A-Za-z_]\w*)/.exec(symbol.value)?.[1]
+        if (!name || !exec) throw new Error(`Unresolved command initializer ${symbol.id}`)
+        const callbacks = (symbol.references ?? [])
+          .map((ref) => ids.get(ref.target))
+          .filter((target) => target?.kind === 'function' && target.name === exec)
+        if (callbacks.length !== 1)
+          throw new Error(`Command ${name} callback must resolve once through native XML references`)
+        return { name, entry: symbol.id, callback: callbacks[0].id }
+      })
+      .sort((a, b) => a.name.localeCompare(b.name))
+    if (new Set(commands.map((command) => command.name)).size !== commands.length)
+      throw new Error('Duplicate command name')
     const notices = {}
     for (const file of inputs) {
       const contents = readFileSync(join(source, file), 'utf8')
@@ -434,34 +524,62 @@ function generateTmuxModel() {
     }
     const copying = readFileSync(join(source, 'COPYING'), 'utf8')
     const model = {
-      schemaVersion: 1, project: 'tmux', language: 'c', version, repo: 'tmux/tmux', revision: commit,
+      schemaVersion: 1,
+      project: 'tmux',
+      language: 'c',
+      version,
+      repo: 'tmux/tmux',
+      revision: commit,
       extractor: 'doxygen-c-v1',
       profile: {
-        producer: `Doxygen ${doxygenVersion}`, producerBinarySha256: sha256(readFileSync(doxygenPath)), configuredPlatform: run(compile[0], ['-dumpmachine']).trim(),
-        compiler: run(compile[0], ['--version']).split('\n')[0], arguments: compile.slice(1),
-        pin: revision, sourceCommit: commit, sourceTree: tree, translationUnits, inputs,
+        producer: `Doxygen ${doxygenVersion}`,
+        producerBinarySha256: sha256(readFileSync(doxygenPath)),
+        configuredPlatform: run(compile[0], ['-dumpmachine']).trim(),
+        compiler: run(compile[0], ['--version']).split('\n')[0],
+        arguments: compile.slice(1),
+        pin: revision,
+        sourceCommit: commit,
+        sourceTree: tree,
+        translationUnits,
+        inputs,
         exclusions: [
-          { paths: configuredSources.filter((file) => file.endsWith('.c') && !inputSet.has(file)).sort(), reason: 'Generated parser and compatibility implementation are outside the source reference.' },
-          { paths: [...trackedPaths].filter((file) => file.endsWith('.c') && !configuredSources.includes(file)).sort(), reason: 'Not selected by this configured platform.' },
+          {
+            paths: configuredSources.filter((file) => file.endsWith('.c') && !inputSet.has(file)).sort(),
+            reason: 'Generated parser and compatibility implementation are outside the source reference.',
+          },
+          {
+            paths: [...trackedPaths].filter((file) => file.endsWith('.c') && !configuredSources.includes(file)).sort(),
+            reason: 'Not selected by this configured platform.',
+          },
         ],
-        macroExpansion: 'Native included definitions and configured Makefile -D flags; no synthetic feature definitions.',
-        ignoredDecorations: ['__attribute__(x)'], initializerLineLimit: 30,
-        spelling: 'Doxygen-normalized declarations, types and initializers, including expanded macros; not verbatim source slices. Anonymous synthetic types have no reconstructed raw declaration.',
-        references: 'Resolved native XML relationships and explicit C tag types between included symbols; external targets omitted. Call edges are a bounded syntactic projection of refid-linked programlisting inside native function body spans: direct statements, returns, first conditions and assignment RHS. Each call edge records source sites. Callback/address uses, macros, indirect calls, ambiguous or continued expressions remain general references; cross-file static function links are omitted and recorded as producer diagnostics; no runtime execution or complete call graph is claimed.',
-        sourceHashes, referenceDiagnostics: [...new Set(referenceDiagnostics)].sort(), diagnostics: warnings.trim() ? warnings.trim().split('\n') : [],
+        macroExpansion:
+          'Native included definitions and configured Makefile -D flags; no synthetic feature definitions.',
+        ignoredDecorations: ['__attribute__(x)'],
+        initializerLineLimit: 30,
+        spelling:
+          'Doxygen-normalized declarations, types and initializers, including expanded macros; not verbatim source slices. Anonymous synthetic types have no reconstructed raw declaration.',
+        references:
+          'Resolved native XML relationships and explicit C tag types between included symbols; external targets omitted. Call edges are a bounded syntactic projection of refid-linked programlisting inside native function body spans: direct statements, returns, first conditions and assignment RHS. Each call edge records source sites. Callback/address uses, macros, indirect calls, ambiguous or continued expressions remain general references; cross-file static function links are omitted and recorded as producer diagnostics; no runtime execution or complete call graph is claimed.',
+        sourceHashes,
+        referenceDiagnostics: [...new Set(referenceDiagnostics)].sort(),
+        diagnostics: warnings.trim() ? warnings.trim().split('\n') : [],
       },
       license: { file: 'COPYING', sha256: sha256(copying), text: copying, notices },
-      commands, symbols,
+      commands,
+      symbols,
     }
     const out = join(repoRoot, 'site/src/data/tmux/api', `${version}.json`)
     const text = `${JSON.stringify(model)}\n`
     if (check) {
-      if (!existsSync(out) || readFileSync(out, 'utf8') !== text) throw new Error(`${out} stale; regenerate with the same configured toolchain`)
+      if (!existsSync(out) || readFileSync(out, 'utf8') !== text)
+        throw new Error(`${out} stale; regenerate with the same configured toolchain`)
     } else {
       mkdirSync(dirname(out), { recursive: true })
       writeFileSync(out, text)
     }
-    console.log(`gen-api-model: tmux ${version}: ${symbols.length} shared symbols, ${commands.length} native command associations${check ? ' current' : ''}`)
+    console.log(
+      `gen-api-model: tmux ${version}: ${symbols.length} shared symbols, ${commands.length} native command associations${check ? ' current' : ''}`,
+    )
     if (args.includes('--retain-output')) console.log(`Native Doxygen evidence: ${scratch}`)
     else rmSync(scratch, { recursive: true })
   } catch (error) {
@@ -471,7 +589,8 @@ function generateTmuxModel() {
 }
 
 if (args.includes('--project')) {
-  if (args[args.indexOf('--project') + 1] !== 'tmux' || only) throw new Error('Use --project tmux independently of --port')
+  if (args[args.indexOf('--project') + 1] !== 'tmux' || only)
+    throw new Error('Use --project tmux independently of --port')
   generateTmuxModel()
   process.exit(0)
 }
@@ -484,9 +603,7 @@ if (args.includes('--project')) {
  */
 const navOnly = args.includes('--nav')
 const skipNativeModelPortsIndex = args.indexOf('--skip-native-model-ports')
-const skipNativeModelPortsValue = skipNativeModelPortsIndex === -1
-  ? undefined
-  : args[skipNativeModelPortsIndex + 1]
+const skipNativeModelPortsValue = skipNativeModelPortsIndex === -1 ? undefined : args[skipNativeModelPortsIndex + 1]
 if (skipNativeModelPortsIndex !== -1 && !check) {
   console.error('gen-api-model: --skip-native-model-ports requires --check')
   process.exit(2)
@@ -495,7 +612,12 @@ if (skipNativeModelPortsIndex !== -1 && (!skipNativeModelPortsValue || skipNativ
   console.error('gen-api-model: --skip-native-model-ports requires a comma-separated port list')
   process.exit(2)
 }
-const skipNativeModelPorts = new Set((skipNativeModelPortsValue ?? '').split(',').map((port) => port.trim()).filter(Boolean))
+const skipNativeModelPorts = new Set(
+  (skipNativeModelPortsValue ?? '')
+    .split(',')
+    .map((port) => port.trim())
+    .filter(Boolean),
+)
 for (const port of skipNativeModelPorts) {
   if (!(port in PORTS)) {
     console.error(`gen-api-model: --skip-native-model-ports names unknown port ${port}`)
@@ -549,10 +671,8 @@ for (const [port, cfg] of Object.entries(PORTS)) {
   }
 
   const head = git(checkout, 'rev-parse', 'HEAD')
-  const selectedSource = process.env.LIBTMUX_DOCS_PORT === port
-    ? process.env.LIBTMUX_DOCS_SOURCE_SHA : undefined
-  const selectedRef = process.env.LIBTMUX_DOCS_PORT === port
-    ? process.env.LIBTMUX_DOCS_SOURCE_REF : undefined
+  const selectedSource = process.env.LIBTMUX_DOCS_PORT === port ? process.env.LIBTMUX_DOCS_SOURCE_SHA : undefined
+  const selectedRef = process.env.LIBTMUX_DOCS_PORT === port ? process.env.LIBTMUX_DOCS_SOURCE_REF : undefined
   if (selectedSource) {
     if (!/^[0-9a-f]{40}$/.test(selectedSource) || head !== selectedSource) {
       console.error(`gen-api-model: ${port} checkout HEAD ${head} does not match selected source ${selectedSource}`)
@@ -560,7 +680,9 @@ for (const [port, cfg] of Object.entries(PORTS)) {
     }
     const resolved = selectedRef ? git(checkout, 'rev-parse', `${selectedRef}^{commit}`) : head
     if (resolved !== selectedSource) {
-      console.error(`gen-api-model: ${port} source ref ${selectedRef} resolves to ${resolved}, expected ${selectedSource}`)
+      console.error(
+        `gen-api-model: ${port} source ref ${selectedRef} resolves to ${resolved}, expected ${selectedSource}`,
+      )
       process.exit(1)
     }
   }
@@ -572,13 +694,12 @@ for (const [port, cfg] of Object.entries(PORTS)) {
     // Gradle owns dependency tracking; stale generated methods must never be
     // accepted simply because their output directory already exists.
     execFileSync(join(checkout, 'gradlew'), [...cfg.generate, '--console=plain'], {
-      cwd: checkout, stdio: 'inherit',
+      cwd: checkout,
+      stdio: 'inherit',
     })
   }
 
-  const roots = (cfg.roots ?? [cfg.root])
-    .map((r) => join(checkout, r))
-    .filter((r) => existsSync(r))
+  const roots = (cfg.roots ?? [cfg.root]).map((r) => join(checkout, r)).filter((r) => existsSync(r))
   if (!roots.length) {
     console.error(`gen-api-model: no source roots exist for ${port}`)
     process.exit(1)
@@ -633,89 +754,141 @@ for (const [port, cfg] of Object.entries(PORTS)) {
   if (port === 'go') {
     // Read committed bytes at the citation revision, never a newer working tree.
     const files = (git(checkout, 'ls-tree', '-r', '--name-only', revision, 'tmux') ?? '')
-      .split('\n').filter((file) => /^tmux\/[^/]+_test\.go$/.test(file))
+      .split('\n')
+      .filter((file) => /^tmux\/[^/]+_test\.go$/.test(file))
       .map((file) => ({
         file,
         code: execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
-          encoding: 'utf8', maxBuffer: 1 << 26,
+          encoding: 'utf8',
+          maxBuffer: 1 << 26,
         }),
       }))
     const examples = await readCompleteGoExamples(files)
     const goVersion = /^go (\d+\.\d+\.\d+)$/m.exec(git(checkout, 'show', `${revision}:go.mod`) ?? '')?.[1]
     if (examples.length && !goVersion) throw new Error('Missing Go version for complete examples')
-    if (examples.length) attachCompleteGoExamples(model.symbols, examples, {
-      repo: cfg.repo, revision, goVersion,
-    })
+    if (examples.length)
+      attachCompleteGoExamples(model.symbols, examples, {
+        repo: cfg.repo,
+        revision,
+        goVersion,
+      })
   }
 
   if (['java', 'kotlin', 'scala'].includes(port)) {
-    attachCompleteJvmExamples(model.symbols, port, (file) => {
-      try {
-        return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
-          encoding: 'utf8', maxBuffer: 1 << 26, stdio: ['ignore', 'pipe', 'ignore'],
-        })
-      } catch {
-        return undefined
-      }
-    }, { repo: cfg.repo, revision })
+    attachCompleteJvmExamples(
+      model.symbols,
+      port,
+      (file) => {
+        try {
+          return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
+            encoding: 'utf8',
+            maxBuffer: 1 << 26,
+            stdio: ['ignore', 'pipe', 'ignore'],
+          })
+        } catch {
+          return undefined
+        }
+      },
+      { repo: cfg.repo, revision },
+    )
   }
 
   if (port === 'swift') {
-    attachCompleteSwiftExamples(model.symbols, (file) => {
-      try {
-        return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
-          encoding: 'utf8', maxBuffer: 1 << 26, stdio: ['ignore', 'pipe', 'ignore'],
-        })
-      } catch {
-        return undefined
-      }
-    }, { repo: cfg.repo, revision })
+    attachCompleteSwiftExamples(
+      model.symbols,
+      (file) => {
+        try {
+          return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
+            encoding: 'utf8',
+            maxBuffer: 1 << 26,
+            stdio: ['ignore', 'pipe', 'ignore'],
+          })
+        } catch {
+          return undefined
+        }
+      },
+      { repo: cfg.repo, revision },
+    )
   }
 
   if (port === 'fsharp' || port === 'csharp') {
     const attach = port === 'fsharp' ? attachCompleteFSharpExamples : attachCompleteCSharpExamples
-    attach(model.symbols, (file) => {
-      try {
-        return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
-          encoding: 'utf8', maxBuffer: 1 << 26, stdio: ['ignore', 'pipe', 'ignore'],
-        })
-      } catch {
-        return undefined
-      }
-    }, { repo: cfg.repo, revision })
+    attach(
+      model.symbols,
+      (file) => {
+        try {
+          return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
+            encoding: 'utf8',
+            maxBuffer: 1 << 26,
+            stdio: ['ignore', 'pipe', 'ignore'],
+          })
+        } catch {
+          return undefined
+        }
+      },
+      { repo: cfg.repo, revision },
+    )
   }
 
   if (port === 'cxx' || port === 'rs') {
     const attach = port === 'rs' ? attachCompleteRustExamples : attachCompleteCxxExamples
-    attach(model.symbols, (file) => {
-      try {
-        return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
-          encoding: 'utf8', maxBuffer: 1 << 26, stdio: ['ignore', 'pipe', 'ignore'],
-        })
-      } catch {
-        return undefined
-      }
-    }, { repo: cfg.repo, revision })
+    attach(
+      model.symbols,
+      (file) => {
+        try {
+          return execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
+            encoding: 'utf8',
+            maxBuffer: 1 << 26,
+            stdio: ['ignore', 'pipe', 'ignore'],
+          })
+        } catch {
+          return undefined
+        }
+      },
+      { repo: cfg.repo, revision },
+    )
   }
 
   const legacyIds = new Set(model.symbols.map((symbol) => symbol.id))
   const sourceUnits = [{ checkout, repo: cfg.repo, revision, head, symbols: model.symbols }]
   const mcpRoots = {
-    ts: 'packages/mcp/src', rs: 'crates/tmux-mcp/src', go: 'mcp',
-    java: 'libtmux-mcp/src/main/java', csharp: 'src/LibTmux.Mcp',
-  }
-  const extras = cfg.nativeArtifact ? [] : port === 'py'
-    ? [
-      { product: 'workspace', checkout: expand(process.env.LIBTMUX_DOCS_WORKSPACE_PY || '~/work/python/tmuxp'), root: 'src', repo: 'tmux-python/tmuxp', package: 'tmuxp' },
-      { product: 'mcp', checkout: expand(process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp'), root: 'src', repo: 'tmux-python/libtmux-mcp', package: 'libtmux-mcp' },
-    ]
-    : mcpRoots[port] ? [{ product: 'mcp', checkout, root: mcpRoots[port], repo: cfg.repo }] : []
+    ts: 'packages/mcp/src',
+    rs: 'crates/tmux-mcp/src',
+    go: 'mcp',
+    java: 'libtmux-mcp/src/main/java',
+    csharp: 'src/LibTmux.Mcp',
+  }
+  const extras = cfg.nativeArtifact
+    ? []
+    : port === 'py'
+      ? [
+          {
+            product: 'workspace',
+            checkout: expand(process.env.LIBTMUX_DOCS_WORKSPACE_PY || '~/work/python/tmuxp'),
+            root: 'src',
+            repo: 'tmux-python/tmuxp',
+            package: 'tmuxp',
+          },
+          {
+            product: 'mcp',
+            checkout: expand(process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp'),
+            root: 'src',
+            repo: 'tmux-python/libtmux-mcp',
+            package: 'libtmux-mcp',
+          },
+        ]
+      : mcpRoots[port]
+        ? [{ product: 'mcp', checkout, root: mcpRoots[port], repo: cfg.repo }]
+        : []
   for (const extra of extras) {
     const extraHead = git(extra.checkout, 'rev-parse', 'HEAD')
-    if (!extraHead || !existsSync(join(extra.checkout, extra.root))) throw new Error(`Missing ${port} ${extra.product} source`)
+    if (!extraHead || !existsSync(join(extra.checkout, extra.root)))
+      throw new Error(`Missing ${port} ${extra.product} source`)
     const extraRevision = publicRevision(extra.checkout, extraHead, port, extra.repo)
     const extracted = await extractProject({
-      port, root: join(extra.checkout, extra.root), revision: extraRevision,
+      port,
+      root: join(extra.checkout, extra.root),
+      revision: extraRevision,
       options: { ...cfg.options, privateMembers: false, specialMembers: true },
     })
     // These crates use file-relative names. Prefix the additional package so
@@ -741,11 +914,13 @@ for (const [port, cfg] of Object.entries(PORTS)) {
       `INPUT = ${quote(join(checkout, 'examples/workspace/include'))} ${quote(join(checkout, 'apps/mcp/include'))}`,
       `OUTPUT_DIRECTORY = ${quote(output)}`,
       `STRIP_FROM_PATH = ${quote(checkout)}`,
-      'EXTRACT_ALL = YES', 'WARN_AS_ERROR = NO',
+      'EXTRACT_ALL = YES',
+      'WARN_AS_ERROR = NO',
     ].join('\n')
     execFileSync('doxygen', ['-'], { cwd: checkout, input: config, encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] })
-    const symbols = extractDoxygen(join(output, 'xml'), checkout)
-      .filter((symbol) => /^(examples\/workspace|apps\/mcp)\//.test(symbol.source.file))
+    const symbols = extractDoxygen(join(output, 'xml'), checkout).filter((symbol) =>
+      /^(examples\/workspace|apps\/mcp)\//.test(symbol.source.file),
+    )
     sourceUnits[0].symbols.push(...symbols)
     rmSync(output, { recursive: true })
     // Format the extracted declarations once. Static HTML, Markdown and previews
@@ -753,18 +928,30 @@ for (const [port, cfg] of Object.entries(PORTS)) {
     const signatures = model.symbols.flatMap((symbol) => symbol.signatures).filter((signature) => signature.raw)
     const separator = (i) => `// libtmux-signature-${i}`
     const input = `struct ApiDeclarations {\n${signatures.map((signature, i) => `${separator(i)}\n${signature.raw}`).join('\n\n')}\n};\n`
-    const formatted = execFileSync(process.env.CLANG_FORMAT || 'clang-format',
+    const formatted = execFileSync(
+      process.env.CLANG_FORMAT || 'clang-format',
       ['--style=file', `--assume-filename=${join(checkout, 'include/libtmux.hpp')}`],
-      { cwd: checkout, input, encoding: 'utf8', maxBuffer: 1 << 26 })
+      { cwd: checkout, input, encoding: 'utf8', maxBuffer: 1 << 26 },
+    )
     const body = formatted.replace(/^struct ApiDeclarations \{\n/, '').replace(/\n\};\s*$/, '')
-    const parts = body.replace(/^  /gm, '').split(/^\/\/ libtmux-signature-\d+[ \t]*\n/m).slice(1)
+    const parts = body
+      .replace(/^  /gm, '')
+      .split(/^\/\/ libtmux-signature-\d+[ \t]*\n/m)
+      .slice(1)
     if (parts.length !== signatures.length) throw new Error('C++ signature formatting lost a declaration boundary')
-    signatures.forEach((signature, i) => { signature.raw = parts[i].trim() })
+    signatures.forEach((signature, i) => {
+      signature.raw = parts[i].trim()
+    })
   }
   if (model.pruned) model.pruned.kept = model.symbols.length
-  const productOf = (file) => /(?:^|\/)(?:workspace|TmuxWorkspace|LibTmux\.Workspace|libtmux-workspace)(?:\/|$)|crates\/tmux-workspace\//.test(file)
-    ? 'workspace'
-    : /(?:^|\/)(?:mcp|LibTmuxMCP|LibTmux\.Mcp|libtmux-mcp)(?:\/|$)|crates\/tmux-mcp\//.test(file) ? 'mcp' : 'core'
+  const productOf = (file) =>
+    /(?:^|\/)(?:workspace|TmuxWorkspace|LibTmux\.Workspace|libtmux-workspace)(?:\/|$)|crates\/tmux-workspace\//.test(
+      file,
+    )
+      ? 'workspace'
+      : /(?:^|\/)(?:mcp|LibTmuxMCP|LibTmux\.Mcp|libtmux-mcp)(?:\/|$)|crates\/tmux-mcp\//.test(file)
+        ? 'mcp'
+        : 'core'
   const packages = {
     ts: { workspace: '@libtmux/workspace', mcp: '@libtmux/mcp' },
     rs: { workspace: 'tmux-workspace', mcp: 'tmux-mcp' },
@@ -786,7 +973,13 @@ for (const [port, cfg] of Object.entries(PORTS)) {
         model.generatedSources[relativeFile] ??= readFileSync(join(unit.checkout, relativeFile), 'utf8')
       }
       symbol.product ??= productOf(relativeFile)
-      symbol.source = { ...symbol.source, file: relativeFile, repo: unit.repo, revision: unit.revision, extractedRevision: unit.head }
+      symbol.source = {
+        ...symbol.source,
+        file: relativeFile,
+        repo: unit.repo,
+        revision: unit.revision,
+        extractedRevision: unit.head,
+      }
     }
     inheritProductFromOwners(unit.symbols)
     for (const product of ['workspace', 'mcp']) {
@@ -795,21 +988,34 @@ for (const [port, cfg] of Object.entries(PORTS)) {
       let entries = []
       if (port === 'ts') {
         const manifest = JSON.parse(readFileSync(join(unit.checkout, `packages/${product}/package.json`), 'utf8'))
-        entries = Object.values(manifest.exports).flatMap((entry) => typeof entry === 'object' && entry.bun ? [resolve(unit.checkout, `packages/${product}`, entry.bun)] : [])
+        entries = Object.values(manifest.exports).flatMap((entry) =>
+          typeof entry === 'object' && entry.bun ? [resolve(unit.checkout, `packages/${product}`, entry.bun)] : [],
+        )
       } else if (port === 'rs') entries = [join(unit.checkout, `crates/tmux-${product}/src/lib.rs`)]
-      scopeProductSymbols(symbols, { port, root: unit.checkout, entries, readSource: (file) => readFileSync(file, 'utf8') })
+      scopeProductSymbols(symbols, {
+        port,
+        root: unit.checkout,
+        entries,
+        readSource: (file) => readFileSync(file, 'utf8'),
+      })
     }
     remapLines(unit.checkout, unit.symbols, unit.revision, unit.head)
     for (const product of new Set(unit.symbols.map((symbol) => symbol.product))) {
       model.sources.push({
-        product, package: unit.package ?? packages[port]?.[product] ?? portBySlug[port].packageName,
-        repo: unit.repo, revision: unit.revision, extractedRevision: unit.head,
+        product,
+        package: unit.package ?? packages[port]?.[product] ?? portBySlug[port].packageName,
+        repo: unit.repo,
+        revision: unit.revision,
+        extractedRevision: unit.head,
         version: packageVersion(unit.checkout, port, product),
       })
     }
   }
   if (cfg.nativeArtifact) {
-    const locations = model.symbols.flatMap((symbol) => [symbol, ...symbol.signatures.filter((signature) => signature.source)])
+    const locations = model.symbols.flatMap((symbol) => [
+      symbol,
+      ...symbol.signatures.filter((signature) => signature.source),
+    ])
     for (const entry of locations) {
       entry.source = {
         ...entry.source,
@@ -910,8 +1116,10 @@ for (const [port, cfg] of Object.entries(PORTS)) {
     const nav = navSidecar(port, model)
     const stalePaths = [
       strip(read(`${port}.json`)) !== strip(text) && `${port}.json`,
-      tree && JSON.stringify(committedPaths && JSON.parse(committedPaths).paths) !==
-        JSON.stringify(repositoryPaths(tree, cfg)) && `${port}.paths.json`,
+      tree &&
+        JSON.stringify(committedPaths && JSON.parse(committedPaths).paths) !==
+          JSON.stringify(repositoryPaths(tree, cfg)) &&
+        `${port}.paths.json`,
       nav && read(`${port}.nav.json`) !== `${JSON.stringify(nav)}\n` && `${port}.nav.json`,
     ].filter(Boolean)
     if (stalePaths.length) {
@@ -955,7 +1163,10 @@ for (const [port, cfg] of Object.entries(PORTS)) {
   const kinds = model.symbols.reduce((a, s) => ((a[s.kind] = (a[s.kind] ?? 0) + 1), a), {})
   console.log(
     `gen-api-model: ${port} -> ${model.symbols.length} symbols ` +
-      `(${Object.entries(kinds).sort((a, b) => b[1] - a[1]).map(([k, v]) => `${k}:${v}`).join(' ')}) ` +
+      `(${Object.entries(kinds)
+        .sort((a, b) => b[1] - a[1])
+        .map(([k, v]) => `${k}:${v}`)
+        .join(' ')}) ` +
       `${(text.length / 1024 / 1024).toFixed(1)} MB` +
       (disambiguated ? ` [${disambiguated} slugs disambiguated]` : ''),
   )
diff --git a/scripts/gen-brand-css.mjs b/scripts/gen-brand-css.mjs
index 76736ec7f..e7df6a696 100644
--- a/scripts/gen-brand-css.mjs
+++ b/scripts/gen-brand-css.mjs
@@ -6,27 +6,48 @@ import palettes from '../site/src/lib/brand-palettes.json' with { type: 'json' }
 // Both shells consume the same explicit sRGB shades, including without JS.
 const variables = (p, color) => ({
   'brand-color': color,
-  'brand-solid': p.solid, 'brand-on-solid': p.onSolid,
-  'button-bg-primary': p.solid, 'button-text-primary': p.onSolid,
-  'theme-primary': p.link, 'theme-secondary': p.muted, 'theme-accent': p.link,
-  'theme-background': p.background, 'theme-text': p.text,
-  'background-color': p.background, 'text-color': p.text,
-  'topnav-background': p.background, 'topnav-text-color': p.text,
-  'topnav-link-color': p.muted, 'topnav-link-hover-color': p.text,
-  'color-background-primary': p.background, 'color-background-secondary': p.surface,
-  'color-background-border': p.border, 'color-api-background-hover': p.hover,
-  'color-foreground-primary': p.text, 'color-foreground-secondary': p.muted,
-  'color-foreground-muted': p.muted, 'color-link': p.link,
-  'color-brand-primary': p.link, 'color-brand-content': p.link,
+  'brand-solid': p.solid,
+  'brand-on-solid': p.onSolid,
+  'button-bg-primary': p.solid,
+  'button-text-primary': p.onSolid,
+  'theme-primary': p.link,
+  'theme-secondary': p.muted,
+  'theme-accent': p.link,
+  'theme-background': p.background,
+  'theme-text': p.text,
+  'background-color': p.background,
+  'text-color': p.text,
+  'topnav-background': p.background,
+  'topnav-text-color': p.text,
+  'topnav-link-color': p.muted,
+  'topnav-link-hover-color': p.text,
+  'color-background-primary': p.background,
+  'color-background-secondary': p.surface,
+  'color-background-border': p.border,
+  'color-api-background-hover': p.hover,
+  'color-foreground-primary': p.text,
+  'color-foreground-secondary': p.muted,
+  'color-foreground-muted': p.muted,
+  'color-link': p.link,
+  'color-brand-primary': p.link,
+  'color-brand-content': p.link,
   'color-inline-code-background': p.surface,
-  'lt-color-bg': p.background, 'lt-color-bg-secondary': p.surface,
-  'lt-color-bg-hover': p.hover, 'lt-color-fg': p.text,
-  'lt-color-fg-secondary': p.muted, 'lt-color-fg-muted': p.muted,
-  'lt-color-border': p.border, 'lt-color-accent': p.link,
-  'lt-color-link': p.link, 'lt-color-link-visited': p.link,
+  'lt-color-bg': p.background,
+  'lt-color-bg-secondary': p.surface,
+  'lt-color-bg-hover': p.hover,
+  'lt-color-fg': p.text,
+  'lt-color-fg-secondary': p.muted,
+  'lt-color-fg-muted': p.muted,
+  'lt-color-border': p.border,
+  'lt-color-accent': p.link,
+  'lt-color-link': p.link,
+  'lt-color-link-visited': p.link,
   'lt-color-code-bg': p.surface,
 })
-const declarations = (p, color, mode) => `color-scheme: ${mode};\n${Object.entries(variables(p, color)).map(([key, value]) => `  --${key}: ${value};`).join('\n')}`
+const declarations = (p, color, mode) =>
+  `color-scheme: ${mode};\n${Object.entries(variables(p, color))
+    .map(([key, value]) => `  --${key}: ${value};`)
+    .join('\n')}`
 let css = '/* Generated by scripts/gen-brand-css.mjs from brand-palettes.json. */\n'
 for (const [language, p] of Object.entries(palettes)) {
   const selector = `html[data-brand="${language}"]`
diff --git a/scripts/gen-example-sources.mjs b/scripts/gen-example-sources.mjs
index 0482b9a79..43f1f5285 100755
--- a/scripts/gen-example-sources.mjs
+++ b/scripts/gen-example-sources.mjs
@@ -38,7 +38,8 @@ for (const [owner, file] of [
   ['lua', 'examples/quickstart.lua'],
   ['lua', 'examples/native_query.lua'],
   ['lua', 'examples/snapshot.lua'],
-]) wanted.set(`${owner}:${file}`, { owner, file })
+])
+  wanted.set(`${owner}:${file}`, { owner, file })
 for (const md of markdownFiles(CONTENT)) {
   const text = readFileSync(md, 'utf8')
   for (const m of text.matchAll(/^```(\w+)([^\n]*)$/gm)) {
@@ -56,13 +57,22 @@ const digest = (content) => createHash('sha256').update(content).digest('hex')
 export function cachedExample({ repository, revision, file, checkout, current }) {
   if (!/^[a-f0-9]{40}$/.test(revision)) throw new Error(`Invalid example revision: ${revision}`)
   if (existsSync(join(checkout, '.git'))) {
-    const content = execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`],
-      { encoding: 'utf8', maxBuffer: 4 * 1024 * 1024, stdio: ['ignore', 'pipe', 'pipe'] })
+    const content = execFileSync('git', ['-C', checkout, 'show', `${revision}:${file}`], {
+      encoding: 'utf8',
+      maxBuffer: 4 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'pipe'],
+    })
     return { repository, revision, sha256: digest(content), content }
   }
-  if (current?.repository !== repository || current?.revision !== revision ||
-      typeof current.content !== 'string' || current.sha256 !== digest(current.content)) {
-    throw new Error(`${repository}:${file}: no verified cache for ${revision}; provide its checkout and regenerate example sources`)
+  if (
+    current?.repository !== repository ||
+    current?.revision !== revision ||
+    typeof current.content !== 'string' ||
+    current.sha256 !== digest(current.content)
+  ) {
+    throw new Error(
+      `${repository}:${file}: no verified cache for ${revision}; provide its checkout and regenerate example sources`,
+    )
   }
   return current
 }
@@ -74,7 +84,8 @@ export function run() {
   const offline = new Set()
   for (const [key, { owner, file }] of [...wanted].sort((a, b) => a[0].localeCompare(b[0]))) {
     const modelPath = join(root, `site/src/data/api/${owner}.json`)
-    const provenance = existsSync(modelPath) ? JSON.parse(readFileSync(modelPath, 'utf8'))
+    const provenance = existsSync(modelPath)
+      ? JSON.parse(readFileSync(modelPath, 'utf8'))
       : JSON.parse(readFileSync(join(root, `site/src/data/port-guides/${owner}.json`), 'utf8')).source
     const repository = provenance.repository ?? provenance.repo
     const revision = provenance.revision
@@ -83,10 +94,16 @@ export function run() {
     cache[key] = cachedExample({ repository, revision, file, checkout, current: previous[key] })
   }
   const merged = `${JSON.stringify(cache, null, 2)}\n`
-  if (check && merged !== current) throw new Error(`${OUT}: stale example sources; run node scripts/gen-example-sources.mjs`)
+  if (check && merged !== current)
+    throw new Error(`${OUT}: stale example sources; run node scripts/gen-example-sources.mjs`)
   if (!check) writeFileSync(OUT, merged)
-  console.log(`gen-example-sources: ${check ? 'cache matches' : 'wrote'} ${Object.keys(cache).length} revision-bound example sources`)
-  if (offline.size) console.log(`gen-example-sources: cached sources for ${[...offline].join(', ')}; checksums and revisions checked, source checkouts unavailable`)
+  console.log(
+    `gen-example-sources: ${check ? 'cache matches' : 'wrote'} ${Object.keys(cache).length} revision-bound example sources`,
+  )
+  if (offline.size)
+    console.log(
+      `gen-example-sources: cached sources for ${[...offline].join(', ')}; checksums and revisions checked, source checkouts unavailable`,
+    )
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) run()
diff --git a/scripts/gen-example-sources.negative.mjs b/scripts/gen-example-sources.negative.mjs
index 971155a21..bdd63a9c8 100755
--- a/scripts/gen-example-sources.negative.mjs
+++ b/scripts/gen-example-sources.negative.mjs
@@ -21,7 +21,16 @@ try {
   writeFileSync(join(scratch, 'example.go'), '// uncommitted replacement\n')
   assert.deepEqual(cachedExample(request), initial)
   git('add', 'example.go')
-  git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '--quiet', '-m', 'Later revision')
+  git(
+    '-c',
+    'user.name=Fixture',
+    '-c',
+    'user.email=fixture@example.invalid',
+    'commit',
+    '--quiet',
+    '-m',
+    'Later revision',
+  )
   assert.deepEqual(cachedExample(request), initial)
   console.log('ok   examples ignore a dirty working tree and a later HEAD')
 
diff --git a/scripts/gen-mcp-protocol.mjs b/scripts/gen-mcp-protocol.mjs
index 1be9413cf..6b33820d2 100644
--- a/scripts/gen-mcp-protocol.mjs
+++ b/scripts/gen-mcp-protocol.mjs
@@ -8,29 +8,45 @@ import { PORTS, productAvailable } from '../site/src/lib/ports.ts'
 import { captureProtocol } from './lib/mcp-protocol.mjs'
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
-const expand = (path) => path.startsWith('~/') ? join(homedir(), path.slice(2)) : path
+const expand = (path) => (path.startsWith('~/') ? join(homedir(), path.slice(2)) : path)
 const only = process.argv.includes('--port') ? process.argv[process.argv.indexOf('--port') + 1] : undefined
 const checking = process.argv.includes('--check')
 const sourceBound = process.argv.includes('--source-bound')
 if (only && !PORTS.some((port) => port.slug === only)) throw new Error(`Unknown MCP port: ${only}`)
-if (sourceBound && (!only || process.env.LIBTMUX_DOCS_PORT !== only || !/^[0-9a-f]{40}$/.test(process.env.LIBTMUX_DOCS_SOURCE_SHA ?? ''))) {
+if (
+  sourceBound &&
+  (!only || process.env.LIBTMUX_DOCS_PORT !== only || !/^[0-9a-f]{40}$/.test(process.env.LIBTMUX_DOCS_SOURCE_SHA ?? ''))
+) {
   throw new Error('source-bound MCP discovery requires --port, matching LIBTMUX_DOCS_PORT and LIBTMUX_DOCS_SOURCE_SHA')
 }
-const checkoutFor = (port) => expand(port.slug === 'py'
-  ? process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp'
-  : process.env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`] || port.worktree)
+const checkoutFor = (port) =>
+  expand(
+    port.slug === 'py'
+      ? process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp'
+      : process.env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`] || port.worktree,
+  )
 const commands = {
   py: ['.venv/bin/python', '-m', 'libtmux_mcp'],
   ruby: [
-    'bundle', 'exec', 'libtmux-mcp',
-    '--socket-name', 'libtmux-docs-protocol',
-    '--endpoint', 'docs',
-    '--enable-tool', 'tmux_capture',
-    '--enable-tool', 'tmux_wait',
-    '--enable-tool', 'tmux_create',
-    '--enable-tool', 'tmux_send',
-    '--enable-tool', 'tmux_close',
-    '--enable-tool', 'tmux_run',
+    'bundle',
+    'exec',
+    'libtmux-mcp',
+    '--socket-name',
+    'libtmux-docs-protocol',
+    '--endpoint',
+    'docs',
+    '--enable-tool',
+    'tmux_capture',
+    '--enable-tool',
+    'tmux_wait',
+    '--enable-tool',
+    'tmux_create',
+    '--enable-tool',
+    'tmux_send',
+    '--enable-tool',
+    'tmux_close',
+    '--enable-tool',
+    'tmux_run',
   ],
   ts: ['bun', 'packages/mcp/src/server.ts'],
   rs: ['target/debug/tmux-mcp'],
@@ -38,8 +54,12 @@ const commands = {
   csharp: ['dotnet', 'src/LibTmux.Mcp/bin/Release/net10.0/LibTmux.Mcp.dll'],
   cxx: ['build/cxx-dev/apps/mcp/libtmux-mcp-server', '--socket-name', 'libtmux-docs-protocol'],
   swift: ['.build/debug/libtmux-mcp'],
-  julia: ['julia', '--startup-file=no', '-e',
-    'using LibTmuxMCP; args = ["--socket-name", "libtmux-docs-protocol", "--allow-create"]; for name in LibTmuxMCP._TOOL_NAMES; append!(args, ["--tool", name]); end; exit(LibTmuxMCP.main(args))'],
+  julia: [
+    'julia',
+    '--startup-file=no',
+    '-e',
+    'using LibTmuxMCP; args = ["--socket-name", "libtmux-docs-protocol", "--allow-create"]; for name in LibTmuxMCP._TOOL_NAMES; append!(args, ["--tool", name]); end; exit(LibTmuxMCP.main(args))',
+  ],
 }
 const builds = {
   rs: [['cargo', 'build', '--locked', '-p', 'tmux-mcp', '--bin', 'tmux-mcp', '--jobs', '2']],
@@ -64,9 +84,25 @@ const selections = {
   csharp: { LIBTMUX_TOOLSETS: 'inspect,manage,execute,teardown' },
   swift: { LIBTMUX_TOOLSETS: 'inspect,manage,execute,teardown' },
   cxx: { LIBTMUX_TOOLSETS: 'inspect,manage,execute,teardown' },
-  julia: { mode: 'explicit CLI options', tools: 'all registered tools via repeated --tool', allowCreate: '--allow-create' },
+  julia: {
+    mode: 'explicit CLI options',
+    tools: 'all registered tools via repeated --tool',
+    allowCreate: '--allow-create',
+  },
 }
-const selectionVariables = [...new Set(Object.values(selections).flatMap(Object.keys)), 'LIBTMUX_TOOLS', 'LIBTMUX_EXCLUDE_TOOLS', 'LIBTMUX_MCP_TOOLS', 'LIBTMUX_SAFETY', 'TMUX_MCP_SAFETY', 'LIBTMUX_MCP_CAPABILITIES', 'LIBTMUX_MCP_PROMPTS_AS_TOOLS', 'LIBTMUX_MCP_LIVE', 'LIBTMUX_SOCKET_NAME', 'LIBTMUX_SOCKET_PATH']
+const selectionVariables = [
+  ...new Set(Object.values(selections).flatMap(Object.keys)),
+  'LIBTMUX_TOOLS',
+  'LIBTMUX_EXCLUDE_TOOLS',
+  'LIBTMUX_MCP_TOOLS',
+  'LIBTMUX_SAFETY',
+  'TMUX_MCP_SAFETY',
+  'LIBTMUX_MCP_CAPABILITIES',
+  'LIBTMUX_MCP_PROMPTS_AS_TOOLS',
+  'LIBTMUX_MCP_LIVE',
+  'LIBTMUX_SOCKET_NAME',
+  'LIBTMUX_SOCKET_PATH',
+]
 const sourceStatus = (checkout, slug) => {
   // Publication records the clean/dirty state before native generation.
   // Generated, untracked artifacts such as Swift's symbolgraph are not edits.
@@ -89,19 +125,23 @@ const sourceRevision = (checkout, slug) => {
 // stale snapshot. Writing a snapshot set tolerates neither, because a
 // partial or unreliable set is worse than none.
 const relevant = PORTS.filter((port) => (!only || only === port.slug) && productAvailable(port, 'mcp'))
-const checkoutStates = new Map(relevant.map((port) => {
-  const checkout = checkoutFor(port)
-  if (!existsSync(checkout)) return [port.slug, 'missing']
-  const status = sourceStatus(checkout)
-  return [port.slug, status ? 'dirty' : 'ready']
-}))
+const checkoutStates = new Map(
+  relevant.map((port) => {
+    const checkout = checkoutFor(port)
+    if (!existsSync(checkout)) return [port.slug, 'missing']
+    const status = sourceStatus(checkout)
+    return [port.slug, status ? 'dirty' : 'ready']
+  }),
+)
 const missing = [...checkoutStates].filter(([, state]) => state === 'missing').map(([slug]) => slug)
 const dirty = [...checkoutStates].filter(([, state]) => state === 'dirty').map(([slug]) => slug)
 if (missing.length || dirty.length) {
   const note = `gen-mcp-protocol: ${[
     missing.length && `no checkout for ${missing.join(', ')}`,
     dirty.length && `uncommitted changes in ${dirty.join(', ')}`,
-  ].filter(Boolean).join('; ')}`
+  ]
+    .filter(Boolean)
+    .join('; ')}`
   if (checking && !sourceBound) {
     console.log(`${note} — skipping the comparison`)
     process.exit(0)
@@ -117,8 +157,11 @@ for (const port of relevant) {
   if (sourceBound) {
     const model = JSON.parse(readFileSync(join(root, 'site/src/data/api', `${port.slug}.json`), 'utf8'))
     const source = model.sources?.find((entry) => entry.product === 'mcp' && entry.repo === repository)
-    if (model.port !== port.slug || model.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA ||
-        (source?.extractedRevision ?? source?.revision) !== revision) {
+    if (
+      model.port !== port.slug ||
+      model.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA ||
+      (source?.extractedRevision ?? source?.revision) !== revision
+    ) {
       throw new Error(`${port.slug}: API model must describe the selected source and actual MCP checkout ${revision}`)
     }
   }
@@ -130,7 +173,10 @@ for (const port of relevant) {
   const environment = {
     ...Object.fromEntries(selectionVariables.map((key) => [key, undefined])),
     ...(['ruby', 'julia'].includes(port.slug) ? {} : selection),
-    TMUX: undefined, TMUX_PANE: undefined, TMUX_TMPDIR: socketRoot, LIBTMUX_SOCKET: 'libtmux-docs-protocol',
+    TMUX: undefined,
+    TMUX_PANE: undefined,
+    TMUX_TMPDIR: socketRoot,
+    LIBTMUX_SOCKET: 'libtmux-docs-protocol',
     ...(port.slug === 'julia' && !override ? { JULIA_PROJECT: join(socketRoot, 'julia-env') } : {}),
   }
   let protocol
@@ -139,22 +185,35 @@ for (const port of relevant) {
     const goBinary = join(socketRoot, 'libtmux-mcp')
     // Dependency downloads and compilation precede the protocol deadline.
     if (!override) {
-      if (port.slug === 'julia') execFileSync('julia', ['--startup-file=no', '-e',
-        'using Pkg; Pkg.activate(ARGS[1]); Pkg.develop([Pkg.PackageSpec(path=ARGS[2]), Pkg.PackageSpec(path=joinpath(ARGS[2], "packages", "LibTmuxMCP"))]); Pkg.instantiate(); Pkg.precompile()',
-        environment.JULIA_PROJECT, checkout,
-      ], { cwd: checkout, stdio: 'inherit' })
+      if (port.slug === 'julia')
+        execFileSync(
+          'julia',
+          [
+            '--startup-file=no',
+            '-e',
+            'using Pkg; Pkg.activate(ARGS[1]); Pkg.develop([Pkg.PackageSpec(path=ARGS[2]), Pkg.PackageSpec(path=joinpath(ARGS[2], "packages", "LibTmuxMCP"))]); Pkg.instantiate(); Pkg.precompile()',
+            environment.JULIA_PROJECT,
+            checkout,
+          ],
+          { cwd: checkout, stdio: 'inherit' },
+        )
       for (const [build, ...buildArgs] of builds[port.slug] ?? []) {
         execFileSync(build, buildArgs, { cwd: checkout, stdio: 'inherit' })
       }
-      if (port.slug === 'go') execFileSync('go', ['build', '-mod=readonly', '-o', goBinary, './cmd/libtmux-mcp'], { cwd, stdio: 'inherit' })
+      if (port.slug === 'go')
+        execFileSync('go', ['build', '-mod=readonly', '-o', goBinary, './cmd/libtmux-mcp'], { cwd, stdio: 'inherit' })
     }
     // These applications inspect a borrowed endpoint during startup.
-    if (['ruby', 'julia'].includes(port.slug)) execFileSync('tmux', [
-      '-L', 'libtmux-docs-protocol', '-f', '/dev/null', 'new-session', '-d', '-s', 'docs', '/bin/cat',
-    ], { env: { ...process.env, ...environment }, stdio: 'inherit' })
+    if (['ruby', 'julia'].includes(port.slug))
+      execFileSync(
+        'tmux',
+        ['-L', 'libtmux-docs-protocol', '-f', '/dev/null', 'new-session', '-d', '-s', 'docs', '/bin/cat'],
+        { env: { ...process.env, ...environment }, stdio: 'inherit' },
+      )
     const [command, ...args] = override ? JSON.parse(override) : port.slug === 'go' ? [goBinary] : commands[port.slug]
     protocol = await captureProtocol({ command, args, cwd, env: environment })
-    if (sourceRevision(checkout, port.slug) !== revision) throw new Error(`${port.slug}: source revision changed during discovery`)
+    if (sourceRevision(checkout, port.slug) !== revision)
+      throw new Error(`${port.slug}: source revision changed during discovery`)
   } catch (error) {
     failure = error
     throw error
@@ -170,21 +229,29 @@ for (const port of relevant) {
     } catch (error) {
       cleanupErrors.push(error)
     }
-    if (cleanupErrors.length) throw new AggregateError(failure ? [failure, ...cleanupErrors] : cleanupErrors,
-      `${port.slug}: MCP discovery cleanup failed`)
+    if (cleanupErrors.length)
+      throw new AggregateError(
+        failure ? [failure, ...cleanupErrors] : cleanupErrors,
+        `${port.slug}: MCP discovery cleanup failed`,
+      )
   }
   const payload = {
     generated: 'scripts/gen-mcp-protocol.mjs',
     repo: repository,
-    revision, selection, protocol,
+    revision,
+    selection,
+    protocol,
   }
   const out = join(root, 'site/src/data/mcp-protocol', `${port.slug}.json`)
   const text = `${JSON.stringify(payload, null, 2)}\n`
   if (checking) {
-    if (!existsSync(out) || readFileSync(out, 'utf8') !== text) throw new Error(`${port.slug}: protocol snapshot is stale`)
+    if (!existsSync(out) || readFileSync(out, 'utf8') !== text)
+      throw new Error(`${port.slug}: protocol snapshot is stale`)
   } else {
     mkdirSync(dirname(out), { recursive: true })
     writeFileSync(out, text)
   }
-  console.log(`gen-mcp-protocol: ${port.slug} ${protocol.tools.length} tools, ${protocol.resources.length} resources, ${protocol.resourceTemplates.length} resource templates, ${protocol.prompts.length} prompts`)
+  console.log(
+    `gen-mcp-protocol: ${port.slug} ${protocol.tools.length} tools, ${protocol.resources.length} resources, ${protocol.resourceTemplates.length} resource templates, ${protocol.prompts.length} prompts`,
+  )
 }
diff --git a/scripts/gen-mcp-tools.mjs b/scripts/gen-mcp-tools.mjs
index bcfbd9dc9..fd05dc045 100644
--- a/scripts/gen-mcp-tools.mjs
+++ b/scripts/gen-mcp-tools.mjs
@@ -140,7 +140,10 @@ const portsModule = resolve(dirname(dirname(fileURLToPath(import.meta.url))), 's
 const { PORTS: PORT_DEFS, productAvailable } = await import(`file://${portsModule}`)
 const portBySlug = Object.fromEntries(PORT_DEFS.map((port) => [port.slug, port]))
 if (only && !portBySlug[only]) throw new Error(`Unknown MCP port: ${only}`)
-if (sourceBound && (!only || process.env.LIBTMUX_DOCS_PORT !== only || !/^[0-9a-f]{40}$/.test(process.env.LIBTMUX_DOCS_SOURCE_SHA ?? ''))) {
+if (
+  sourceBound &&
+  (!only || process.env.LIBTMUX_DOCS_PORT !== only || !/^[0-9a-f]{40}$/.test(process.env.LIBTMUX_DOCS_SOURCE_SHA ?? ''))
+) {
   throw new Error('source-bound MCP catalog requires --port, matching LIBTMUX_DOCS_PORT and LIBTMUX_DOCS_SOURCE_SHA')
 }
 if (only && !productAvailable(portBySlug[only], 'mcp')) process.exit(0)
@@ -148,14 +151,17 @@ for (const port of PORTS) {
   const definition = portBySlug[port.slug]
   const configured = process.env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`] || definition.worktree
   const oldRoot = definition.checkout
-  port.dir = port.slug === 'py' ? port.dir.replace('~/work/python/libtmux-mcp', process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp') : port.dir.replace(oldRoot, configured)
-  port.checkout = expand(port.slug === 'py' ? process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp' : configured)
+  port.dir =
+    port.slug === 'py'
+      ? port.dir.replace('~/work/python/libtmux-mcp', process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp')
+      : port.dir.replace(oldRoot, configured)
+  port.checkout = expand(
+    port.slug === 'py' ? process.env.LIBTMUX_DOCS_MCP_PY || '~/work/python/libtmux-mcp' : configured,
+  )
   port.repo = port.slug === 'py' ? 'tmux-python/libtmux-mcp' : definition.repo
   if (port.serverDir) port.serverDir = join(port.checkout, 'src/libtmux_mcp')
 }
-const declaredSlugs = new Set(PORT_DEFS
-  .filter((port) => productAvailable(port, 'mcp'))
-  .map((port) => port.slug))
+const declaredSlugs = new Set(PORT_DEFS.filter((port) => productAvailable(port, 'mcp')).map((port) => port.slug))
 const coveredSlugs = new Set(PORTS.map((port) => port.slug))
 const absentHere = [...declaredSlugs].filter((slug) => !coveredSlugs.has(slug))
 const absentThere = [...coveredSlugs].filter((slug) => !declaredSlugs.has(slug))
@@ -166,11 +172,12 @@ if (absentHere.length || absentThere.length) {
   process.exit(1)
 }
 
-
 function filesIn(dir, glob, exclude = []) {
   if (!existsSync(dir)) return []
-  return globSync(glob, { cwd: dir, exclude }).map((file) => join(dir, file))
-    .filter((file) => !file.includes('__pycache__') && statSync(file).isFile()).sort()
+  return globSync(glob, { cwd: dir, exclude })
+    .map((file) => join(dir, file))
+    .filter((file) => !file.includes('__pycache__') && statSync(file).isFile())
+    .sort()
 }
 
 /**
@@ -212,14 +219,18 @@ for (const port of relevant) {
   const head = git(port.checkout, 'rev-parse', 'HEAD')
   const apiModel = JSON.parse(readFileSync(join(repoRoot, 'site/src/data/api', `${port.slug}.json`), 'utf8'))
   const source = apiModel.sources?.find((entry) => entry.repo === port.repo && entry.product === 'mcp')
-  if (sourceBound && (apiModel.port !== port.slug || apiModel.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA ||
-      (source?.extractedRevision ?? source?.revision) !== head)) {
+  if (
+    sourceBound &&
+    (apiModel.port !== port.slug ||
+      apiModel.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA ||
+      (source?.extractedRevision ?? source?.revision) !== head)
+  ) {
     throw new Error(`${port.slug}: API model must describe the selected source and actual MCP checkout ${head}`)
   }
   if (sourceBound && git(port.checkout, 'status', '--porcelain', '--untracked-files=no')) {
     throw new Error(`${port.slug}: MCP checkout has tracked source changes`)
   }
-  const revision = sourceBound ? head : source?.revision ?? head
+  const revision = sourceBound ? head : (source?.revision ?? head)
   const names = new Map()
   let defaultNames
   for (const file of filesIn(dir, port.glob, port.exclude)) {
@@ -232,38 +243,65 @@ for (const port of relevant) {
       defaultNames = new Set([...defaults[1].matchAll(/"([a-z][a-z0-9_]*)"/g)].map((match) => match[1]))
     }
     const path = relative(port.checkout, file)
-    const hunks = head === revision ? [] : parseHunks(git(port.checkout, 'diff', '-U0', `${revision}..${head}`, '--', path))
+    const hunks =
+      head === revision ? [] : parseHunks(git(port.checkout, 'diff', '-U0', `${revision}..${head}`, '--', path))
     for (const match of (section?.[0] ?? text).matchAll(port.pattern)) {
       const wireName = port.capture ? port.capture(match) : match[1]
       const name = port.wirePrefix ? wireName.replace(new RegExp(`^${port.wirePrefix}`), '') : wireName
       const line = mapLine(hunks, text.slice(0, (section?.index ?? 0) + match.index).split('\n').length)
-      names.set(name, { wireName, source: { repo: port.repo, revision, extractedRevision: head, file: path, ...(line ? { line } : {}) } })
+      names.set(name, {
+        wireName,
+        source: { repo: port.repo, revision, extractedRevision: head, file: path, ...(line ? { line } : {}) },
+      })
     }
   }
   const snapshotFile = join(repoRoot, 'site/src/data/mcp-protocol', `${port.slug}.json`)
   const snapshot = existsSync(snapshotFile) ? JSON.parse(readFileSync(snapshotFile, 'utf8')) : undefined
-  if (snapshot && (snapshot.revision !== head || snapshot.repo !== port.repo)) throw new Error(`${port.slug}: MCP protocol snapshot describes another source revision or repository`)
-  if (sourceBound && !snapshot) throw new Error(`${port.slug}: source-bound MCP catalog requires a runtime protocol snapshot`)
+  if (snapshot && (snapshot.revision !== head || snapshot.repo !== port.repo))
+    throw new Error(`${port.slug}: MCP protocol snapshot describes another source revision or repository`)
+  if (sourceBound && !snapshot)
+    throw new Error(`${port.slug}: source-bound MCP catalog requires a runtime protocol snapshot`)
   const protocols = new Map((snapshot?.protocol.tools ?? []).map((tool) => [tool.name, tool]))
-  const registrations = [...names.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([name, registration]) => {
-    const tool = protocols.get(registration.wireName)
-    return {
-      name, ...registration, description: tool?.description ?? '',
-      schemaStatus: tool ? 'runtime' : 'unavailable',
-      ...(port.slug === 'ruby' ? { enabledByDefault: ['capabilities', 'snapshot'].includes(name) } : {}),
-      ...(defaultNames ? { enabledByDefault: defaultNames.has(name), enableOption: port.enableOption } : {}),
-      ...(tool ? { inputSchema: tool.inputSchema, outputSchema: tool.outputSchema, annotations: tool.annotations, meta: tool._meta } : {}),
-    }
-  })
-  const unregistered = [...protocols.keys()].filter((name) => !registrations.some((registration) => registration.wireName === name))
-  if (unregistered.length) throw new Error(`${port.slug}: runtime tools absent from source registrations: ${unregistered.join(', ')}`)
+  const registrations = [...names.entries()]
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([name, registration]) => {
+      const tool = protocols.get(registration.wireName)
+      return {
+        name,
+        ...registration,
+        description: tool?.description ?? '',
+        schemaStatus: tool ? 'runtime' : 'unavailable',
+        ...(port.slug === 'ruby' ? { enabledByDefault: ['capabilities', 'snapshot'].includes(name) } : {}),
+        ...(defaultNames ? { enabledByDefault: defaultNames.has(name), enableOption: port.enableOption } : {}),
+        ...(tool
+          ? {
+              inputSchema: tool.inputSchema,
+              outputSchema: tool.outputSchema,
+              annotations: tool.annotations,
+              meta: tool._meta,
+            }
+          : {}),
+      }
+    })
+  const unregistered = [...protocols.keys()].filter(
+    (name) => !registrations.some((registration) => registration.wireName === name),
+  )
+  if (unregistered.length)
+    throw new Error(`${port.slug}: runtime tools absent from source registrations: ${unregistered.join(', ')}`)
   const unavailable = registrations.filter((entry) => entry.schemaStatus !== 'runtime' || !entry.inputSchema)
-  if (sourceBound && unavailable.length) throw new Error(`${port.slug}: runtime schemas missing for ${unavailable.map((entry) => entry.wireName).join(', ')}`)
+  if (sourceBound && unavailable.length)
+    throw new Error(
+      `${port.slug}: runtime schemas missing for ${unavailable.map((entry) => entry.wireName).join(', ')}`,
+    )
   results[port.slug] = {
-    tools: [...names.keys()].sort(), registrations,
+    tools: [...names.keys()].sort(),
+    registrations,
     wirePrefix: port.wirePrefix ?? '',
     selectable: selectsToolsets(expand(port.serverDir ?? port.dir)),
-    source: relative(port.checkout, dir), repo: port.repo, revision, extractedRevision: head,
+    source: relative(port.checkout, dir),
+    repo: port.repo,
+    revision,
+    extractedRevision: head,
     ...(snapshot ? { selection: snapshot.selection, protocol: { ...snapshot.protocol, tools: undefined } } : {}),
   }
 }
@@ -339,9 +377,7 @@ if (silent.length) {
 }
 
 const universe = [...new Set(slugs.flatMap((s) => results[s].tools))].sort()
-const coverage = Object.fromEntries(
-  universe.map((t) => [t, slugs.filter((s) => results[s].tools.includes(t))]),
-)
+const coverage = Object.fromEntries(universe.map((t) => [t, slugs.filter((s) => results[s].tools.includes(t))]))
 
 const payload = {
   generated: 'scripts/gen-mcp-tools.mjs',
diff --git a/scripts/gen-mentions.mjs b/scripts/gen-mentions.mjs
index 9c11aa2b7..1841d641d 100755
--- a/scripts/gen-mentions.mjs
+++ b/scripts/gen-mentions.mjs
@@ -3,7 +3,16 @@
 import { existsSync, globSync, mkdirSync, readdirSync, readFileSync, statSync, writeFileSync } from 'node:fs'
 import { basename, dirname, join, relative, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
-import { Resolver, parentInventory, decideMention, isLikelyReference, notASymbol, notApiReason, proseMentions, pageSlug } from '../packages/api-model/src/index.ts'
+import {
+  Resolver,
+  parentInventory,
+  decideMention,
+  isLikelyReference,
+  notASymbol,
+  notApiReason,
+  proseMentions,
+  pageSlug,
+} from '../packages/api-model/src/index.ts'
 import { isLocale } from '../site/src/i18n/locales.ts'
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), '..')
@@ -15,7 +24,9 @@ const check = process.argv.includes('--check')
 
 const { PORTS: PORT_DEFS } = await import(`file://${resolve(root, 'site/src/lib/ports.ts')}`)
 const PORTS = PORT_DEFS.map((p) => p.slug)
-const { KNOWN_PORTS, resolvePortBody, resolvePortContent } = await import(`file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`)
+const { KNOWN_PORTS, resolvePortBody, resolvePortContent } = await import(
+  `file://${resolve(root, 'site/src/lib/workspace-shared-slots.ts')}`
+)
 
 /** The first column's label, as the prose writes it. */
 const PORT_BY_LABEL = Object.fromEntries(PORT_DEFS.map((port) => [port.name, port.slug]))
@@ -32,8 +43,13 @@ const models = Object.fromEntries(modelList.map((model) => [model.port, model]))
 const resolver = new Resolver(modelList)
 for (const port of PORT_DEFS) {
   const dependencies = [...(port.parentLibrary ? [port.parentLibrary.slug] : []), ...(port.apiDependencies ?? [])]
-  for (const dependency of dependencies) resolver.addInventory('Library API', '', parentInventory(models[dependency],
-    (symbol) => `/reference/${dependency}/${symbol.slug}/`), [port.slug])
+  for (const dependency of dependencies)
+    resolver.addInventory(
+      'Library API',
+      '',
+      parentInventory(models[dependency], (symbol) => `/reference/${dependency}/${symbol.slug}/`),
+      [port.slug],
+    )
 }
 // Match the renderer's external names before considering a cross-port fallback.
 for (const [file, project, baseUrl, langs] of [
@@ -43,21 +59,38 @@ for (const [file, project, baseUrl, langs] of [
   ['julia', 'Julia', 'https://docs.julialang.org/en/v1/', ['julia']],
 ]) {
   const inventory = JSON.parse(readFileSync(join(root, `site/src/data/inventories/${file}.entries.json`), 'utf8'))
-  resolver.addInventory(project, baseUrl, inventory.e.map(([name, uri]) => ({
-    name, uri, type: 'std:label', priority: 1, dispname: '-',
-  })), langs)
+  resolver.addInventory(
+    project,
+    baseUrl,
+    inventory.e.map(([name, uri]) => ({
+      name,
+      uri,
+      type: 'std:label',
+      priority: 1,
+      dispname: '-',
+    })),
+    langs,
+  )
 }
 
 function frontmatterValue(source, key) {
   const front = /^---\n([\s\S]*?)\n---/.exec(source)?.[1]
   const value = front && new RegExp(`^${key}:\\s*(.+)$`, 'm').exec(front)?.[1]
   if (!value) return undefined
-  try { return JSON.parse(value) } catch { return value.replace(/^['"]|['"]$/g, '') }
+  try {
+    return JSON.parse(value)
+  } catch {
+    return value.replace(/^['"]|['"]$/g, '')
+  }
 }
 
 function versionOf(port) {
   if (port === process.env.LIBTMUX_DOCS_PORT) return process.env.LIBTMUX_DOCS_VERSION || 'latest'
-  try { return JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')[port] ?? 'latest' } catch { return 'latest' }
+  try {
+    return JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')[port] ?? 'latest'
+  } catch {
+    return 'latest'
+  }
 }
 
 // Authored destinations carry ownership even when their labels are ambiguous.
@@ -66,8 +99,8 @@ const authoredTargets = new Map()
 for (const model of modelList) {
   for (const symbol of model.symbols) {
     const slug = symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id)
-    const product = symbol.product && symbol.product !== 'core' && symbol.apiScope !== 'internal'
-      ? `${symbol.product}/` : ''
+    const product =
+      symbol.product && symbol.product !== 'core' && symbol.apiScope !== 'internal' ? `${symbol.product}/` : ''
     const target = { port: model.port, symbol: symbol.id }
     authoredTargets.set(`/${model.port}/${versionOf(model.port)}/${product}reference/${slug}/`, target)
     if (!product) authoredTargets.set(`/reference/${model.port}/${slug}/`, target)
@@ -82,7 +115,9 @@ function authoredTarget(href, page) {
     const parts = decodeURIComponent(url.pathname).split('/').filter(Boolean)
     if (isLocale(parts[0])) parts.shift()
     return authoredTargets.get(`/${parts.join('/')}/`)
-  } catch { return undefined }
+  } catch {
+    return undefined
+  }
 }
 
 /** `site/src/content/docs/topics/traversal.md` becomes `/topics/traversal/`. */
@@ -181,7 +216,11 @@ for (const { file, source } of [...realEntries, ...sharedWorkspaceEntries(realFi
   const product = frontmatterValue(source, 'product') ?? /^ports\/[^/]+\/(workspace|mcp)\//.exec(file)?.[1]
 
   const selected = resolvePortContent(source, authoredPort)
-  for (const { port: contextPort, text, line, before, linked, href } of proseMentions(selected.body, PORT_BY_LABEL, selected.portAt)) {
+  for (const { port: contextPort, text, line, before, linked, href } of proseMentions(
+    selected.body,
+    PORT_BY_LABEL,
+    selected.portAt,
+  )) {
     const pagePort = authoredPort ?? contextPort
     if (notASymbol(text)) continue
     let target
@@ -210,15 +249,15 @@ for (const { file, source } of [...realEntries, ...sharedWorkspaceEntries(realFi
 }
 
 mentions.sort(
-  (a, b) =>
-    a.port.localeCompare(b.port) ||
-    a.symbol.localeCompare(b.symbol) ||
-    a.page.localeCompare(b.page),
+  (a, b) => a.port.localeCompare(b.port) || a.symbol.localeCompare(b.symbol) || a.page.localeCompare(b.page),
 )
 
 if (check) {
   const existing = existsSync(out) ? JSON.parse(readFileSync(out, 'utf8')) : undefined
-  if (JSON.stringify(existing?.mentions) !== JSON.stringify(mentions) || JSON.stringify(existing?.dangling) !== JSON.stringify(dangling)) {
+  if (
+    JSON.stringify(existing?.mentions) !== JSON.stringify(mentions) ||
+    JSON.stringify(existing?.dangling) !== JSON.stringify(dangling)
+  ) {
     console.error('gen-mentions: index missing or stale; run node scripts/gen-mentions.mjs')
     process.exit(1)
   }
diff --git a/scripts/gen-registry.mjs b/scripts/gen-registry.mjs
index adf6edbf8..e5ec73cdd 100644
--- a/scripts/gen-registry.mjs
+++ b/scripts/gen-registry.mjs
@@ -93,8 +93,7 @@ function isPrerelease(version, grammar) {
 }
 
 /** Newest first, under this port's grammar. */
-const newestFirst = (versions, grammar) =>
-  [...versions].sort((a, b) => comparePackageVersions(a, b, grammar))
+const newestFirst = (versions, grammar) => [...versions].sort((a, b) => comparePackageVersions(a, b, grammar))
 
 async function getJson(url, headers = {}) {
   const res = await fetch(url, {
@@ -151,11 +150,12 @@ const PROBES = {
     const packages = {}
     for (const name of names) {
       const { missing, body } = await getJson(`https://rubygems.org/api/v1/versions/${name}.json`)
-      packages[name] = missing || !Array.isArray(body)
-        ? null
-        : body
-            .filter((release) => release.yanked_at === null || release.yanked_at === undefined)
-            .map((release) => release.number)
+      packages[name] =
+        missing || !Array.isArray(body)
+          ? null
+          : body
+              .filter((release) => release.yanked_at === null || release.yanked_at === undefined)
+              .map((release) => release.number)
     }
     return { versions: packages.libtmux, packages }
   },
@@ -184,9 +184,7 @@ const PROBES = {
     return (body.versions ?? []).filter((v) => !v.yanked).map((v) => v.num)
   },
   async go() {
-    const { missing, body } = await getText(
-      'https://proxy.golang.org/github.com/libtmux/libtmux-go/@v/list',
-    )
+    const { missing, body } = await getText('https://proxy.golang.org/github.com/libtmux/libtmux-go/@v/list')
     if (missing || body === null) return null
     const versions = body.split('\n').filter(Boolean)
     return versions.length > 0 ? versions : null
@@ -198,9 +196,15 @@ const PROBES = {
     if (missing || !body) return null
     return [...body.matchAll(/<version>([^<]+)<\/version>/g)].map((m) => m[1])
   },
-  async kotlin(port) { return PROBES.java(port) },
-  async scala(port) { return PROBES.java(port) },
-  async fsharp(port) { return PROBES.csharp(port) },
+  async kotlin(port) {
+    return PROBES.java(port)
+  },
+  async scala(port) {
+    return PROBES.java(port)
+  },
+  async fsharp(port) {
+    return PROBES.csharp(port)
+  },
   async csharp(port) {
     const { missing, body } = await getJson(
       `https://api.nuget.org/v3-flatcontainer/${port.packageName.toLowerCase()}/index.json`,
@@ -346,10 +350,7 @@ for (const port of PORTS) {
   const entry = classify(port, versions, tag)
   if (probe && !Array.isArray(probe) && probe.packages) {
     entry.packages = Object.fromEntries(
-      Object.entries(probe.packages).map(([name, packageVersions]) => [
-        name,
-        classify(port, packageVersions, tag),
-      ]),
+      Object.entries(probe.packages).map(([name, packageVersions]) => [name, classify(port, packageVersions, tag)]),
     )
   }
   ports[port.slug] = entry
diff --git a/scripts/gen-registry.negative.mjs b/scripts/gen-registry.negative.mjs
index 495bc1d7d..9484b9d82 100644
--- a/scripts/gen-registry.negative.mjs
+++ b/scripts/gen-registry.negative.mjs
@@ -21,7 +21,10 @@ const real = join(here, '..', 'site/src/data/registry.json')
 
 function run(file) {
   try {
-    const out = execFileSync('node', [script, '--check', '--offline', '--out', file], { encoding: 'utf8', stdio: 'pipe' })
+    const out = execFileSync('node', [script, '--check', '--offline', '--out', file], {
+      encoding: 'utf8',
+      stdio: 'pipe',
+    })
     return { code: 0, out }
   } catch (err) {
     return { code: err.status, out: `${err.stdout ?? ''}${err.stderr ?? ''}` }
@@ -53,12 +56,18 @@ const check = (name, ok, detail) => {
 }
 
 const mutations = [
-  ['a dropped port is caught', (s) => {
-    const data = JSON.parse(s)
-    delete data.ports.rs
-    return `${JSON.stringify(data, null, 2)}\n`
-  }],
-  ['a hand-edited version is caught', (s) => s.replace(/("rs": \{\n\s+"status": "\w+",\n\s+"version": ")([^"]+)"/, '$10.0.0-edited"')],
+  [
+    'a dropped port is caught',
+    (s) => {
+      const data = JSON.parse(s)
+      delete data.ports.rs
+      return `${JSON.stringify(data, null, 2)}\n`
+    },
+  ],
+  [
+    'a hand-edited version is caught',
+    (s) => s.replace(/("rs": \{\n\s+"status": "\w+",\n\s+"version": ")([^"]+)"/, '$10.0.0-edited"'),
+  ],
   ['a file the generator would not write is caught', (s) => `${JSON.stringify(JSON.parse(s))}\n`],
 ]
 
diff --git a/scripts/gen-tmux-manual.mjs b/scripts/gen-tmux-manual.mjs
index 2babf47e7..83d7639ee 100644
--- a/scripts/gen-tmux-manual.mjs
+++ b/scripts/gen-tmux-manual.mjs
@@ -57,7 +57,8 @@ export function parseManual(html, commands, version) {
     link.append(code)
   }
   const sections = [...document.querySelectorAll('section.Sh > h1')].map((heading) => ({
-    id: heading.id, title: compact(heading.textContent),
+    id: heading.id,
+    title: compact(heading.textContent),
   }))
   for (const heading of document.querySelectorAll('h1, h2')) {
     const replacement = document.createElement(heading.tagName === 'H1' ? 'h2' : 'h3')
@@ -82,8 +83,12 @@ export function parseManual(html, commands, version) {
     }
     const related = { 'set-window-option': 'set-option', 'show-window-options': 'show-options' }[command.name]
     if (!related) throw new Error(`Command absent from the manual: ${command.name}`)
-    return { ...command, section: 'OPTIONS', summary: `Window-scoped form of ${related}.`,
-      html: `<p>Use <a href="${base}${related}/"><code>${related}</code></a> for the option semantics. This command selects window scope. Its accepted flags are listed above.</p>` }
+    return {
+      ...command,
+      section: 'OPTIONS',
+      summary: `Window-scoped form of ${related}.`,
+      html: `<p>Use <a href="${base}${related}/"><code>${related}</code></a> for the option semantics. This command selects window scope. Its accepted flags are listed above.</p>`,
+    }
   })
   const manual = document.body.innerHTML
   window.happyDOM.abort()
@@ -94,7 +99,9 @@ function main() {
   const args = process.argv.slice(2)
   const option = (name) => args[args.indexOf(name) + 1]
   if (!args.includes('--source') || !args.includes('--binaries') || !args.includes('--mandoc')) {
-    throw new Error('Usage: gen-tmux-manual.mjs --source <tmux-git> --binaries <version/bin/tmux parent> --mandoc <executable> [--check]')
+    throw new Error(
+      'Usage: gen-tmux-manual.mjs --source <tmux-git> --binaries <version/bin/tmux parent> --mandoc <executable> [--check]',
+    )
   }
   const source = resolve(option('--source'))
   const binaries = resolve(option('--binaries'))
@@ -112,27 +119,67 @@ function main() {
     delete env.TMUX_PANE
     let catalog
     try {
-      execFileSync(binary, ['-S', socket, '-f', '/dev/null', 'new-session', '-d', '-s', 'reference', '/bin/cat'], { env })
-      catalog = execFileSync(binary, ['-S', socket, '-f', '/dev/null', 'list-commands', '-F',
-        '#{command_list_name}\t#{command_list_alias}\t#{command_list_usage}'], { encoding: 'utf8', env })
+      execFileSync(binary, ['-S', socket, '-f', '/dev/null', 'new-session', '-d', '-s', 'reference', '/bin/cat'], {
+        env,
+      })
+      catalog = execFileSync(
+        binary,
+        [
+          '-S',
+          socket,
+          '-f',
+          '/dev/null',
+          'list-commands',
+          '-F',
+          '#{command_list_name}\t#{command_list_alias}\t#{command_list_usage}',
+        ],
+        { encoding: 'utf8', env },
+      )
     } finally {
       if (existsSync(socket)) execFileSync(binary, ['-S', socket, 'kill-server'], { env })
       rmSync(temporary, { recursive: true })
     }
-    const declarations = execFileSync('git', ['-C', source, 'grep', '-n', '-E', '\\.name = "', revision, '--', 'cmd-*.c'], { encoding: 'utf8' })
-    const sources = new Map([...declarations.matchAll(/^[^:]+:([^:]+):(\d+):.*\.name = "([^"]+)"/gm)]
-      .map((match) => [match[3], { sourceFile: match[1], sourceLine: Number(match[2]) }]))
-    const commands = catalog.trimEnd().split('\n').map((line) => {
-      const [name, alias, usage = ''] = line.split('\t')
-      if (!/^[a-z]+(?:-[a-z]+)*$/.test(name)) throw new Error(`Invalid command: ${name}`)
-      if (!sources.has(name)) throw new Error(`Missing source declaration: ${name}`)
-      return { name, alias, usage, ...sources.get(name) }
+    const declarations = execFileSync(
+      'git',
+      ['-C', source, 'grep', '-n', '-E', '\\.name = "', revision, '--', 'cmd-*.c'],
+      { encoding: 'utf8' },
+    )
+    const sources = new Map(
+      [...declarations.matchAll(/^[^:]+:([^:]+):(\d+):.*\.name = "([^"]+)"/gm)].map((match) => [
+        match[3],
+        { sourceFile: match[1], sourceLine: Number(match[2]) },
+      ]),
+    )
+    const commands = catalog
+      .trimEnd()
+      .split('\n')
+      .map((line) => {
+        const [name, alias, usage = ''] = line.split('\t')
+        if (!/^[a-z]+(?:-[a-z]+)*$/.test(name)) throw new Error(`Invalid command: ${name}`)
+        if (!sources.has(name)) throw new Error(`Missing source declaration: ${name}`)
+        return { name, alias, usage, ...sources.get(name) }
+      })
+    const html = execFileSync(mandoc, ['-Thtml', '-Ofragment'], {
+      input: manual,
+      encoding: 'utf8',
+      maxBuffer: 4 * 1024 * 1024,
     })
-    const html = execFileSync(mandoc, ['-Thtml', '-Ofragment'], { input: manual, encoding: 'utf8', maxBuffer: 4 * 1024 * 1024 })
-    const license = manual.split('\n.Dd')[0].split('\n').filter((line) => line.startsWith('.\\"')).slice(2)
-      .map((line) => line.replace(/^\.\\" ?/, '')).join('\n').trim()
-    const model = { version, revision, manualSha256: digest(manual), catalogSha256: digest(catalog), license,
-      ...parseManual(html, commands, version) }
+    const license = manual
+      .split('\n.Dd')[0]
+      .split('\n')
+      .filter((line) => line.startsWith('.\\"'))
+      .slice(2)
+      .map((line) => line.replace(/^\.\\" ?/, ''))
+      .join('\n')
+      .trim()
+    const model = {
+      version,
+      revision,
+      manualSha256: digest(manual),
+      catalogSha256: digest(catalog),
+      license,
+      ...parseManual(html, commands, version),
+    }
     const target = join(dataDir, `${version}.json`)
     const output = `${JSON.stringify(model, null, 2)}\n`
     if (args.includes('--check')) {
diff --git a/scripts/gen-versions.mjs b/scripts/gen-versions.mjs
index b1728690e..37f6cb357 100755
--- a/scripts/gen-versions.mjs
+++ b/scripts/gen-versions.mjs
@@ -122,8 +122,20 @@ function deriveEntries(port) {
     // engine — the opposite of the truth.
     ...(stableTag ? [{ slug: 'stable', label: 'stable', kind: 'alias', resolvesTo: stableTag, supported: true }] : []),
     ...(preTag ? [{ slug: 'next', label: 'next', kind: 'alias', resolvesTo: preTag, supported: true }] : []),
-    ...tags.map((t) => ({ slug: t.name, label: t.name, kind: 'tag', supported: true, ...(t.date ? { published: t.date } : {}) })),
-    ...branches.map((b) => ({ slug: b.name, label: b.name, kind: 'branch', supported: true, ...(b.date ? { published: b.date } : {}) })),
+    ...tags.map((t) => ({
+      slug: t.name,
+      label: t.name,
+      kind: 'tag',
+      supported: true,
+      ...(t.date ? { published: t.date } : {}),
+    })),
+    ...branches.map((b) => ({
+      slug: b.name,
+      label: b.name,
+      kind: 'branch',
+      supported: true,
+      ...(b.date ? { published: b.date } : {}),
+    })),
   ]
   return { entries, defaultVersion: stableTag ? 'stable' : 'latest', note: undefined }
 }
@@ -146,18 +158,14 @@ function mergeOverrides(manifest, overridesPath) {
 function main() {
   const opts = parseArgs(process.argv.slice(2))
   if (opts.help) {
-    process.stdout.write(
-      'Usage: node scripts/gen-versions.mjs [--out <path>] [--seed] [--overrides <path>]\n',
-    )
+    process.stdout.write('Usage: node scripts/gen-versions.mjs [--out <path>] [--seed] [--overrides <path>]\n')
     return
   }
 
   const manifest = { schema: 1, ports: {}, defaultVersion: {} }
 
   for (const port of PORTS) {
-    const derived = opts.seed
-      ? { entries: seedEntries(), defaultVersion: 'latest' }
-      : deriveEntries(port)
+    const derived = opts.seed ? { entries: seedEntries(), defaultVersion: 'latest' } : deriveEntries(port)
     if (derived.note) process.stderr.write(`gen-versions: ${port.slug}: ${derived.note}\n`)
     manifest.ports[port.slug] = sortVersions(derived.entries, port.tagGrammar, port.tagPrefix)
     // Not unconditionally 'stable' any more: a port with no release has no
diff --git a/scripts/inject-shell.mjs b/scripts/inject-shell.mjs
index 5b5054a5a..7f10f8fa5 100644
--- a/scripts/inject-shell.mjs
+++ b/scripts/inject-shell.mjs
@@ -16,10 +16,16 @@ const selectedVersion = argument('--version')
 const locale = process.env.LIBTMUX_DOCS_LOCALE || 'en'
 const siteDir = existsSync(join(output, locale, 'index.html')) ? join(output, locale) : output
 const prefix = `${(process.env.LIBTMUX_DOCS_LOCALES_ROOT || '').replace(/\/+$/, '')}/${locale}/`
-const failures = new Set(), checked = [], skipped = [], assets = new Map(), allAssets = new Set()
+const failures = new Set(),
+  checked = [],
+  skipped = [],
+  assets = new Map(),
+  allAssets = new Set()
 const stripCssComments = (css) => css.replace(/\/\*[\s\S]*?\*\//g, '')
-const cssUrls = (css) => [...stripCssComments(css).matchAll(/url\(\s*(?:"([^"]*)"|'([^']*)'|([^\s)]+))\s*\)/g)]
-  .map((match) => match[1] ?? match[2] ?? match[3])
+const cssUrls = (css) =>
+  [...stripCssComments(css).matchAll(/url\(\s*(?:"([^"]*)"|'([^']*)'|([^\s)]+))\s*\)/g)].map(
+    (match) => match[1] ?? match[2] ?? match[3],
+  )
 
 function files(directory, suffix) {
   if (!existsSync(directory)) return []
@@ -55,7 +61,10 @@ function checkAsset(href, parent) {
 
 for (const port of PORTS.filter((entry) => entry.renderer === 'sphinx')) {
   const root = join(siteDir, port.slug)
-  if (!existsSync(root)) { skipped.push(`${port.slug}: no assembled native reference`); continue }
+  if (!existsSync(root)) {
+    skipped.push(`${port.slug}: no assembled native reference`)
+    continue
+  }
   for (const version of readdirSync(root)) {
     if (selectedVersion && version !== selectedVersion) continue
     assets.clear()
@@ -69,10 +78,13 @@ for (const port of PORTS.filter((entry) => entry.renderer === 'sphinx')) {
       count++
       const url = `https://libtmux.org${prefix}${relative(siteDir, file).replace(/index\.html$/, '')}`
       if (!html.includes('data-native-shell="')) failures.add(`${url}: compiled native shell is absent`)
-      if (/data-native-shell-export|data-native-boundary/.test(html)) failures.add(`${url}: temporary native export was published`)
-      if (/<script[^>]*src=["'][^"']*(?:\/_shell\/shell\.js|(?:^|\/)spa-nav\.js)/.test(html)) failures.add(`${url}: competing native shell/router remains`)
+      if (/data-native-shell-export|data-native-boundary/.test(html))
+        failures.add(`${url}: temporary native export was published`)
+      if (/<script[^>]*src=["'][^"']*(?:\/_shell\/shell\.js|(?:^|\/)spa-nav\.js)/.test(html))
+        failures.add(`${url}: competing native shell/router remains`)
       for (const tag of html.matchAll(/<(?:link|script|img)\b[^>]*>/g)) {
-        if (tag[0].startsWith('<link') && !/\b(?:rel="(?:stylesheet|preload|modulepreload)"|as="font")/.test(tag[0])) continue
+        if (tag[0].startsWith('<link') && !/\b(?:rel="(?:stylesheet|preload|modulepreload)"|as="font")/.test(tag[0]))
+          continue
         const asset = /\b(?:src|href)=["']([^"']+)["']/.exec(tag[0])?.[1]
         if (asset) checkAsset(asset, url)
       }
@@ -81,7 +93,10 @@ for (const port of PORTS.filter((entry) => entry.renderer === 'sphinx')) {
         for (const href of cssUrls(style[1])) checkAsset(href, url)
       }
     }
-    if (!count) { skipped.push(`${port.slug}/${version}: no native content`); continue }
+    if (!count) {
+      skipped.push(`${port.slug}/${version}: no native content`)
+      continue
+    }
     const styles = [...assets].filter(([file]) => file.endsWith('.css')).map(([, css]) => css)
     styles.push(...inlineStyles)
     const adapter = styles.find((css) => css.includes('html[data-native-shell]'))
@@ -89,14 +104,20 @@ for (const port of PORTS.filter((entry) => entry.renderer === 'sphinx')) {
     if (adapter) {
       const css = stripCssComments(adapter)
       const generated = files(join(native, '_static'), '.css')
-        .filter((path) => !path.endsWith('/libtmux-org.css')).map((path) => readFileSync(path, 'utf8')).join('\n')
-      const nativeRules = [...css.matchAll(/[^{}]*html\[data-native-shell\][^{}]*\{([^{}]*)\}/g)].map((match) => match[1]).join('\n')
+        .filter((path) => !path.endsWith('/libtmux-org.css'))
+        .map((path) => readFileSync(path, 'utf8'))
+        .join('\n')
+      const nativeRules = [...css.matchAll(/[^{}]*html\[data-native-shell\][^{}]*\{([^{}]*)\}/g)]
+        .map((match) => match[1])
+        .join('\n')
       for (const [name] of nativeRules.matchAll(/--color-[a-z0-9-]+(?=\s*:)/gi)) {
-        if (!generated.includes(name)) failures.add(`${port.slug}/${version}: native generator no longer declares ${name}`)
+        if (!generated.includes(name))
+          failures.add(`${port.slug}/${version}: native generator no longer declares ${name}`)
       }
       const compiled = styles.join('\n')
       for (const [, name] of nativeRules.matchAll(/var\((--(?:lt-)?[a-z0-9-]+)/gi)) {
-        if (!compiled.includes(`${name}:`) && !css.includes(`${name}:`)) failures.add(`${port.slug}/${version}: shared CSS does not declare ${name}`)
+        if (!compiled.includes(`${name}:`) && !css.includes(`${name}:`))
+          failures.add(`${port.slug}/${version}: shared CSS does not declare ${name}`)
       }
     }
     checked.push(`${port.slug}/${version}: ${count} native pages`)
diff --git a/scripts/lib/mcp-protocol.mjs b/scripts/lib/mcp-protocol.mjs
index 3fa001792..7da73baab 100644
--- a/scripts/lib/mcp-protocol.mjs
+++ b/scripts/lib/mcp-protocol.mjs
@@ -7,20 +7,36 @@ const isObject = (value) => value !== null && typeof value === 'object' && !Arra
 function validRegistration(item, key) {
   if (!isObject(item) || typeof item.name !== 'string') return false
   if (item.description !== undefined && typeof item.description !== 'string') return false
-  if (key === 'tools') return isObject(item.inputSchema) && item.inputSchema.type === 'object' &&
-    (item.outputSchema === undefined || (isObject(item.outputSchema) && item.outputSchema.type === 'object'))
+  if (key === 'tools')
+    return (
+      isObject(item.inputSchema) &&
+      item.inputSchema.type === 'object' &&
+      (item.outputSchema === undefined || (isObject(item.outputSchema) && item.outputSchema.type === 'object'))
+    )
   if (key === 'resources') return typeof item.uri === 'string'
   if (key === 'resourceTemplates') return typeof item.uriTemplate === 'string'
-  return item.arguments === undefined || (Array.isArray(item.arguments) && item.arguments.every((arg) =>
-    isObject(arg) && typeof arg.name === 'string' &&
-    (arg.description === undefined || typeof arg.description === 'string') &&
-    (arg.required === undefined || typeof arg.required === 'boolean')))
+  return (
+    item.arguments === undefined ||
+    (Array.isArray(item.arguments) &&
+      item.arguments.every(
+        (arg) =>
+          isObject(arg) &&
+          typeof arg.name === 'string' &&
+          (arg.description === undefined || typeof arg.description === 'string') &&
+          (arg.required === undefined || typeof arg.required === 'boolean'),
+      ))
+  )
 }
 
 /** Schema object order is not semantic; some SDKs emit hash maps in random order. */
 export function orderedProtocol(value) {
   if (Array.isArray(value)) return value.map(orderedProtocol)
-  if (value && typeof value === 'object') return Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, item]) => [key, orderedProtocol(item)]))
+  if (value && typeof value === 'object')
+    return Object.fromEntries(
+      Object.entries(value)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([key, item]) => [key, orderedProtocol(item)]),
+    )
   return value
 }
 
@@ -30,7 +46,12 @@ export function orderedProtocol(value) {
  */
 export async function captureProtocol({ command, args = [], cwd, env = {}, timeoutMs = 30000 }) {
   const grouped = process.platform !== 'win32'
-  const child = spawn(command, args, { cwd, env: { ...process.env, ...env }, stdio: ['pipe', 'pipe', 'pipe'], detached: grouped })
+  const child = spawn(command, args, {
+    cwd,
+    env: { ...process.env, ...env },
+    stdio: ['pipe', 'pipe', 'pipe'],
+    detached: grouped,
+  })
   const closed = new Promise((resolve) => child.once('close', resolve))
   const stop = (signal) => {
     if (!child.pid) return
@@ -45,7 +66,9 @@ export async function captureProtocol({ command, args = [], cwd, env = {}, timeo
   const unsupportedMethods = new Set()
   let nextId = 0
   let stderr = ''
-  child.stderr.on('data', (chunk) => { stderr = (stderr + chunk).slice(-4096) })
+  child.stderr.on('data', (chunk) => {
+    stderr = (stderr + chunk).slice(-4096)
+  })
   const lines = createInterface({ input: child.stdout })
   const fail = (error) => {
     for (const request of pending.values()) request.reject(error)
@@ -56,23 +79,31 @@ export async function captureProtocol({ command, args = [], cwd, env = {}, timeo
   child.on('exit', (code) => fail(new Error(`MCP process exited ${code}: ${stderr}`)))
   lines.on('line', (line) => {
     let message
-    try { message = JSON.parse(line) } catch { return }
+    try {
+      message = JSON.parse(line)
+    } catch {
+      return
+    }
     const request = pending.get(message.id)
     if (!request) return
     pending.delete(message.id)
-    if (message.error?.code === -32601 && request.method === 'resources/templates/list' && request.params?.cursor === undefined) {
+    if (
+      message.error?.code === -32601 &&
+      request.method === 'resources/templates/list' &&
+      request.params?.cursor === undefined
+    ) {
       unsupportedMethods.add(request.method)
       request.resolve({ resourceTemplates: [] })
-    }
-    else if (message.error) request.reject(new Error(JSON.stringify(message.error)))
+    } else if (message.error) request.reject(new Error(JSON.stringify(message.error)))
     else request.resolve(message.result)
   })
   const send = (message) => child.stdin.write(`${JSON.stringify({ jsonrpc: '2.0', ...message })}\n`)
-  const request = (method, params) => new Promise((resolve, reject) => {
-    const id = ++nextId
-    pending.set(id, { resolve, reject, method, params })
-    send({ id, method, ...(params ? { params } : {}) })
-  })
+  const request = (method, params) =>
+    new Promise((resolve, reject) => {
+      const id = ++nextId
+      pending.set(id, { resolve, reject, method, params })
+      send({ id, method, ...(params ? { params } : {}) })
+    })
   const timeout = setTimeout(() => {
     fail(new Error(`MCP discovery timed out: ${stderr}`))
     stop('SIGKILL')
@@ -85,7 +116,8 @@ export async function captureProtocol({ command, args = [], cwd, env = {}, timeo
       if (!result || !Array.isArray(result[key])) throw new Error(`${method}: missing or invalid ${key} array`)
       const invalid = result[key].findIndex((item) => !validRegistration(item, key))
       if (invalid !== -1) throw new Error(`${method}: invalid ${key} registration at index ${invalid}`)
-      if (result.nextCursor !== undefined && typeof result.nextCursor !== 'string') throw new Error(`${method}: invalid nextCursor`)
+      if (result.nextCursor !== undefined && typeof result.nextCursor !== 'string')
+        throw new Error(`${method}: invalid nextCursor`)
       entries.push(...result[key])
       cursor = result.nextCursor
     } while (cursor !== undefined)
@@ -93,15 +125,20 @@ export async function captureProtocol({ command, args = [], cwd, env = {}, timeo
   }
   try {
     const initialized = await request('initialize', {
-      protocolVersion: '2025-11-25', capabilities: {},
+      protocolVersion: '2025-11-25',
+      capabilities: {},
       clientInfo: { name: 'libtmux-docs-reference', version: '1' },
     })
     const capabilities = initialized?.capabilities
     if (!isObject(capabilities)) {
       throw new Error('initialize: missing or invalid capabilities object')
     }
-    if (typeof initialized.protocolVersion !== 'string' || !isObject(initialized.serverInfo) ||
-        typeof initialized.serverInfo.name !== 'string' || typeof initialized.serverInfo.version !== 'string') {
+    if (
+      typeof initialized.protocolVersion !== 'string' ||
+      !isObject(initialized.serverInfo) ||
+      typeof initialized.serverInfo.name !== 'string' ||
+      typeof initialized.serverInfo.version !== 'string'
+    ) {
       throw new Error('initialize: missing or invalid protocolVersion or serverInfo')
     }
     for (const family of ['tools', 'resources', 'prompts']) {
diff --git a/scripts/merge-version-manifests.mjs b/scripts/merge-version-manifests.mjs
index 1c20f949c..7c6bfde68 100644
--- a/scripts/merge-version-manifests.mjs
+++ b/scripts/merge-version-manifests.mjs
@@ -10,17 +10,45 @@ function fail(message) {
 }
 
 export function validateReceipt(value, port, version) {
-  const check = (condition, message) => { if (!condition) fail(message) }
+  const check = (condition, message) => {
+    if (!condition) fail(message)
+  }
   const DIGEST = /^[0-9a-f]{64}$/
   const prefix = value?.destination?.prefix
   const parts = typeof prefix === 'string' ? prefix.split('/') : []
-  check(parts.length === 4 && /^[a-z]{2}(?:-[A-Z]{2})?$/.test(parts[0]) && parts[1] === port && parts[2] === version && parts[3] === '' && !prefix.includes('..'),
-    'publication receipt belongs to another destination')
-  check(value.destination.url === `https://libtmux.org/${prefix}` && value.build?.url === `/${prefix}build-provenance.json` && DIGEST.test(value.build?.sha256 ?? ''), 'invalid publication build/destination')
-  check(value.publisher?.repository === 'libtmux/docs' && /^[0-9a-f]{40}$/.test(value.publisher?.sha ?? ''), 'invalid publication publisher')
+  check(
+    parts.length === 4 &&
+      /^[a-z]{2}(?:-[A-Z]{2})?$/.test(parts[0]) &&
+      parts[1] === port &&
+      parts[2] === version &&
+      parts[3] === '' &&
+      !prefix.includes('..'),
+    'publication receipt belongs to another destination',
+  )
+  check(
+    value.destination.url === `https://libtmux.org/${prefix}` &&
+      value.build?.url === `/${prefix}build-provenance.json` &&
+      DIGEST.test(value.build?.sha256 ?? ''),
+    'invalid publication build/destination',
+  )
+  check(
+    value.publisher?.repository === 'libtmux/docs' && /^[0-9a-f]{40}$/.test(value.publisher?.sha ?? ''),
+    'invalid publication publisher',
+  )
   check(['published', 'verified-existing'].includes(value.operation), 'invalid publication operation')
-  check(Number.isSafeInteger(value.artifact?.id) && value.artifact.id > 0 && typeof value.artifact.name === 'string' && DIGEST.test(value.artifact.sha256 ?? ''), 'invalid publication artifact')
-  check(/^https:\/\/github\.com\/[^/]+\/[^/]+\/actions\/runs\/[0-9]+$/.test(value.run?.url ?? '') && Number.isSafeInteger(value.run?.attempt) && value.run.attempt > 0, 'invalid publication run')
+  check(
+    Number.isSafeInteger(value.artifact?.id) &&
+      value.artifact.id > 0 &&
+      typeof value.artifact.name === 'string' &&
+      DIGEST.test(value.artifact.sha256 ?? ''),
+    'invalid publication artifact',
+  )
+  check(
+    /^https:\/\/github\.com\/[^/]+\/[^/]+\/actions\/runs\/[0-9]+$/.test(value.run?.url ?? '') &&
+      Number.isSafeInteger(value.run?.attempt) &&
+      value.run.attempt > 0,
+    'invalid publication run',
+  )
 }
 
 function parseArgs(argv) {
@@ -76,12 +104,12 @@ function main() {
   const directory = resolve(options.fragments)
   const fragments = existsSync(directory)
     ? readdirSync(directory, { withFileTypes: true })
-      .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
-      .sort((a, b) => a.name.localeCompare(b.name))
-      .map((entry) => ({
-        port: basename(entry.name, '.json'),
-        manifest: readManifest(resolve(directory, entry.name)),
-      }))
+        .filter((entry) => entry.isFile() && entry.name.endsWith('.json'))
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .map((entry) => ({
+          port: basename(entry.name, '.json'),
+          manifest: readManifest(resolve(directory, entry.name)),
+        }))
     : []
   const result = merge(readManifest(resolve(options.base)), fragments)
   writeFileSync(resolve(options.out), `${JSON.stringify(result, null, 2)}\n`)
diff --git a/scripts/native-shell-context.mjs b/scripts/native-shell-context.mjs
index b984d9ba6..ca148f670 100644
--- a/scripts/native-shell-context.mjs
+++ b/scripts/native-shell-context.mjs
@@ -16,7 +16,8 @@ export function nativeArticle(html) {
 }
 
 function artifactFiles(directory, path = '') {
-  return readdirSync(join(directory, path), { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))
+  return readdirSync(join(directory, path), { withFileTypes: true })
+    .sort((a, b) => a.name.localeCompare(b.name))
     .flatMap((entry) => {
       const name = path ? `${path}/${entry.name}` : entry.name
       if (entry.isDirectory()) return artifactFiles(directory, name)
@@ -26,8 +27,13 @@ function artifactFiles(directory, path = '') {
 }
 
 function localPath(value, field) {
-  if (typeof value !== 'string' || !value.startsWith('/') || value.startsWith('//') ||
-      /[?#\\]/.test(value) || value.split('/').some((part) => ['.', '..'].includes(decodeURIComponent(part)))) {
+  if (
+    typeof value !== 'string' ||
+    !value.startsWith('/') ||
+    value.startsWith('//') ||
+    /[?#\\]/.test(value) ||
+    value.split('/').some((part) => ['.', '..'].includes(decodeURIComponent(part)))
+  ) {
     throw new Error(`Native ${field} is not a local absolute path: ${value}`)
   }
   return value
@@ -40,7 +46,8 @@ export async function collectNativeContext(directory, { prefix, sphinxPort, vers
   const git = (...args) => execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8' }).trim()
   const sha = git('rev-parse', 'HEAD')
   if (sourceSha && sourceSha !== sha) throw new Error(`Native source revision mismatch: ${sourceSha} != ${sha}`)
-  if (git('status', '--porcelain', '--untracked-files=no')) throw new Error(`Native source has tracked changes: ${checkout}`)
+  if (git('status', '--porcelain', '--untracked-files=no'))
+    throw new Error(`Native source has tracked changes: ${checkout}`)
   const root = localPath(`${prefix.replace(/\/+$/, '')}/`, 'prefix')
   if (!/^[\w.-]+$/.test(version)) throw new Error(`Invalid native version: ${version}`)
   const locale = root.split('/').filter(Boolean).at(-1)
@@ -56,7 +63,9 @@ export async function collectNativeContext(directory, { prefix, sphinxPort, vers
   }
   const pages = []
   const redirects = []
-  const window = new Window({ settings: { disableJavaScriptEvaluation: true, disableCSSFileLoading: true, disableJavaScriptFileLoading: true } })
+  const window = new Window({
+    settings: { disableJavaScriptEvaluation: true, disableCSSFileLoading: true, disableJavaScriptFileLoading: true },
+  })
   try {
     for (const file of files.filter((path) => path.endsWith('.html') && !path.startsWith('_sources/'))) {
       const html = readFileSync(join(directory, file), 'utf8')
@@ -73,7 +82,12 @@ export async function collectNativeContext(directory, { prefix, sphinxPort, vers
       let markdownHref
       let markdownSha256
       if (entry) {
-        if (!sourcePath || sourcePath.startsWith('/') || /[\\\r\n]/.test(sourcePath) || sourcePath.split('/').some((part) => part === '..')) {
+        if (
+          !sourcePath ||
+          sourcePath.startsWith('/') ||
+          /[\\\r\n]/.test(sourcePath) ||
+          sourcePath.split('/').some((part) => part === '..')
+        ) {
           throw new Error(`Native page has no valid source path: ${file}`)
         }
         const committed = execFileSync('git', ['-C', checkout, 'show', `${sha}:${sourcePath}`])
@@ -89,12 +103,22 @@ export async function collectNativeContext(directory, { prefix, sphinxPort, vers
         throw new Error(`Native page has no docs.json entry: ${file}`)
       }
       pages.push({
-        file, path, url: `${base}${path}`, sourcePath: `${port.slug}/${version}/api/${path}`,
-        source, markdownHref, markdownSha256,
-        htmlSha256: hashes[file], articleSha256: nativeHash(nativeArticle(html)),
+        file,
+        path,
+        url: `${base}${path}`,
+        sourcePath: `${port.slug}/${version}/api/${path}`,
+        source,
+        markdownHref,
+        markdownSha256,
+        htmlSha256: hashes[file],
+        articleSha256: nativeHash(nativeArticle(html)),
         hasTableOfContents: [...window.document.querySelectorAll('.toc-tree a[href^="#"]')].some((link) => {
           let id
-          try { id = decodeURIComponent(link.getAttribute('href').slice(1)) } catch { return false }
+          try {
+            id = decodeURIComponent(link.getAttribute('href').slice(1))
+          } catch {
+            return false
+          }
           const target = id ? window.document.getElementById(id) : null
           return Boolean(target?.closest('article') && !target.matches('h1') && !target.querySelector(':scope > h1'))
         }),
@@ -106,15 +130,23 @@ export async function collectNativeContext(directory, { prefix, sphinxPort, vers
   }
   if (metadata.size) throw new Error(`Native docs.json names missing pages: ${[...metadata.keys()].join(', ')}`)
   return {
-    schema: 1, port: port.slug, version, locale, root, base,
+    schema: 1,
+    port: port.slug,
+    version,
+    locale,
+    root,
+    base,
     source: { repository: port.repo, sha },
-    artifactSha256: nativeHash(JSON.stringify(hashes)), pages, redirects,
+    artifactSha256: nativeHash(JSON.stringify(hashes)),
+    pages,
+    redirects,
   }
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
   const [directory, prefix, sphinxPort, version, checkout, output, sourceSha] = process.argv.slice(2)
-  if (!output) throw new Error('Usage: native-shell-context.mjs DIRECTORY PREFIX PORT VERSION CHECKOUT OUTPUT [SOURCE_SHA]')
+  if (!output)
+    throw new Error('Usage: native-shell-context.mjs DIRECTORY PREFIX PORT VERSION CHECKOUT OUTPUT [SOURCE_SHA]')
   const manifest = await collectNativeContext(directory, { prefix, sphinxPort, version, checkout, sourceSha })
   writeFileSync(output, `${JSON.stringify(manifest, null, 2)}\n`)
   console.log(`Native context: ${manifest.pages.length} pages at ${manifest.base} from ${manifest.source.sha}`)
diff --git a/scripts/normalise-parity.mjs b/scripts/normalise-parity.mjs
index 7303dd155..0f480d55f 100644
--- a/scripts/normalise-parity.mjs
+++ b/scripts/normalise-parity.mjs
@@ -134,7 +134,10 @@ function readJson(path) {
  * source-evidence link path, so the three line up with each other and with .NET's own
  * `module` field wherever the file is one .NET's ledger covers too. */
 function deriveModule(srcPath) {
-  const parts = srcPath.replace(/^src\//, '').replace(/\.py$/, '').split('/')
+  const parts = srcPath
+    .replace(/^src\//, '')
+    .replace(/\.py$/, '')
+    .split('/')
   if (parts.at(-1) === '__init__') parts.pop()
   return parts.join('.')
 }
@@ -218,11 +221,10 @@ function goTestFunctionNames(checkout) {
   // just in tmuxq/. One ripgrep pass over the whole checkout, not per-citation: 1588
   // entries citing a few hundred distinct functions is cheaper as a set-membership
   // check.
-  const out = execFileSync(
-    'rg',
-    ['-o', '--no-filename', '--no-line-number', 'func (Test\\w+)', '-r', '$1', '.'],
-    { cwd: checkout, encoding: 'utf8' },
-  )
+  const out = execFileSync('rg', ['-o', '--no-filename', '--no-line-number', 'func (Test\\w+)', '-r', '$1', '.'], {
+    cwd: checkout,
+    encoding: 'utf8',
+  })
   return new Set(out.split('\n').filter(Boolean))
 }
 
@@ -291,7 +293,10 @@ function parseJavaPythonApiTable(text) {
   const unparsed = []
   for (const line of lines) {
     if (!line.startsWith('|')) continue
-    const cells = line.split('|').slice(1, -1).map((c) => c.trim())
+    const cells = line
+      .split('|')
+      .slice(1, -1)
+      .map((c) => c.trim())
     if (cells.length !== 8 || cells[0] === 'Python symbol' || cells[0].startsWith('---')) continue
     const treatment = cells[4].replace(/<[^>]*>/g, '').trim()
     const evidence = cells[7]
@@ -320,7 +325,10 @@ function parseJavaTestMapCounts(path) {
   let dataRows = 0
   for (const line of lines) {
     if (!line.startsWith('|')) continue
-    const cells = line.split('|').slice(1, -1).map((c) => c.trim())
+    const cells = line
+      .split('|')
+      .slice(1, -1)
+      .map((c) => c.trim())
     if (cells.length !== 6 || cells[0] === 'Python evidence' || cells[0].startsWith('---')) continue
     dataRows += 1
     const status = cells[5]
@@ -353,7 +361,12 @@ function parseJava(checkout) {
   const apiText = readFileSync(apiPath, 'utf8')
   const { rows, unparsed } = parseJavaPythonApiTable(apiText)
   const pythonRevision = parseJavaPythonRevision(apiText)
-  const KNOWN_TREATMENT = new Set(['direct translation', 'approved omission', 'consolidation', 'semantic Java adaptation'])
+  const KNOWN_TREATMENT = new Set([
+    'direct translation',
+    'approved omission',
+    'consolidation',
+    'semantic Java adaptation',
+  ])
 
   const byModule = {}
   const portTally = emptyTally()
@@ -388,7 +401,10 @@ function parseJava(checkout) {
       'on the missing PythonBehaviorParityTest class. They count as claimed in ' +
       'the port total only. Server.attached_sessions has two evidence entries, ' +
       'so row counts can exceed the number of distinct corrections.',
-    contractClassesFound: { PythonApiParityContract: apiContractFound, PythonBehaviorParityTest: behaviorContractExists },
+    contractClassesFound: {
+      PythonApiParityContract: apiContractFound,
+      PythonBehaviorParityTest: behaviorContractExists,
+    },
     unparsedSourceEvidence: unparsed,
     portTally: (() => {
       // Fold test-map.md's "deliberate Java correction" rows into the port level
diff --git a/scripts/normalize-native-shell.mjs b/scripts/normalize-native-shell.mjs
index 2f275f5af..24c21ff85 100644
--- a/scripts/normalize-native-shell.mjs
+++ b/scripts/normalize-native-shell.mjs
@@ -30,22 +30,61 @@ function adaptHighlight(directory) {
 /** Keep native widget behavior when Astro replaces the document body. */
 function adaptWidgets(directory) {
   const assets = [
-    ['doctools.js', '2992c09df91826a8d33e3b48b645ee77e457adcf7c712d776a814e1e2c448b43', [
-      ['_ready(Documentation.init);', '_ready(Documentation.init);\ndocument.addEventListener("astro:after-swap", Documentation.initDomainIndexTable);'],
-    ]],
-    ['copybutton.js', '75381d09e0497b436ac3c7a1e690415e4f2ccf2b0cc5202fad70b3bdcb7bbf80', [
-      ['const addCopyButtonToCodeCells = () => {', 'let nativeClipboard;\nconst addCopyButtonToCodeCells = () => {\n  nativeClipboard?.destroy();'],
-      ["codeCell.insertAdjacentHTML('afterend', clipboardButton(id))", "if (!codeCell.nextElementSibling?.classList.contains('copybtn')) codeCell.insertAdjacentHTML('afterend', clipboardButton(id))"],
-      ["const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText})", "const clipboard = nativeClipboard = new ClipboardJS('.copybtn', {text: copyTargetText})"],
-      ['runWhenDOMLoaded(addCopyButtonToCodeCells)', 'runWhenDOMLoaded(addCopyButtonToCodeCells)\ndocument.addEventListener("astro:page-load", addCopyButtonToCodeCells);\ndocument.addEventListener("astro:before-swap", () => nativeClipboard?.destroy());'],
-    ]],
-    ['design-tabs.js', 'de2467cfca5bb555043369f1eea82c9cd794e70fa0444f216aa4ebb18cefc9f0', [
-      ['function ready() {', 'function ready() {\n  sd_id_to_elements = {};'],
-      ['document.addEventListener("DOMContentLoaded", ready, false);', 'document.addEventListener("DOMContentLoaded", ready, false);\ndocument.addEventListener("astro:page-load", ready);'],
-      ['window.sessionStorage.getItem(\n          storageKeyPrefix + group\n        )', '(() => { try { return window.sessionStorage.getItem(storageKeyPrefix + group); } catch { return null; } })()'],
-      ['window.sessionStorage.setItem(storageKeyPrefix + group, tabParam);', 'try { window.sessionStorage.setItem(storageKeyPrefix + group, tabParam); } catch {}'],
-      ['window.sessionStorage.setItem(storageKeyPrefix + group, id);', 'try { window.sessionStorage.setItem(storageKeyPrefix + group, id); } catch {}'],
-    ]],
+    [
+      'doctools.js',
+      '2992c09df91826a8d33e3b48b645ee77e457adcf7c712d776a814e1e2c448b43',
+      [
+        [
+          '_ready(Documentation.init);',
+          '_ready(Documentation.init);\ndocument.addEventListener("astro:after-swap", Documentation.initDomainIndexTable);',
+        ],
+      ],
+    ],
+    [
+      'copybutton.js',
+      '75381d09e0497b436ac3c7a1e690415e4f2ccf2b0cc5202fad70b3bdcb7bbf80',
+      [
+        [
+          'const addCopyButtonToCodeCells = () => {',
+          'let nativeClipboard;\nconst addCopyButtonToCodeCells = () => {\n  nativeClipboard?.destroy();',
+        ],
+        [
+          "codeCell.insertAdjacentHTML('afterend', clipboardButton(id))",
+          "if (!codeCell.nextElementSibling?.classList.contains('copybtn')) codeCell.insertAdjacentHTML('afterend', clipboardButton(id))",
+        ],
+        [
+          "const clipboard = new ClipboardJS('.copybtn', {text: copyTargetText})",
+          "const clipboard = nativeClipboard = new ClipboardJS('.copybtn', {text: copyTargetText})",
+        ],
+        [
+          'runWhenDOMLoaded(addCopyButtonToCodeCells)',
+          'runWhenDOMLoaded(addCopyButtonToCodeCells)\ndocument.addEventListener("astro:page-load", addCopyButtonToCodeCells);\ndocument.addEventListener("astro:before-swap", () => nativeClipboard?.destroy());',
+        ],
+      ],
+    ],
+    [
+      'design-tabs.js',
+      'de2467cfca5bb555043369f1eea82c9cd794e70fa0444f216aa4ebb18cefc9f0',
+      [
+        ['function ready() {', 'function ready() {\n  sd_id_to_elements = {};'],
+        [
+          'document.addEventListener("DOMContentLoaded", ready, false);',
+          'document.addEventListener("DOMContentLoaded", ready, false);\ndocument.addEventListener("astro:page-load", ready);',
+        ],
+        [
+          'window.sessionStorage.getItem(\n          storageKeyPrefix + group\n        )',
+          '(() => { try { return window.sessionStorage.getItem(storageKeyPrefix + group); } catch { return null; } })()',
+        ],
+        [
+          'window.sessionStorage.setItem(storageKeyPrefix + group, tabParam);',
+          'try { window.sessionStorage.setItem(storageKeyPrefix + group, tabParam); } catch {}',
+        ],
+        [
+          'window.sessionStorage.setItem(storageKeyPrefix + group, id);',
+          'try { window.sessionStorage.setItem(storageKeyPrefix + group, id); } catch {}',
+        ],
+      ],
+    ],
   ]
   const digests = {}
   let changed = 0
@@ -57,16 +96,22 @@ function adaptWidgets(directory) {
     if (nativeHash(before) !== digest) throw new Error(`Native widget changed: ${file}`)
     const after = edits.reduce((value, [from, to]) => value.replaceAll(from, to), before)
     digests[name] = nativeHash(after)
-    if (after !== original) { writeFileSync(file, after); changed++ }
+    if (after !== original) {
+      writeFileSync(file, after)
+      changed++
+    }
   }
   return { changed, digests }
 }
 
 function exportRegion(html, name) {
   const boundary = (edge) => `<template data-native-boundary="${name}-${edge}"></template>`
-  const start = boundary('start'), end = boundary('end')
-  if (html.split(start).length !== 2 || html.split(end).length !== 2) throw new Error(`Native export must contain one ${name} region`)
-  const from = html.indexOf(start) + start.length, to = html.indexOf(end)
+  const start = boundary('start'),
+    end = boundary('end')
+  if (html.split(start).length !== 2 || html.split(end).length !== 2)
+    throw new Error(`Native export must contain one ${name} region`)
+  const from = html.indexOf(start) + start.length,
+    to = html.indexOf(end)
   if (to < from) throw new Error(`Native export ${name} boundaries are reversed`)
   return html.slice(from, to)
 }
@@ -83,8 +128,12 @@ function stripNativeTheme(html, file) {
   return html.replace(/<script\b[^>]*>([\s\S]*?)<\/script>/gi, (tag, body) => {
     if (!/localStorage\.getItem\(["']theme["']\)/.test(body)) return tag
     const compact = body.replace(/\s+/g, '')
-    if (compact === 'document.body.dataset.theme=localStorage.getItem("theme")||"auto";' ||
-        compact === '(function(){vart=localStorage.getItem("theme")||"auto";varr=t==="auto"?(window.matchMedia("(prefers-color-scheme:dark)").matches?"dark":"light"):t;document.documentElement.style.colorScheme=r;document.documentElement.classList.add("gp-sphinx-theme-pending");document.documentElement.classList.remove("no-js");functions(){if(document.body&&!document.body.dataset.theme)document.body.dataset.theme=t;}requestAnimationFrame(s);document.addEventListener("DOMContentLoaded",s);})();') return ''
+    if (
+      compact === 'document.body.dataset.theme=localStorage.getItem("theme")||"auto";' ||
+      compact ===
+        '(function(){vart=localStorage.getItem("theme")||"auto";varr=t==="auto"?(window.matchMedia("(prefers-color-scheme:dark)").matches?"dark":"light"):t;document.documentElement.style.colorScheme=r;document.documentElement.classList.add("gp-sphinx-theme-pending");document.documentElement.classList.remove("no-js");functions(){if(document.body&&!document.body.dataset.theme)document.body.dataset.theme=t;}requestAnimationFrame(s);document.addEventListener("DOMContentLoaded",s);})();'
+    )
+      return ''
     throw new Error(`Unrecognized native theme bootstrap: ${file}`)
   })
 }
@@ -93,10 +142,12 @@ function adaptNativePage(html, page, context, chrome, file, assetDigests) {
   if (!/<\/head>/i.test(html)) throw new Error(`Native page has no closing head: ${file}`)
   if (!/<body\b[^>]*>/i.test(html) || !/<\/body>/i.test(html)) throw new Error(`Native page has no body: ${file}`)
   const article = nativeArticle(html)
-  if (nativeHash(article) !== page.articleSha256) throw new Error(`Native article changed after context collection: ${page.file}`)
+  if (nativeHash(article) !== page.articleSha256)
+    throw new Error(`Native article changed after context collection: ${page.file}`)
   const contextHash = nativeHash(JSON.stringify(context))
   const alreadyNormalized = html.includes(`data-native-shell="${contextHash}"`)
-  if (!alreadyNormalized && nativeHash(html) !== page.htmlSha256) throw new Error(`Native page changed after context collection: ${page.file}`)
+  if (!alreadyNormalized && nativeHash(html) !== page.htmlSha256)
+    throw new Error(`Native page changed after context collection: ${page.file}`)
   const opening = /<article\b[^>]*>/i.exec(html)
   const afterArticle = opening.index + opening[0].length + article.length
   // Transform only the shell; parsing and serializing the article would rewrite its HTML.
@@ -109,28 +160,42 @@ function adaptNativePage(html, page, context, chrome, file, assetDigests) {
       .replace(/<style\b[^>]*>html\.gp-sphinx-theme-pending[\s\S]*?<\/style>/g, '')
       .replace(/<style\b[^>]*\bid=["']sphinx-fonts["'][^>]*>[\s\S]*?<\/style>/g, '')
       // Older gp-sphinx releases delete this conflicting extension asset but leave its tag.
-      .replace(/<script\b[^>]*\bsrc=["']((?:\.\.\/)*_static\/tabs\.js(?:\?[^"']*)?)["'][^>]*>[\s\S]*?<\/script>/gi,
-        (tag, src) => existsSync(resolve(dirname(file), src.split('?')[0])) ? tag : '')
+      .replace(
+        /<script\b[^>]*\bsrc=["']((?:\.\.\/)*_static\/tabs\.js(?:\?[^"']*)?)["'][^>]*>[\s\S]*?<\/script>/gi,
+        (tag, src) => (existsSync(resolve(dirname(file), src.split('?')[0])) ? tag : ''),
+      )
       .replace(/<link\b(?=[^>]*\bas=["']font["'])[^>]*>/gi, '')
       .replace(/<header\b[^>]*class=["']mobile-header["'][^>]*>[\s\S]*?<\/header>/g, '')
       .replace(/<button\b[^>]*class=["']theme-toggle["'][^>]*>[\s\S]*?<\/button>/g, '')
       .replace(/<div\b[^>]*class=["']page-source["'][^>]*>[\s\S]*?<\/div>/g, '')
-      .replace(/<script\b[^>]*\bsrc=["']((?:[^"']*\/)?_static\/js\/spa-nav\.js(?:\?[^"']*)?)["'][^>]*>[\s\S]*?<\/script>/gi, (_tag, src) => {
-        const asset = resolve(dirname(file), src.split('?')[0])
-        if (nativeHash(readFileSync(asset)) !== spaNavigationHash) throw new Error(`Native navigation bootstrap changed: ${asset}`)
-        return ''
-      })
-      .replace(/<script\b[^>]*\bsrc=["']((?:[^"']*\/)?_static\/scripts\/furo\.js(?:\?[^"']*)?)["'][^>]*>[\s\S]*?<\/script>/gi, (_tag, src) => {
-        const asset = resolve(dirname(file), src.split('?')[0])
-        if (nativeHash(readFileSync(asset)) !== furoHash) throw new Error(`Native theme script changed: ${asset}`)
-        return ''
-      })
+      .replace(
+        /<script\b[^>]*\bsrc=["']((?:[^"']*\/)?_static\/js\/spa-nav\.js(?:\?[^"']*)?)["'][^>]*>[\s\S]*?<\/script>/gi,
+        (_tag, src) => {
+          const asset = resolve(dirname(file), src.split('?')[0])
+          if (nativeHash(readFileSync(asset)) !== spaNavigationHash)
+            throw new Error(`Native navigation bootstrap changed: ${asset}`)
+          return ''
+        },
+      )
+      .replace(
+        /<script\b[^>]*\bsrc=["']((?:[^"']*\/)?_static\/scripts\/furo\.js(?:\?[^"']*)?)["'][^>]*>[\s\S]*?<\/script>/gi,
+        (_tag, src) => {
+          const asset = resolve(dirname(file), src.split('?')[0])
+          if (nativeHash(readFileSync(asset)) !== furoHash) throw new Error(`Native theme script changed: ${asset}`)
+          return ''
+        },
+      )
     result = stripNativeTheme(result, file)
-    result = result.replace(/\bsrc=(["'])((?:[^"']*\/)?_static\/([^/"'?]+\.js))(?:\?[^"']*)?\1/g,
-      (attribute, quote, src, name) => assetDigests[name] ? `src=${quote}${src}?v=${assetDigests[name].slice(0, 12)}${quote}` : attribute)
+    result = result.replace(
+      /\bsrc=(["'])((?:[^"']*\/)?_static\/([^/"'?]+\.js))(?:\?[^"']*)?\1/g,
+      (attribute, quote, src, name) =>
+        assetDigests[name] ? `src=${quote}${src}?v=${assetDigests[name].slice(0, 12)}${quote}` : attribute,
+    )
     // ClientRouter compares asset URLs before changing the document location.
-    result = result.replace(/\b(src|href)=(["'])(?:\.\.\/)*(_static\/[^"']+)\2/g,
-      (_attribute, name, quote, path) => `${name}=${quote}${escapeAttribute(context.base + path)}${quote}`)
+    result = result.replace(
+      /\b(src|href)=(["'])(?:\.\.\/)*(_static\/[^"']+)\2/g,
+      (_attribute, name, quote, path) => `${name}=${quote}${escapeAttribute(context.base + path)}${quote}`,
+    )
     result = result.replace(/\bhref=(["'])(\/[^"']+\.html)\1/g, (attribute, quote, href) => {
       const target = context.pages.find((entry) => `/${entry.path?.replace(/\/$/, '')}.html` === href)
       return target ? `href=${quote}${escapeAttribute(target.url)}${quote}` : attribute
@@ -140,18 +205,30 @@ function adaptNativePage(html, page, context, chrome, file, assetDigests) {
   let before = transform(html.slice(0, opening.index))
   let after = transform(html.slice(afterArticle))
   before = before.replace(/<html\b([^>]*)>/i, (_tag, attributes) => {
-    const clean = attributes.replace(/\sdata-(?:native-shell|native-toc|theme|brand|brand-variant|shell-base)(?=[=\s]|$)(?:=["'][^"']*["'])?/gi, '')
+    const clean = attributes.replace(
+      /\sdata-(?:native-shell|native-toc|theme|brand|brand-variant|shell-base)(?=[=\s]|$)(?:=["'][^"']*["'])?/gi,
+      '',
+    )
     const brand = PORT_BY_SLUG[context.port].logoLanguage
     return `<html${clean} data-native-shell="${contextHash}" data-theme="${brand}" data-brand="${brand}" data-brand-variant="library" data-shell-base="${escapeAttribute(context.base)}" data-native-toc="${Boolean(page.hasTableOfContents)}">`
   })
   before = before
     .replace(/<\/head>/i, `<!-- libtmux-native-head -->${chrome.head}<!-- /libtmux-native-head -->\n</head>`)
-    .replace(/<body\b([^>]*)>\s*/i, (_tag, attributes) => `<body${attributes.replace(/\sdata-documentation-layout=["'][^"']*["']/gi, '')} data-documentation-layout="reference">\n<!-- libtmux-native-header -->${chrome.header}<!-- /libtmux-native-header -->\n`)
-    .replace(/<aside class="sidebar-drawer"(?: id="native-navigation")?>/, '<aside class="sidebar-drawer" id="native-navigation">')
+    .replace(
+      /<body\b([^>]*)>\s*/i,
+      (_tag, attributes) =>
+        `<body${attributes.replace(/\sdata-documentation-layout=["'][^"']*["']/gi, '')} data-documentation-layout="reference">\n<!-- libtmux-native-header -->${chrome.header}<!-- /libtmux-native-header -->\n`,
+    )
+    .replace(
+      /<aside class="sidebar-drawer"(?: id="native-navigation")?>/,
+      '<aside class="sidebar-drawer" id="native-navigation">',
+    )
   after = after
     .replace(/<aside class="toc-drawer"(?: id="native-toc")?>/, '<aside class="toc-drawer" id="native-toc">')
     .replace(/\s*<\/body>/i, `\n<!-- libtmux-native-footer -->${chrome.footer}<!-- /libtmux-native-footer -->\n</body>`)
-  const attributes = opening[0].replace(/\sdata-pagefind-(?:body|filter)(?:=["'][^"']*["'])?/gi, '').replace(/>$/, ` data-pagefind-body data-pagefind-filter="port:${PORT_BY_SLUG[context.port].name}">`)
+  const attributes = opening[0]
+    .replace(/\sdata-pagefind-(?:body|filter)(?:=["'][^"']*["'])?/gi, '')
+    .replace(/>$/, ` data-pagefind-body data-pagefind-filter="port:${PORT_BY_SLUG[context.port].name}">`)
   const result = before + attributes + article + after
   if (nativeArticle(result) !== article) throw new Error(`Native article was modified: ${page.file}`)
   return result
@@ -163,7 +240,11 @@ function adaptNativePage(html, page, context, chrome, file, assetDigests) {
  * @param {string} prefix
  * @param {{ sphinxPort?: string, version?: string, contextFile?: string, shellDirectory?: string }} [options]
  */
-export async function normalizeNativeShell(directory, prefix, { sphinxPort, version = 'latest', contextFile, shellDirectory } = {}) {
+export async function normalizeNativeShell(
+  directory,
+  prefix,
+  { sphinxPort, version = 'latest', contextFile, shellDirectory } = {},
+) {
   const port = sphinxPort ? PORT_BY_SLUG[sphinxPort] : undefined
   if (sphinxPort && port?.renderer !== 'sphinx') throw new Error(`Not a Sphinx port: ${sphinxPort}`)
   const root = prefix.replace(/\/+$/, '')
@@ -205,7 +286,14 @@ export async function normalizeNativeShell(directory, prefix, { sphinxPort, vers
           const page = pages.get(name)
           if (!page || !shellDirectory) throw new Error(`Native page has no compiled context: ${name}`)
           seen.add(name)
-          after = adaptNativePage(before, page, context, compiledChrome(join(shellDirectory, 'api', name)), path, assetDigests)
+          after = adaptNativePage(
+            before,
+            page,
+            context,
+            compiledChrome(join(shellDirectory, 'api', name)),
+            path,
+            assetDigests,
+          )
         } else {
           after = normalize(before)
         }
@@ -217,7 +305,8 @@ export async function normalizeNativeShell(directory, prefix, { sphinxPort, vers
     }
   }
   walk(directory)
-  for (const page of pages.keys()) if (!seen.has(page)) throw new Error(`Native context page was not assembled: ${page}`)
+  for (const page of pages.keys())
+    if (!seen.has(page)) throw new Error(`Native context page was not assembled: ${page}`)
   return changed
 }
 
@@ -226,5 +315,7 @@ if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.ur
   if (!directory || !prefix?.startsWith('/')) {
     throw new Error('Usage: normalize-native-shell.mjs DIRECTORY PREFIX [SPHINX_PORT VERSION CONTEXT SHELL_DIRECTORY]')
   }
-  console.log(`Native shell: prepared ${await normalizeNativeShell(directory, prefix, { sphinxPort, version, contextFile, shellDirectory })} HTML/CSS files`)
+  console.log(
+    `Native shell: prepared ${await normalizeNativeShell(directory, prefix, { sphinxPort, version, contextFile, shellDirectory })} HTML/CSS files`,
+  )
 }
diff --git a/scripts/port-docs-matrix.mjs b/scripts/port-docs-matrix.mjs
index 2cfd1c01e..9de151466 100644
--- a/scripts/port-docs-matrix.mjs
+++ b/scripts/port-docs-matrix.mjs
@@ -14,14 +14,19 @@ import { PORTS, PORT_BY_SLUG } from '../site/src/lib/ports.ts'
 export function publicationMatrix(matrix, slug, repository, includeWrappers = false) {
   const port = PORT_BY_SLUG[slug]
   if (!port) throw new Error(`unknown documentation port: ${slug}`)
-  if (port.repo !== repository) throw new Error(`${repository} cannot build ${slug}; its source belongs to ${port.repo}`)
+  if (port.repo !== repository)
+    throw new Error(`${repository} cannot build ${slug}; its source belongs to ${port.repo}`)
   const family = [port, ...(includeWrappers ? PORTS.filter((entry) => entry.parentLibrary?.slug === slug) : [])]
   return { include: matrix.include.flatMap((version) => family.map((member) => ({ ...version, port: member.slug }))) }
 }
 
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  const matrix = publicationMatrix(JSON.parse(process.env.IDENTITY_MATRIX), process.env.PORT,
-    process.env.CALLER_REPOSITORY, process.env.INCLUDE_WRAPPERS === 'true')
+  const matrix = publicationMatrix(
+    JSON.parse(process.env.IDENTITY_MATRIX),
+    process.env.PORT,
+    process.env.CALLER_REPOSITORY,
+    process.env.INCLUDE_WRAPPERS === 'true',
+  )
   appendFileSync(process.env.GITHUB_OUTPUT, `matrix=${JSON.stringify(matrix)}\n`)
   console.log(JSON.stringify(matrix, null, 2))
 }
diff --git a/scripts/prune-versions.mjs b/scripts/prune-versions.mjs
index 13c79234d..e7d2a07dc 100644
--- a/scripts/prune-versions.mjs
+++ b/scripts/prune-versions.mjs
@@ -79,7 +79,6 @@ export function toPrune(kept, present) {
   return out.sort()
 }
 
-
 /**
  * The CLI, run only when this file is the entry point.
  *
@@ -135,5 +134,4 @@ if (fileURLToPath(import.meta.url) === argv[1]) {
     console.log(`deleting s3://${bucket}/${prefix}/`)
     execFileSync('aws', ['s3', 'rm', `s3://${bucket}/${prefix}/`, '--recursive'], { stdio: 'inherit' })
   }
-
 }
diff --git a/scripts/publication-provenance.mjs b/scripts/publication-provenance.mjs
index c9bf3fcbd..c359ca0af 100644
--- a/scripts/publication-provenance.mjs
+++ b/scripts/publication-provenance.mjs
@@ -13,27 +13,42 @@ const SHA = /^[0-9a-f]{40}$/
 const DIGEST = /^[0-9a-f]{64}$/
 const NATIVE_GENERATOR_PORTS = new Set(['ruby', 'lua', 'powershell', 'julia'])
 const segment = /^[a-zA-Z0-9][a-zA-Z0-9._-]*$/
-const fail = (message) => { throw new Error(`publication-provenance: ${message}`) }
-const check = (condition, message) => { if (!condition) fail(message) }
+const fail = (message) => {
+  throw new Error(`publication-provenance: ${message}`)
+}
+const check = (condition, message) => {
+  if (!condition) fail(message)
+}
 const json = (file) => JSON.parse(readFileSync(file, 'utf8'))
 export const digest = (bytes) => createHash('sha256').update(bytes).digest('hex')
 const write = (file, value) => writeFileSync(file, `${JSON.stringify(value, null, 2)}\n`)
 const git = (directory, ...args) => execFileSync('git', ['-C', directory, ...args], { encoding: 'utf8' }).trim()
 
 function validateRoute(version, locale) {
-  check(typeof version === 'string' && segment.test(version) && !/[\r\n]/.test(version) && !version.includes('..'), 'invalid version')
-  check(typeof locale === 'string' && /^[a-z]{2}(?:-[A-Z]{2})?$/.test(locale) && !/[\r\n]/.test(locale), 'invalid locale')
+  check(
+    typeof version === 'string' && segment.test(version) && !/[\r\n]/.test(version) && !version.includes('..'),
+    'invalid version',
+  )
+  check(
+    typeof locale === 'string' && /^[a-z]{2}(?:-[A-Z]{2})?$/.test(locale) && !/[\r\n]/.test(locale),
+    'invalid locale',
+  )
 }
 
 export function workflowIdentity(repository, sha) {
-  check(repository === 'libtmux/docs' && SHA.test(sha ?? ''),
-    'GitHub Cloud job.workflow_repository/job.workflow_sha must identify libtmux/docs at a full commit SHA')
+  check(
+    repository === 'libtmux/docs' && SHA.test(sha ?? ''),
+    'GitHub Cloud job.workflow_repository/job.workflow_sha must identify libtmux/docs at a full commit SHA',
+  )
   return { repository, sha }
 }
 
 export function checkoutIdentity(directory) {
   const origin = git(directory, 'remote', 'get-url', 'origin')
-  const repository = /^(?:https:\/\/github\.com\/|git@github\.com:|(?:git\+)?ssh:\/\/git@github\.com\/)([^/]+\/[^/]+?)(?:\.git)?$/.exec(origin)?.[1]
+  const repository =
+    /^(?:https:\/\/github\.com\/|git@github\.com:|(?:git\+)?ssh:\/\/git@github\.com\/)([^/]+\/[^/]+?)(?:\.git)?$/.exec(
+      origin,
+    )?.[1]
   check(repository, `checkout has no GitHub origin: ${directory}`)
   const sha = git(directory, 'rev-parse', 'HEAD')
   check(SHA.test(sha), 'checkout HEAD must be a full SHA')
@@ -65,9 +80,17 @@ export function snapshot(docsRoot, env = process.env) {
   const docs = checkoutIdentity(docsRoot)
   check(docs.repository === 'libtmux/docs', 'docs checkout must belong to libtmux/docs')
   const nativeGenerator = NATIVE_GENERATOR_PORTS.has(port.slug)
-    ? checkoutIdentity(env.LIBTMUX_DOCS_GENERATOR_CHECKOUT || env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`]) : undefined
-  if (nativeGenerator) check(nativeGenerator.repository === port.repo, `native generator repository must be ${port.repo}`)
-  const current = { schema: 1, port: port.slug, version: env.LIBTMUX_DOCS_VERSION, locale, docs, sources,
+    ? checkoutIdentity(env.LIBTMUX_DOCS_GENERATOR_CHECKOUT || env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`])
+    : undefined
+  if (nativeGenerator)
+    check(nativeGenerator.repository === port.repo, `native generator repository must be ${port.repo}`)
+  const current = {
+    schema: 1,
+    port: port.slug,
+    version: env.LIBTMUX_DOCS_VERSION,
+    locale,
+    docs,
+    sources,
     ...(nativeGenerator ? { nativeGenerator } : {}),
   }
   if (!env.LIBTMUX_DOCS_INPUT_SNAPSHOT) return current
@@ -75,14 +98,22 @@ export function snapshot(docsRoot, env = process.env) {
   // The shared builder captures inputs before native generators emit files
   // such as Swift symbolgraph/. Their output must not masquerade as a source
   // edit. Recheck every actual HEAD when assembly consumes that snapshot.
-  const revisions = (value) => ({ ...value,
+  const revisions = (value) => ({
+    ...value,
     docs: { ...value.docs, dirty: undefined },
     ...(value.nativeGenerator ? { nativeGenerator: { ...value.nativeGenerator, dirty: undefined } } : {}),
     sources: value.sources.map((source) => ({ ...source, dirty: undefined })),
   })
-  check(JSON.stringify(revisions(captured)) === JSON.stringify(revisions(current)), 'input snapshot no longer matches checkout revisions')
-  check(typeof captured.docs.dirty === 'boolean' && captured.sources.every((source) => typeof source.dirty === 'boolean') &&
-    (!nativeGenerator || typeof captured.nativeGenerator?.dirty === 'boolean'), 'input snapshot has no dirty state')
+  check(
+    JSON.stringify(revisions(captured)) === JSON.stringify(revisions(current)),
+    'input snapshot no longer matches checkout revisions',
+  )
+  check(
+    typeof captured.docs.dirty === 'boolean' &&
+      captured.sources.every((source) => typeof source.dirty === 'boolean') &&
+      (!nativeGenerator || typeof captured.nativeGenerator?.dirty === 'boolean'),
+    'input snapshot has no dirty state',
+  )
   return captured
 }
 
@@ -94,16 +125,21 @@ function paths(root, prefix = '') {
     const stat = lstatSync(join(root, path))
     check(!stat.isSymbolicLink(), `symlink is forbidden: ${path}`)
     if (stat.isDirectory()) result.push(...paths(root, path))
-    else { check(stat.isFile(), `non-regular file: ${path}`); result.push(path) }
+    else {
+      check(stat.isFile(), `non-regular file: ${path}`)
+      result.push(path)
+    }
   }
   return result.sort()
 }
 
 export function inventory(root) {
-  return paths(root).filter((path) => path !== RECORD).map((path) => {
-    const bytes = readFileSync(join(root, path))
-    return { path, size: bytes.length, sha256: digest(bytes) }
-  })
+  return paths(root)
+    .filter((path) => path !== RECORD)
+    .map((path) => {
+      const bytes = readFileSync(join(root, path))
+      return { path, size: bytes.length, sha256: digest(bytes) }
+    })
 }
 
 export function normalize(root, locale) {
@@ -122,12 +158,18 @@ export function recordBuild(root, inputs) {
   for (const path of paths(root).filter((path) => path.endsWith('.html'))) {
     const file = join(root, path)
     const before = readFileSync(file, 'utf8').replace(/<link data-libtmux-provenance[^>]*>/g, '')
-    const after = /<\/head>/i.test(before) ? before.replace(/<\/head>/i, `${link}</head>`)
-      : /^(\s*<!doctype[^>]*>)/i.test(before) ? before.replace(/^(\s*<!doctype[^>]*>)/i, `$1${link}`) : `${link}${before}`
+    const after = /<\/head>/i.test(before)
+      ? before.replace(/<\/head>/i, `${link}</head>`)
+      : /^(\s*<!doctype[^>]*>)/i.test(before)
+        ? before.replace(/^(\s*<!doctype[^>]*>)/i, `$1${link}`)
+        : `${link}${before}`
     writeFileSync(file, after)
   }
   const record = { ...inputs, files: inventory(root) }
-  check(record.files.some((file) => file.path === 'index.html'), 'version tree has no index.html')
+  check(
+    record.files.some((file) => file.path === 'index.html'),
+    'version tree has no index.html',
+  )
   write(join(root, RECORD), record)
   return record
 }
@@ -138,8 +180,14 @@ export function validateDescriptor(value, expected) {
   check(Number.isSafeInteger(value.artifact?.id) && value.artifact.id > 0, 'invalid artifact ID')
   check(DIGEST.test(value.artifact?.sha256 ?? ''), 'invalid artifact SHA256')
   check(/^[0-9]+$/.test(value.run?.id ?? ''), 'invalid artifact run ID')
-  check(value.run?.repository === expected.repository && value.run?.id === String(expected.runId), 'artifact belongs to another repository/run')
-  check(Number.isSafeInteger(value.run?.attempt) && value.run.attempt > 0 && value.run.attempt <= Number(expected.attempt), 'invalid artifact run attempt')
+  check(
+    value.run?.repository === expected.repository && value.run?.id === String(expected.runId),
+    'artifact belongs to another repository/run',
+  )
+  check(
+    Number.isSafeInteger(value.run?.attempt) && value.run.attempt > 0 && value.run.attempt <= Number(expected.attempt),
+    'invalid artifact run attempt',
+  )
   check(SHA.test(value.sourceSha ?? ''), 'invalid source SHA')
   return value
 }
@@ -151,7 +199,11 @@ export function unpackArchive(directory, descriptor, out) {
   check(files.length === 1, 'expected exactly one downloaded archive')
   const archive = join(directory, files[0])
   check(digest(readFileSync(archive)) === descriptor.artifact.sha256, 'artifact archive SHA256 differs from descriptor')
-  execFileSync('python3', ['-c', `
+  execFileSync(
+    'python3',
+    [
+      '-c',
+      `
 import pathlib, stat, sys, zipfile
 root = pathlib.Path(sys.argv[2])
 root.mkdir(parents=True, exist_ok=False)
@@ -166,7 +218,12 @@ with zipfile.ZipFile(sys.argv[1]) as archive:
         if stat.S_ISLNK(mode) or (stat.S_IFMT(mode) and not (stat.S_ISREG(mode) or stat.S_ISDIR(mode))):
             raise ValueError("non-regular artifact entry: " + item.filename)
     archive.extractall(root)
-`, archive, out], { stdio: 'pipe' })
+`,
+      archive,
+      out,
+    ],
+    { stdio: 'pipe' },
+  )
 }
 
 export function verifyBuild(root, expected) {
@@ -175,29 +232,51 @@ export function verifyBuild(root, expected) {
   const port = PORT_BY_SLUG[expected.port]
   check(port?.repo === expected.repository, 'caller repository does not own this port')
   workflowIdentity(expected.publisherRepository, expected.publisherSha)
-  check(record.schema === 1 && record.port === expected.port && record.version === expected.version && record.locale === expected.locale,
-    'build identity differs from publication destination')
-  check(record.docs?.repository === expected.publisherRepository && record.docs?.sha === expected.publisherSha,
-    'builder docs SHA differs from publisher workflow SHA')
+  check(
+    record.schema === 1 &&
+      record.port === expected.port &&
+      record.version === expected.version &&
+      record.locale === expected.locale,
+    'build identity differs from publication destination',
+  )
+  check(
+    record.docs?.repository === expected.publisherRepository && record.docs?.sha === expected.publisherSha,
+    'builder docs SHA differs from publisher workflow SHA',
+  )
   check(record.docs.dirty === false, 'docs inputs are dirty')
   if (NATIVE_GENERATOR_PORTS.has(record.port)) {
-    check(record.nativeGenerator?.repository === port.repo && SHA.test(record.nativeGenerator?.sha ?? ''), 'missing or invalid native generator repository/SHA')
+    check(
+      record.nativeGenerator?.repository === port.repo && SHA.test(record.nativeGenerator?.sha ?? ''),
+      'missing or invalid native generator repository/SHA',
+    )
     check(record.nativeGenerator.dirty === false, 'native generator inputs are dirty')
   } else check(record.nativeGenerator === undefined, 'unexpected native generator')
   const products = record.port === 'py' ? ['core', 'workspace', 'mcp'] : ['core']
-  check(JSON.stringify(record.sources?.map((source) => source.product)) === JSON.stringify(products), 'missing or unexpected source products')
+  check(
+    JSON.stringify(record.sources?.map((source) => source.product)) === JSON.stringify(products),
+    'missing or unexpected source products',
+  )
   const repositories = [port.repo, 'tmux-python/tmuxp', 'tmux-python/libtmux-mcp']
   record.sources.forEach((source, index) => {
     check(source.repository === repositories[index] && SHA.test(source.sha ?? ''), 'invalid source repository/SHA')
     check(source.dirty === false, 'source inputs are dirty')
   })
   check(record.sources[0].sha === expected.sourceSha, 'source SHA differs from builder artifact descriptor')
-  check(expected.prefix === `${record.locale}/${record.port}/${record.version}`, 'destination prefix differs from build')
+  check(
+    expected.prefix === `${record.locale}/${record.port}/${record.version}`,
+    'destination prefix differs from build',
+  )
   // Normalization must already have happened in the builder. Any byte changed
   // here makes the inventory fail, rather than silently publishing other bytes.
   normalize(root, record.locale)
-  check(Array.isArray(record.files) && record.files.some((file) => file.path === 'index.html'), 'version tree has no index.html')
-  check(JSON.stringify(record.files) === JSON.stringify(inventory(root)), 'content inventory differs (changed, missing, extra, or duplicate files)')
+  check(
+    Array.isArray(record.files) && record.files.some((file) => file.path === 'index.html'),
+    'version tree has no index.html',
+  )
+  check(
+    JSON.stringify(record.files) === JSON.stringify(inventory(root)),
+    'content inventory differs (changed, missing, extra, or duplicate files)',
+  )
   return record
 }
 
@@ -206,17 +285,28 @@ export function receipt(root, descriptor, expected) {
   return {
     build: { url: `/${expected.prefix}/${RECORD}`, sha256: digest(readFileSync(join(root, RECORD))) },
     artifact: descriptor.artifact,
-    run: { url: `https://github.com/${descriptor.run.repository}/actions/runs/${descriptor.run.id}`, attempt: descriptor.run.attempt },
+    run: {
+      url: `https://github.com/${descriptor.run.repository}/actions/runs/${descriptor.run.id}`,
+      attempt: descriptor.run.attempt,
+    },
     publisher: workflowIdentity(expected.publisherRepository, expected.publisherSha),
     destination: { prefix: `${expected.prefix}/`, url: `https://libtmux.org/${expected.prefix}/` },
   }
 }
 
-
 function expected(env) {
-  return { port: env.PORT, version: env.VERSION, locale: env.LOCALE || 'en', prefix: env.PREFIX,
-    publisherRepository: env.PUBLISHER_REPOSITORY, publisherSha: env.PUBLISHER_SHA,
-    name: env.ARTIFACT_NAME, repository: env.GITHUB_REPOSITORY, runId: env.GITHUB_RUN_ID, attempt: env.GITHUB_RUN_ATTEMPT }
+  return {
+    port: env.PORT,
+    version: env.VERSION,
+    locale: env.LOCALE || 'en',
+    prefix: env.PREFIX,
+    publisherRepository: env.PUBLISHER_REPOSITORY,
+    publisherSha: env.PUBLISHER_SHA,
+    name: env.ARTIFACT_NAME,
+    repository: env.GITHUB_REPOSITORY,
+    runId: env.GITHUB_RUN_ID,
+    attempt: env.GITHUB_RUN_ATTEMPT,
+  }
 }
 
 function main() {
@@ -226,14 +316,19 @@ function main() {
   else if (command === 'record') recordBuild(first, json(second))
   else if (command === 'workflow') workflowIdentity(env.PUBLISHER_REPOSITORY, env.PUBLISHER_SHA)
   else if (command === 'descriptor') {
-    const value = { schema: 1, artifact: { id: Number(env.ARTIFACT_ID), name: env.ARTIFACT_NAME, sha256: env.ARTIFACT_DIGEST },
-      run: { repository: env.GITHUB_REPOSITORY, id: env.GITHUB_RUN_ID, attempt: Number(env.GITHUB_RUN_ATTEMPT) }, sourceSha: env.SOURCE_SHA }
+    const value = {
+      schema: 1,
+      artifact: { id: Number(env.ARTIFACT_ID), name: env.ARTIFACT_NAME, sha256: env.ARTIFACT_DIGEST },
+      run: { repository: env.GITHUB_REPOSITORY, id: env.GITHUB_RUN_ID, attempt: Number(env.GITHUB_RUN_ATTEMPT) },
+      sourceSha: env.SOURCE_SHA,
+    }
     write(first, validateDescriptor(value, expected(env)))
   } else if (command === 'select') {
     const value = validateDescriptor(json(first), expected(env))
     appendFileSync(env.GITHUB_OUTPUT, `artifact-id=${value.artifact.id}\n`)
   } else if (command === 'unpack') unpackArchive(first, validateDescriptor(json(second), expected(env)), third)
-  else if (command === 'verify') write(third, receipt(first, validateDescriptor(json(second), expected(env)), expected(env)))
+  else if (command === 'verify')
+    write(third, receipt(first, validateDescriptor(json(second), expected(env)), expected(env)))
   else fail(`unknown command: ${command}`)
 }
 if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) main()
diff --git a/scripts/publish-plan.mjs b/scripts/publish-plan.mjs
index 092e5e427..03bfd7d94 100644
--- a/scripts/publish-plan.mjs
+++ b/scripts/publish-plan.mjs
@@ -41,14 +41,19 @@ function versionOf(tag, port) {
  */
 export function plan(inputs, catalog, lookup, versions) {
   const dispatchable = catalog.filter((port) => port.docsDispatch)
-  const wanted = inputs.ports.trim() === 'all'
-    ? dispatchable
-    : inputs.ports.split(',').map((slug) => slug.trim()).filter(Boolean).map((slug) => {
-      const port = catalog.find((candidate) => candidate.slug === slug)
-      if (!port) fail(`unknown port ${slug}`)
-      if (!dispatchable.includes(port)) fail(`${slug} has no dispatchable docs workflow`)
-      return port
-    })
+  const wanted =
+    inputs.ports.trim() === 'all'
+      ? dispatchable
+      : inputs.ports
+          .split(',')
+          .map((slug) => slug.trim())
+          .filter(Boolean)
+          .map((slug) => {
+            const port = catalog.find((candidate) => candidate.slug === slug)
+            if (!port) fail(`unknown port ${slug}`)
+            if (!dispatchable.includes(port)) fail(`${slug} has no dispatchable docs workflow`)
+            return port
+          })
   if (wanted.length === 0) fail('no ports selected')
 
   const ref = inputs.ref.trim()
@@ -76,26 +81,54 @@ export function plan(inputs, catalog, lookup, versions) {
     }
     if (!sources.has(port.repo)) sources.set(port.repo, lookup(port.repo))
     const { defaultBranch, tags } = sources.get(port.repo)
-    const base = { port: port.slug, repo: port.repo, repoOwner: repository[1], repoName: repository[2],
-      workflow: dispatch.workflow, dispatchRef: dispatch.ref ?? defaultBranch, language: dispatch.language ?? '' }
+    const base = {
+      port: port.slug,
+      repo: port.repo,
+      repoOwner: repository[1],
+      repoName: repository[2],
+      workflow: dispatch.workflow,
+      dispatchRef: dispatch.ref ?? defaultBranch,
+      language: dispatch.language ?? '',
+    }
     const releases = tags.filter((tag) => versions.releaseTag(tag, port) !== null)
     if (ref === 'latest') {
       const stable = releases.some((tag) => !versions.packageVersionIsPrerelease(versionOf(tag, port), port.tagGrammar))
-      entries.push({ ...base, sourceRef: defaultBranch, version: 'latest', kind: 'trunk', isDefault: !stable, resolvesTo: '' })
+      entries.push({
+        ...base,
+        sourceRef: defaultBranch,
+        version: 'latest',
+        kind: 'trunk',
+        isDefault: !stable,
+        resolvesTo: '',
+      })
     } else if (ref === 'release') {
       const tag = versions.newestPublishedTag(releases, port, null)
       if (!tag) continue
       const version = versionOf(tag, port)
       const alias = versions.packageVersionIsPrerelease(version, port.tagGrammar) ? 'next' : 'stable'
       entries.push({ ...base, sourceRef: tag, version, kind: 'tag', isDefault: false, resolvesTo: '' })
-      entries.push({ ...base, sourceRef: tag, version: alias, kind: 'alias', isDefault: alias === 'stable', resolvesTo: version })
+      entries.push({
+        ...base,
+        sourceRef: tag,
+        version: alias,
+        kind: 'alias',
+        isDefault: alias === 'stable',
+        resolvesTo: version,
+      })
     } else {
       const kind = inputs.versionKind
       if (!KINDS.includes(kind)) fail(`an exact ref needs version-kind trunk, tag or alias, not ${kind || 'auto'}`)
       if (!SLUG.test(inputs.version ?? '')) fail(`invalid version slug: ${inputs.version ?? ''}`)
       if (kind === 'alias' && !inputs.resolvesTo) fail('an alias requires resolves-to')
       if (kind !== 'alias' && inputs.resolvesTo) fail('resolves-to applies only to aliases')
-      entries.push({ ...base, sourceRef: ref, version: inputs.version, kind, isDefault: Boolean(inputs.isDefault), resolvesTo: inputs.resolvesTo ?? '' })
+      entries.push({
+        ...base,
+        sourceRef: ref,
+        version: inputs.version,
+        kind,
+        isDefault: Boolean(inputs.isDefault),
+        resolvesTo: inputs.resolvesTo ?? '',
+      })
     }
   }
   return entries
@@ -103,8 +136,10 @@ export function plan(inputs, catalog, lookup, versions) {
 
 /** The Markdown summary of a plan. */
 export function summary(entries, dryRun) {
-  const rows = entries.map((e) =>
-    `| ${e.port} | \`${e.repo}/${e.workflow}@${e.dispatchRef}\` | \`${e.sourceRef}\` | ${e.version} | ${e.kind}${e.resolvesTo ? ` → ${e.resolvesTo}` : ''} | ${e.isDefault ? 'yes' : ''} |`)
+  const rows = entries.map(
+    (e) =>
+      `| ${e.port} | \`${e.repo}/${e.workflow}@${e.dispatchRef}\` | \`${e.sourceRef}\` | ${e.version} | ${e.kind}${e.resolvesTo ? ` → ${e.resolvesTo}` : ''} | ${e.isDefault ? 'yes' : ''} |`,
+  )
   return [
     `### ${dryRun ? 'Dry run: would publish' : 'Publishing'} ${entries.length} version(s)`,
     '',
@@ -121,7 +156,9 @@ function lookup(repo) {
   const defaultBranch = /^ref: refs\/heads\/(\S+)\s+HEAD$/m.exec(head)?.[1]
   if (!defaultBranch) fail(`cannot read ${repo}'s default branch`)
   const tags = execFileSync('git', ['ls-remote', '--tags', '--refs', url], { encoding: 'utf8' })
-    .split('\n').filter(Boolean).map((line) => line.replace(/^.*refs\/tags\//, ''))
+    .split('\n')
+    .filter(Boolean)
+    .map((line) => line.replace(/^.*refs\/tags\//, ''))
   return { defaultBranch, tags }
 }
 
@@ -129,14 +166,19 @@ async function main() {
   const env = process.env
   const { PORTS } = await import(resolve(root, 'site/src/lib/ports.ts'))
   const versions = await import(resolve(root, 'site/src/lib/versions.ts'))
-  const entries = plan({
-    ports: env.INPUT_PORTS ?? 'all',
-    ref: env.INPUT_REF ?? 'latest',
-    version: env.INPUT_VERSION ?? '',
-    versionKind: env.INPUT_KIND ?? 'auto',
-    isDefault: env.INPUT_DEFAULT === 'true',
-    resolvesTo: env.INPUT_RESOLVES_TO ?? '',
-  }, PORTS, lookup, versions)
+  const entries = plan(
+    {
+      ports: env.INPUT_PORTS ?? 'all',
+      ref: env.INPUT_REF ?? 'latest',
+      version: env.INPUT_VERSION ?? '',
+      versionKind: env.INPUT_KIND ?? 'auto',
+      isDefault: env.INPUT_DEFAULT === 'true',
+      resolvesTo: env.INPUT_RESOLVES_TO ?? '',
+    },
+    PORTS,
+    lookup,
+    versions,
+  )
   process.stdout.write(`${JSON.stringify({ include: entries })}\n`)
   process.stderr.write(summary(entries, env.INPUT_DRY_RUN !== 'false'))
 }
diff --git a/scripts/skip-unchanged.mjs b/scripts/skip-unchanged.mjs
index babb5698c..d7fc45fff 100644
--- a/scripts/skip-unchanged.mjs
+++ b/scripts/skip-unchanged.mjs
@@ -57,13 +57,17 @@ function parseArgs(argv) {
 export function unchanged(files, objects, prefix, policySince) {
   const since = Date.parse(policySince)
   const remote = new Map(objects.map((object) => [object.Key, object]))
-  return files.filter(({ path, size, md5 }) => {
-    const object = remote.get(`${prefix}${path}`)
-    return object !== undefined
-      && object.Size === size
-      && object.ETag.replaceAll('"', '') === md5
-      && Date.parse(object.LastModified) >= since
-  }).map(({ path }) => path)
+  return files
+    .filter(({ path, size, md5 }) => {
+      const object = remote.get(`${prefix}${path}`)
+      return (
+        object !== undefined &&
+        object.Size === size &&
+        object.ETag.replaceAll('"', '') === md5 &&
+        Date.parse(object.LastModified) >= since
+      )
+    })
+    .map(({ path }) => path)
 }
 
 function localFiles(directory) {
@@ -81,11 +85,22 @@ function localFiles(directory) {
 }
 
 function remoteObjects(bucket, prefix) {
-  const out = execFileSync('aws', [
-    's3api', 'list-objects-v2', '--bucket', bucket, '--prefix', prefix,
-    '--query', 'Contents[].{Key: Key, ETag: ETag, Size: Size, LastModified: LastModified}',
-    '--output', 'json',
-  ], { encoding: 'utf8', maxBuffer: 1 << 30 })
+  const out = execFileSync(
+    'aws',
+    [
+      's3api',
+      'list-objects-v2',
+      '--bucket',
+      bucket,
+      '--prefix',
+      prefix,
+      '--query',
+      'Contents[].{Key: Key, ETag: ETag, Size: Size, LastModified: LastModified}',
+      '--output',
+      'json',
+    ],
+    { encoding: 'utf8', maxBuffer: 1 << 30 },
+  )
   // An empty prefix lists as `null`, not `[]`.
   return JSON.parse(out || 'null') ?? []
 }
@@ -97,7 +112,9 @@ function main() {
   const files = localFiles(directory)
   const skipped = unchanged(files, remoteObjects(options.bucket, options.prefix), options.prefix, options.policySince)
   for (const path of skipped) utimesSync(join(directory, path), 0, 0)
-  process.stderr.write(`skip-unchanged: ${skipped.length} of ${files.length} file(s) unchanged, ${files.length - skipped.length} to upload\n`)
+  process.stderr.write(
+    `skip-unchanged: ${skipped.length} of ${files.length} file(s) unchanged, ${files.length - skipped.length} to upload\n`,
+  )
 }
 
 if (import.meta.url === `file://${process.argv[1]}`) main()
diff --git a/scripts/stage-docfx.mjs b/scripts/stage-docfx.mjs
index 8a34f3efc..65be96b46 100644
--- a/scripts/stage-docfx.mjs
+++ b/scripts/stage-docfx.mjs
@@ -139,7 +139,11 @@ for (const file of files) {
     // `…GetOptionRequest_System…`. Nine broken links, all of them anchors on
     // pages that existed, which is why the page looked fine on arrival.
     const uidRef = decodeUid(href.replace(/\*$/, ''))
-    const label = uidRef.split('.').slice(-2).join('.').replace(/\(.*\)$/, '()')
+    const label = uidRef
+      .split('.')
+      .slice(-2)
+      .join('.')
+      .replace(/\(.*\)$/, '()')
     const hit = pageFor(uidRef)
     if (!hit) return `\`${label}\``
     const hash = hit.member ? `#${anchorOf(uidRef)}` : ''
@@ -180,7 +184,10 @@ for (const file of files) {
 // siblings live in. Using `../` here sent all 215 links to
 // /<port>/<version>/<uid>/, which does not exist.
 // ---------------------------------------------------------------------------
-const namespaces = pages.filter((p) => p.kind === 'Namespace').map((p) => p.uid).sort()
+const namespaces = pages
+  .filter((p) => p.kind === 'Namespace')
+  .map((p) => p.uid)
+  .sort()
 const KIND_ORDER = ['Interface', 'Class', 'Struct', 'Enum', 'Delegate']
 const plural = { Interface: 'Interfaces', Class: 'Classes', Struct: 'Structs', Enum: 'Enums', Delegate: 'Delegates' }
 
diff --git a/scripts/stage-port-docs.mjs b/scripts/stage-port-docs.mjs
index 7a9280084..a04af933c 100644
--- a/scripts/stage-port-docs.mjs
+++ b/scripts/stage-port-docs.mjs
@@ -30,7 +30,7 @@ export function stagedRoutesFor(port) {
 
 const ROUTES = Object.fromEntries(SOURCE_GUIDE_PORTS.map((slug) => [slug, stagedRoutesFor(slug)]))
 
-const expand = (value) => value.startsWith('~/') ? join(homedir(), value.slice(2)) : value
+const expand = (value) => (value.startsWith('~/') ? join(homedir(), value.slice(2)) : value)
 
 function titleAndBody(content, sourcePath) {
   content = content.replace(/<!-- libtmux-logo -->[\s\S]*?<!-- \/libtmux-logo -->\s*/g, '')
@@ -90,8 +90,7 @@ export function rewriteLinks(content, sourcePath, route, routes, repo, revision,
     const url = targetUrl(node.url, node.type === 'image')
     if (url === node.url) return children
     node.url = url
-    return [{ start: node.position.start.offset, end: node.position.end.offset,
-      text: toMarkdown(node).trimEnd() }]
+    return [{ start: node.position.start.offset, end: node.position.end.offset, text: toMarkdown(node).trimEnd() }]
   }
   const edits = editsFor(fromMarkdown(content)).sort((a, b) => b.start - a.start)
   for (const { start, end, text } of edits) content = content.slice(0, start) + text + content.slice(end)
@@ -104,21 +103,33 @@ export function linkSnapshotDepths(content, symbols, referenceRoot) {
   const visit = (node) => {
     const paragraph = node.type === 'listItem' && node.children.length === 1 ? node.children[0] : undefined
     const children = paragraph?.type === 'paragraph' ? paragraph.children : []
-    if (children.length === 2 && children[0].type === 'text' && children[0].value === 'Required depth: '
-        && children[1].type === 'inlineCode') {
+    if (
+      children.length === 2 &&
+      children[0].type === 'text' &&
+      children[0].value === 'Required depth: ' &&
+      children[1].type === 'inlineCode'
+    ) {
       symbols ??= JSON.parse(readFileSync(join(root, 'site/src/data/api/csharp.json'), 'utf8')).symbols
       // The Markdown pipeline adds the locale and preview mount once.
       referenceRoot ??= `/csharp/${defaultVersionFor('csharp')}/reference/`
       const label = children[1]
       const id = `LibTmux.SnapshotDepth.${label.value}`
       const matches = symbols.filter((symbol) => (symbol.publicId ?? symbol.id) === id)
-      if (matches.length !== 1 || matches[0].parent !== 'LibTmux.SnapshotDepth'
-          || matches[0].kind !== 'constant' || matches[0].product !== 'core' || !matches[0].slug) {
+      if (
+        matches.length !== 1 ||
+        matches[0].parent !== 'LibTmux.SnapshotDepth' ||
+        matches[0].kind !== 'constant' ||
+        matches[0].product !== 'core' ||
+        !matches[0].slug
+      ) {
         throw new Error(`F# descriptor depth must resolve to one public .NET enum constant: ${id}`)
       }
       const { start, end } = label.position
-      edits.push({ start: start.offset, end: end.offset,
-        text: `[${content.slice(start.offset, end.offset)}](${referenceRoot}${matches[0].slug}/)` })
+      edits.push({
+        start: start.offset,
+        end: end.offset,
+        text: `[${content.slice(start.offset, end.offset)}](${referenceRoot}${matches[0].slug}/)`,
+      })
     }
     for (const child of node.children ?? []) visit(child)
   }
@@ -132,7 +143,9 @@ export function linkSnapshotDepths(content, symbols, referenceRoot) {
 export function stagedPortGuides(port, artifact) {
   const identity = PORTS.find((entry) => entry.slug === port)
   const routes = ROUTES[port]
-  const linkRoutes = Object.fromEntries(Object.entries(routes).map(([sourcePath, guide]) => [sourcePath, [guide.route]]))
+  const linkRoutes = Object.fromEntries(
+    Object.entries(routes).map(([sourcePath, guide]) => [sourcePath, [guide.route]]),
+  )
   const nativeReferenceFiles = new Set()
   for (const redirect of sourceGuideRedirectsFor(port)) linkRoutes[redirect.sourcePath] = [redirect.target]
   if (port === 'powershell') {
@@ -146,7 +159,10 @@ export function stagedPortGuides(port, artifact) {
       nativeReferenceFiles.add(help)
       for (const parameter of symbol.signatures.flatMap((signature) => signature.params)) {
         if (parameter.binding?.common) continue
-        linkRoutes[`${help}#-${parameter.name.toLowerCase()}`] = [reference, encodeURIComponent(parameterId(symbol, parameter.name))]
+        linkRoutes[`${help}#-${parameter.name.toLowerCase()}`] = [
+          reference,
+          encodeURIComponent(parameterId(symbol, parameter.name)),
+        ]
       }
     }
   }
@@ -169,10 +185,18 @@ export function stagedPortGuides(port, artifact) {
     if (typeof content !== 'string') throw new Error(`${port}: native artifact is missing guide ${sourcePath}`)
     const { title: sourceTitle, body } = titleAndBody(content, sourcePath)
     const title = guide.title ?? sourceTitle
-    const linked = port === 'fsharp' && sourcePath === 'docs/fsharp/supported-query-fields.md'
-      ? linkSnapshotDepths(body) : body
+    const linked =
+      port === 'fsharp' && sourcePath === 'docs/fsharp/supported-query-fields.md' ? linkSnapshotDepths(body) : body
     const nativeLinked = port === 'julia' ? linkDocumenter(linked) : linked
-    const rewritten = rewriteLinks(nativeLinked, sourcePath, route, linkRoutes, artifact.source.repository, artifact.source.revision, nativeReferenceFiles)
+    const rewritten = rewriteLinks(
+      nativeLinked,
+      sourcePath,
+      route,
+      linkRoutes,
+      artifact.source.repository,
+      artifact.source.revision,
+      nativeReferenceFiles,
+    )
     const data = {
       title,
       description: guide.description ?? `${title}: ${identity.packageName} documentation.`,
@@ -184,45 +208,93 @@ export function stagedPortGuides(port, artifact) {
       ...(equivalence ? { equivalence } : {}),
       route,
       source: { repo: artifact.source.repository, path: sourcePath, ref: artifact.source.revision },
-      sidebar: sidebar ?? { group: product ? (product === 'mcp' ? 'MCP' : 'Workspace Manager')
-        : route === 'reference' ? 'API reference' : route.split('/')[0].replace(/^./, (letter) => letter.toUpperCase()) },
+      sidebar: sidebar ?? {
+        group: product
+          ? product === 'mcp'
+            ? 'MCP'
+            : 'Workspace Manager'
+          : route === 'reference'
+            ? 'API reference'
+            : route.split('/')[0].replace(/^./, (letter) => letter.toUpperCase()),
+      },
     }
-    const frontmatter = Object.entries(data).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join('\n')
+    const frontmatter = Object.entries(data)
+      .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+      .join('\n')
     files.set(`${port}/${route}/index.md`, `---\n${frontmatter}\n---\n\n${rewritten.trim()}\n`)
   }
   {
     const source = { repo: artifact.source.repository, path: Object.keys(routes)[0], ref: artifact.source.revision }
     const writeIndex = (route, title, body, cards = []) => {
-      const data = { title, description: `${title} for ${identity.packageName}.`, port, route, source, cards,
-        sidebar: { group: route === 'reference' ? 'API reference' : route[0].toUpperCase() + route.slice(1), label: 'Overview', order: 1 } }
-      const frontmatter = Object.entries(data).map(([key, value]) => `${key}: ${JSON.stringify(value)}`).join('\n')
+      const data = {
+        title,
+        description: `${title} for ${identity.packageName}.`,
+        port,
+        route,
+        source,
+        cards,
+        sidebar: {
+          group: route === 'reference' ? 'API reference' : route[0].toUpperCase() + route.slice(1),
+          label: 'Overview',
+          order: 1,
+        },
+      }
+      const frontmatter = Object.entries(data)
+        .map(([key, value]) => `${key}: ${JSON.stringify(value)}`)
+        .join('\n')
       files.set(`${port}/${route}/index.md`, `---\n${frontmatter}\n---\n\n${body}\n`)
     }
     for (const section of identity.parentLibrary ? ['guides'] : ['guides', 'examples', 'topics', 'concepts']) {
       // Authored overviews own their cards and must keep one public route.
       if (existsSync(join(root, `site/src/content/docs/ports/${port}/${section}/index.md`))) continue
-      const selected = Object.entries(routes).filter(([, entry]) => entry.domain === 'core' && entry.route.startsWith(`${section}/`))
-      const cards = selected.map(([path, entry]) => ({ label: entry.title ?? titleAndBody(guides.get(path), path).title,
-        href: `../${entry.route}/`, body: entry.description ?? `Read about ${titleAndBody(guides.get(path), path).title.toLowerCase()}.`,
-        order: entry.sidebar?.order ?? Number.MAX_SAFE_INTEGER }))
+      const selected = Object.entries(routes).filter(
+        ([, entry]) => entry.domain === 'core' && entry.route.startsWith(`${section}/`),
+      )
+      const cards = selected
+        .map(([path, entry]) => ({
+          label: entry.title ?? titleAndBody(guides.get(path), path).title,
+          href: `../${entry.route}/`,
+          body: entry.description ?? `Read about ${titleAndBody(guides.get(path), path).title.toLowerCase()}.`,
+          order: entry.sidebar?.order ?? Number.MAX_SAFE_INTEGER,
+        }))
         .sort((a, b) => a.order - b.order || a.label.localeCompare(b.label))
         .map(({ order: _order, ...card }) => card)
-      if (section === 'guides' && existsSync(join(root, `site/src/content/docs/ports/${port}/guides/attaching-to-tmux.md`))) cards.splice(Math.min(1, cards.length), 0, {
-        label: 'Attaching to tmux', href: '../guides/attaching-to-tmux/',
-        body: 'Connect to an existing socket and leave its server running.',
-      })
-      if (section === 'examples' && existsSync(join(root, `site/src/content/docs/ports/${port}/examples/capture-pane-output.md`))) cards.unshift({
-        label: 'Capture pane output', href: '../examples/capture-pane-output/',
-        body: 'Send a command, wait for its output, and clean up the private server.',
-      })
-      writeIndex(section, section[0].toUpperCase() + section.slice(1),
-        { guides: 'Connect to tmux and work with its sessions, windows, and panes.',
+      if (
+        section === 'guides' &&
+        existsSync(join(root, `site/src/content/docs/ports/${port}/guides/attaching-to-tmux.md`))
+      )
+        cards.splice(Math.min(1, cards.length), 0, {
+          label: 'Attaching to tmux',
+          href: '../guides/attaching-to-tmux/',
+          body: 'Connect to an existing socket and leave its server running.',
+        })
+      if (
+        section === 'examples' &&
+        existsSync(join(root, `site/src/content/docs/ports/${port}/examples/capture-pane-output.md`))
+      )
+        cards.unshift({
+          label: 'Capture pane output',
+          href: '../examples/capture-pane-output/',
+          body: 'Send a command, wait for its output, and clean up the private server.',
+        })
+      writeIndex(
+        section,
+        section[0].toUpperCase() + section.slice(1),
+        {
+          guides: 'Connect to tmux and work with its sessions, windows, and panes.',
           examples: 'Run complete programs with their documented setup and cleanup.',
           topics: 'Understand object ownership, state, and operation behavior.',
-          concepts: 'Understand captured queries, object identities, and operations.' }[section], cards)
+          concepts: 'Understand captured queries, object identities, and operations.',
+        }[section],
+        cards,
+      )
     }
-    if (identity.referenceKind === 'guide' && identity.ecosystemHost) writeIndex('reference', `${identity.name} API reference`,
-      `Use the [${identity.ecosystemHost.name} reference](${identity.ecosystemHost.url}) for published package versions.\n\nThe [source at this documentation revision](https://github.com/${source.repo}/tree/${source.ref}/${posix.dirname(source.path)}/src/main) contains the wrapper declarations and their documentation.\n\n${identity.name} and its ${identity.parentLibrary.runtime} core share a release version.`)
+    if (identity.referenceKind === 'guide' && identity.ecosystemHost)
+      writeIndex(
+        'reference',
+        `${identity.name} API reference`,
+        `Use the [${identity.ecosystemHost.name} reference](${identity.ecosystemHost.url}) for published package versions.\n\nThe [source at this documentation revision](https://github.com/${source.repo}/tree/${source.ref}/${posix.dirname(source.path)}/src/main) contains the wrapper declarations and their documentation.\n\n${identity.name} and its ${identity.parentLibrary.runtime} core share a release version.`,
+      )
   }
   return files
 }
@@ -230,35 +302,46 @@ export function stagedPortGuides(port, artifact) {
 function artifactFromSource(port, checkout) {
   const modelPath = join(root, `site/src/data/api/${port.slug}.json`)
   const model = port.parentLibrary ? undefined : JSON.parse(readFileSync(modelPath, 'utf8'))
-  const revision = model?.revision ?? execFileSync('git', ['-C', checkout, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim()
+  const revision =
+    model?.revision ?? execFileSync('git', ['-C', checkout, 'rev-parse', 'HEAD'], { encoding: 'utf8' }).trim()
   return artifactFromRevision(port, checkout, revision)
 }
 
 /** Expand the native manual's literal source includes without evaluating Julia. */
 export function expandDocumenter(content, sourcePath, readSource) {
-  return content.replace(/^```jldoctest(?:[^\n]*)$/gm, '```julia').replace(/^```@(eval|autodocs)\n([\s\S]*?)^```/gm, (_block, directive, code) => {
-    if (directive === 'autodocs') {
-      const module = /Modules = \[(LibTmux(?:MCP|Workspace)?)\]/.exec(code)?.[1]
-      if (!module) throw new Error(`Unsupported Documenter module in ${sourcePath}`)
-      const product = module === 'LibTmuxMCP' ? 'mcp/' : module === 'LibTmuxWorkspace' ? 'workspace/' : ''
-      return `Browse the [${module} API reference](/julia/${defaultVersionFor('julia')}/${product}reference/).`
-    }
-    const match = /^using Markdown\s+Markdown\.parse\("```julia\\n" \* read\(joinpath\(@__DIR__, ((?:"[^"\n]+"(?:, )?)+)\), String\) \* "\\n```"\)\s*$/.exec(code)
-    if (!match) throw new Error(`Unsupported Documenter source include in ${sourcePath}`)
-    const parts = [...match[1].matchAll(/"([^"\n]+)"/g)].map((entry) => entry[1])
-    const file = posix.normalize(posix.join(posix.dirname(sourcePath), ...parts))
-    if (file.startsWith('../') || posix.isAbsolute(file)) throw new Error(`Documenter include escapes its checkout: ${file}`)
-    const source = readSource(file)
-    const fence = '`'.repeat(Math.max(3, ...[...source.matchAll(/`+/g)].map((entry) => entry[0].length + 1)))
-    return `${fence}julia title="${posix.basename(file)}"\n${source.trimEnd()}\n${fence}`
-  })
+  return content
+    .replace(/^```jldoctest(?:[^\n]*)$/gm, '```julia')
+    .replace(/^```@(eval|autodocs)\n([\s\S]*?)^```/gm, (_block, directive, code) => {
+      if (directive === 'autodocs') {
+        const module = /Modules = \[(LibTmux(?:MCP|Workspace)?)\]/.exec(code)?.[1]
+        if (!module) throw new Error(`Unsupported Documenter module in ${sourcePath}`)
+        const product = module === 'LibTmuxMCP' ? 'mcp/' : module === 'LibTmuxWorkspace' ? 'workspace/' : ''
+        return `Browse the [${module} API reference](/julia/${defaultVersionFor('julia')}/${product}reference/).`
+      }
+      const match =
+        /^using Markdown\s+Markdown\.parse\("```julia\\n" \* read\(joinpath\(@__DIR__, ((?:"[^"\n]+"(?:, )?)+)\), String\) \* "\\n```"\)\s*$/.exec(
+          code,
+        )
+      if (!match) throw new Error(`Unsupported Documenter source include in ${sourcePath}`)
+      const parts = [...match[1].matchAll(/"([^"\n]+)"/g)].map((entry) => entry[1])
+      const file = posix.normalize(posix.join(posix.dirname(sourcePath), ...parts))
+      if (file.startsWith('../') || posix.isAbsolute(file))
+        throw new Error(`Documenter include escapes its checkout: ${file}`)
+      const source = readSource(file)
+      const fence = '`'.repeat(Math.max(3, ...[...source.matchAll(/`+/g)].map((entry) => entry[0].length + 1)))
+      return `${fence}julia title="${posix.basename(file)}"\n${source.trimEnd()}\n${fence}`
+    })
 }
 
 /** Resolve Documenter references against the same catalog the site renders. */
 function linkDocumenter(content) {
   const model = JSON.parse(readFileSync(join(root, 'site/src/data/api/julia.json'), 'utf8'))
-  const index = new SymbolIndex(model.symbols, (symbol) =>
-    `/julia/${defaultVersionFor('julia')}/${symbol.product && symbol.product !== 'core' ? `${symbol.product}/` : ''}reference/${symbol.slug}/`, 'julia')
+  const index = new SymbolIndex(
+    model.symbols,
+    (symbol) =>
+      `/julia/${defaultVersionFor('julia')}/${symbol.product && symbol.product !== 'core' ? `${symbol.product}/` : ''}reference/${symbol.slug}/`,
+    'julia',
+  )
   const edits = []
   const walk = (node) => {
     if (node.type === 'link' && node.url === '@ref') {
@@ -270,7 +353,8 @@ function linkDocumenter(content) {
     } else for (const child of node.children ?? []) walk(child)
   }
   walk(fromMarkdown(content))
-  for (const edit of edits.sort((a, b) => b.start - a.start)) content = content.slice(0, edit.start) + edit.text + content.slice(edit.end)
+  for (const edit of edits.sort((a, b) => b.start - a.start))
+    content = content.slice(0, edit.start) + edit.text + content.slice(edit.end)
   return content
 }
 
@@ -281,7 +365,10 @@ export function artifactFromRevision(port, checkout, revision) {
   try {
     git('cat-file', '-e', `${revision}^{commit}`)
   } catch (cause) {
-    throw new Error(`${port.slug}: integrated guides need ${port.repo}@${revision} in ${checkout}. Set LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()} to a local checkout containing that commit; this check does not fetch.`, { cause })
+    throw new Error(
+      `${port.slug}: integrated guides need ${port.repo}@${revision} in ${checkout}. Set LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()} to a local checkout containing that commit; this check does not fetch.`,
+      { cause },
+    )
   }
   return {
     source: { repository: port.repo, revision },
@@ -300,30 +387,50 @@ export function run() {
   }
   const publicationPort = process.env.LIBTMUX_DOCS_SOURCE_SHA && process.env.LIBTMUX_DOCS_PORT
   if (cached && selectedPort && selectedPort === publicationPort) {
-    throw new Error(`--cached cannot stage selected publication port ${selectedPort}; regenerate its source guides first`)
+    throw new Error(
+      `--cached cannot stage selected publication port ${selectedPort}; regenerate its source guides first`,
+    )
   }
   const generated = new Map()
-  const selected = PORTS.filter((entry) => entry.slug in ROUTES && (!selectedPort || entry.slug === selectedPort)
-    && (!wrappersOnly || entry.parentLibrary) && !(cached && entry.slug === publicationPort))
+  const selected = PORTS.filter(
+    (entry) =>
+      entry.slug in ROUTES &&
+      (!selectedPort || entry.slug === selectedPort) &&
+      (!wrappersOnly || entry.parentLibrary) &&
+      !(cached && entry.slug === publicationPort),
+  )
   if (refreshCache && !selectedPort) throw new Error('--refresh-cache requires one --port')
   for (const port of selected) {
-    const checkout = expand(process.env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`] || (integrated ? port.checkout : port.worktree))
+    const checkout = expand(
+      process.env[`LIBTMUX_DOCS_CHECKOUT_${port.slug.toUpperCase()}`] || (integrated ? port.checkout : port.worktree),
+    )
     const artifactPath = join(checkout, 'docs/_build/api.json')
     const selectedSource = process.env.LIBTMUX_DOCS_PORT === port.slug && process.env.LIBTMUX_DOCS_SOURCE_SHA
     const cachePath = join(cacheRoot, `${port.slug}.json`)
     const liveWrapper = port.parentLibrary && (refreshCache || selectedSource || (selectedPort && fromSource))
-    if (!cached && !port.parentLibrary && !fromSource && !integrated && !existsSync(artifactPath)) throw new Error(`${port.slug}: native artifact missing at ${artifactPath}`)
-    const artifact = cached || (port.parentLibrary && !liveWrapper)
-      ? JSON.parse(readFileSync(cachePath, 'utf8'))
-      : integrated ? artifactFromRevision(port, checkout, JSON.parse(readFileSync(join(root, `site/src/data/api/${port.slug}.json`), 'utf8')).revision)
-      : fromSource || liveWrapper ? artifactFromSource(port, checkout)
-      : JSON.parse(readFileSync(artifactPath, 'utf8'))
+    if (!cached && !port.parentLibrary && !fromSource && !integrated && !existsSync(artifactPath))
+      throw new Error(`${port.slug}: native artifact missing at ${artifactPath}`)
+    const artifact =
+      cached || (port.parentLibrary && !liveWrapper)
+        ? JSON.parse(readFileSync(cachePath, 'utf8'))
+        : integrated
+          ? artifactFromRevision(
+              port,
+              checkout,
+              JSON.parse(readFileSync(join(root, `site/src/data/api/${port.slug}.json`), 'utf8')).revision,
+            )
+          : fromSource || liveWrapper
+            ? artifactFromSource(port, checkout)
+            : JSON.parse(readFileSync(artifactPath, 'utf8'))
     if (artifact.source.repository !== port.repo || !/^[a-f0-9]{40}$/.test(artifact.source.revision)) {
       throw new Error(`${port.slug}: invalid source guide provenance`)
     }
     if (!port.parentLibrary) {
       const model = JSON.parse(readFileSync(join(root, `site/src/data/api/${port.slug}.json`), 'utf8'))
-      if (artifact.source.revision !== model.revision) throw new Error(`${port.slug}: guide source ${artifact.source.revision} differs from integrated model ${model.revision}`)
+      if (artifact.source.revision !== model.revision)
+        throw new Error(
+          `${port.slug}: guide source ${artifact.source.revision} differs from integrated model ${model.revision}`,
+        )
     }
     const expected = selectedSource
     if (expected && artifact.source?.revision !== expected) {
@@ -343,11 +450,13 @@ export function run() {
       for (const entry of readdirSync(directory, { withFileTypes: true })) {
         const relative = posix.join(prefix, entry.name)
         if (entry.isDirectory()) walk(join(directory, entry.name), relative)
-        else if (selected.some((port) => relative.startsWith(`${port.slug}/`))) actual.set(relative, readFileSync(join(directory, entry.name), 'utf8'))
+        else if (selected.some((port) => relative.startsWith(`${port.slug}/`)))
+          actual.set(relative, readFileSync(join(directory, entry.name), 'utf8'))
       }
     }
     walk(output)
-    const stale = generated.size !== actual.size || [...generated].some(([file, content]) => actual.get(file) !== content)
+    const stale =
+      generated.size !== actual.size || [...generated].some(([file, content]) => actual.get(file) !== content)
     if (stale) throw new Error('staged port guides are missing or stale; rerun without --check')
   } else {
     if (selectedPort || wrappersOnly) {
diff --git a/scripts/test-all.sh b/scripts/test-all.sh
index f5cbbc020..98387ddd1 100755
--- a/scripts/test-all.sh
+++ b/scripts/test-all.sh
@@ -172,6 +172,15 @@ node scripts/check-source-links.mjs
 step 'unit tests'
 LIBTMUX_DOCS_TEST_SOURCE_ONLY=1 pnpm run --recursive --if-present test
 
+step 'format'
+pnpm run format:check
+
+# Hand-written fences are not formatted; this holds them to 80 columns.
+# The self-test plants a wide line first, so a check that cannot fail is caught.
+step 'example width'
+python3 scripts/check_example_width.py --self-test
+python3 scripts/check_example_width.py
+
 step 'lint'
 pnpm run lint
 
diff --git a/scripts/test-loop.mjs b/scripts/test-loop.mjs
index 06668162d..7ae77756a 100644
--- a/scripts/test-loop.mjs
+++ b/scripts/test-loop.mjs
@@ -17,7 +17,9 @@ let cancelled = false
 const stop = (signal = 'SIGTERM') => {
   for (const child of children) if (child.pid) stoppingGroups.add(child.pid)
   for (const pid of stoppingGroups) {
-    try { process.kill(-pid, signal) } catch (error) {
+    try {
+      process.kill(-pid, signal)
+    } catch (error) {
       if (error.code !== 'ESRCH') throw error
     }
   }
@@ -34,7 +36,9 @@ function run(command, args) {
   if (cancelled) throw new Error(`${loop} cancelled or exceeded ${budget}s`)
   const promise = new Promise((resolve, reject) => {
     const child = spawn(command, args, {
-      cwd: root, stdio: 'inherit', detached: true,
+      cwd: root,
+      stdio: 'inherit',
+      detached: true,
       env: { ...process.env, LIBTMUX_DOCS_TEST_SOURCE_ONLY: '1' },
     })
     children.add(child)
@@ -56,34 +60,54 @@ const pnpm = (...args) => {
   const entry = process.env.npm_execpath ?? 'pnpm'
   return /\.[cm]?js$/.test(entry) ? node(entry, ...args) : run(entry, args)
 }
-const tests = (directory, names = []) => node(vitest, 'run', '--root', directory,
-  '--maxWorkers', directory === 'site' ? '3' : '2', '--pool', 'threads', '--fsModuleCache',
-  ...(loop === 'medium' ? ['--exclude', '**/*.outer.test.ts'] : []),
-  ...names.map((name) => `test/${name}.test.ts`))
+const tests = (directory, names = []) =>
+  node(
+    vitest,
+    'run',
+    '--root',
+    directory,
+    '--maxWorkers',
+    directory === 'site' ? '3' : '2',
+    '--pool',
+    'threads',
+    '--fsModuleCache',
+    ...(loop === 'medium' ? ['--exclude', '**/*.outer.test.ts'] : []),
+    ...names.map((name) => `test/${name}.test.ts`),
+  )
 
 try {
   if (loop !== 'inner') await node('scripts/stage-port-docs.mjs', '--integrated')
-  const checks = loop === 'inner' ? [
-    tests('packages/api-model', ['concepts', 'resolver', 'mentions']),
-    tests('site', ['native-switchers', 'native-shell-context', 'normalize-native-shell']),
-  ] : ['packages/api-model', 'packages/theme', 'site'].map((directory) => tests(directory))
-  if (loop !== 'inner') checks.push(
-    pnpm('run', '--recursive', 'lint'),
-    pnpm('exec', 'oxlint', 'scripts'),
-    node('scripts/check-api-links.mjs'),
-    node('scripts/check-nav.mjs'),
-    node('scripts/gen-mentions.mjs', '--check'),
-    node('scripts/gen-shell-ports.mjs', '--check'),
-    node('scripts/gen-brand-css.mjs', '--check'),
-  )
-  if (loop === 'outer') checks.push(
-    node('scripts/gen-example-sources.mjs', '--check'),
-    pnpm('run', '--recursive', 'type-check'),
-    node('site/scripts/check-dev.mjs', '--sample'),
-  )
+  const checks =
+    loop === 'inner'
+      ? [
+          tests('packages/api-model', ['concepts', 'resolver', 'mentions']),
+          tests('site', ['native-switchers', 'native-shell-context', 'normalize-native-shell']),
+        ]
+      : ['packages/api-model', 'packages/theme', 'site'].map((directory) => tests(directory))
+  if (loop !== 'inner')
+    checks.push(
+      pnpm('run', 'format:check'),
+      run('python3', ['scripts/check_example_width.py', '--self-test']).then(() =>
+        run('python3', ['scripts/check_example_width.py']),
+      ),
+      pnpm('run', '--recursive', 'lint'),
+      pnpm('exec', 'oxlint', 'scripts'),
+      node('scripts/check-api-links.mjs'),
+      node('scripts/check-nav.mjs'),
+      node('scripts/gen-mentions.mjs', '--check'),
+      node('scripts/gen-shell-ports.mjs', '--check'),
+      node('scripts/gen-brand-css.mjs', '--check'),
+    )
+  if (loop === 'outer')
+    checks.push(
+      node('scripts/gen-example-sources.mjs', '--check'),
+      pnpm('run', '--recursive', 'type-check'),
+      node('site/scripts/check-dev.mjs', '--sample'),
+    )
   await Promise.all(checks)
   const elapsed = (performance.now() - started) / 1000
-  if (cancelled || elapsed >= budget) throw new Error(`${loop} cancelled or exceeded ${budget}s: ${elapsed.toFixed(2)}s`)
+  if (cancelled || elapsed >= budget)
+    throw new Error(`${loop} cancelled or exceeded ${budget}s: ${elapsed.toFixed(2)}s`)
   console.log(`${loop}: PASS in ${elapsed.toFixed(2)}s (budget <${budget}s; publication audit excluded)`)
 } catch (error) {
   console.error(error.message)
@@ -92,10 +116,12 @@ try {
   clearTimeout(deadline)
   if (children.size || stoppingGroups.size) {
     stop()
-    await new Promise((resolve) => setTimeout(() => {
-      stop('SIGKILL')
-      resolve()
-    }, 500))
+    await new Promise((resolve) =>
+      setTimeout(() => {
+        stop('SIGKILL')
+        resolve()
+      }, 500),
+    )
   }
   await Promise.allSettled(pending)
 }
diff --git a/site/astro.config.ts b/site/astro.config.ts
index 12f4bd145..c44caa916 100644
--- a/site/astro.config.ts
+++ b/site/astro.config.ts
@@ -88,15 +88,25 @@ const isPlaceholder = (page: string): boolean => {
 }
 
 const sharedWorkspaceFiles = readdirSync(join(contentRoot, '../_workspace-shared'), { recursive: true })
-const workspacePages = new Map(PORTS.map((port) => [port.slug, new Set(
-  [
-    ...readdirSync(join(contentRoot, 'ports', port.slug), { recursive: true }),
-    // Include the same synthetic pages and ports as workspaceDocsLoader.
-    ...(KNOWN_PORTS.has(port.slug) ? sharedWorkspaceFiles : []),
-  ]
-    .filter((path): path is string => typeof path === 'string' && /\.mdx?$/.test(path))
-    .map((path) => path.replaceAll('\\', '/').replace(/\.mdx?$/, '').replace(/\/index$/, '')),
-)]))
+const workspacePages = new Map(
+  PORTS.map((port) => [
+    port.slug,
+    new Set(
+      [
+        ...readdirSync(join(contentRoot, 'ports', port.slug), { recursive: true }),
+        // Include the same synthetic pages and ports as workspaceDocsLoader.
+        ...(KNOWN_PORTS.has(port.slug) ? sharedWorkspaceFiles : []),
+      ]
+        .filter((path): path is string => typeof path === 'string' && /\.mdx?$/.test(path))
+        .map((path) =>
+          path
+            .replaceAll('\\', '/')
+            .replace(/\.mdx?$/, '')
+            .replace(/\/index$/, ''),
+        ),
+    ),
+  ]),
+)
 
 const isWorkspaceRedirect = (page: string): boolean => {
   const match = new URL(page).pathname.match(/\/([^/]+)\/[^/]+\/(workspace\/.*)$/)
@@ -104,10 +114,15 @@ const isWorkspaceRedirect = (page: string): boolean => {
   return Boolean(published && workspaceRedirectPath(match![2], published))
 }
 
-const sourceGuideAliases = new Map(SOURCE_GUIDE_PORTS.map((port) => [port, new Set([
-  ...sourceGuidesFor(port).flatMap((guide) => guide.aliases),
-  ...sourceGuideRedirectsFor(port).map((redirect) => redirect.path),
-])]))
+const sourceGuideAliases = new Map(
+  SOURCE_GUIDE_PORTS.map((port) => [
+    port,
+    new Set([
+      ...sourceGuidesFor(port).flatMap((guide) => guide.aliases),
+      ...sourceGuideRedirectsFor(port).map((redirect) => redirect.path),
+    ]),
+  ]),
+)
 
 const isSourceGuideRedirect = (page: string): boolean => {
   const [, port, , ...route] = new URL(page).pathname.split('/').filter(Boolean)
@@ -144,8 +159,12 @@ export default defineConfig({
       ? [
           sitemap({
             filter: (page) =>
-              !page.includes('/pr-') && !page.includes('/demo') && !isPlaceholder(page) &&
-              !isWorkspaceRedirect(page) && !isSourceGuideRedirect(page) && !isPortRoot(page) &&
+              !page.includes('/pr-') &&
+              !page.includes('/demo') &&
+              !isPlaceholder(page) &&
+              !isWorkspaceRedirect(page) &&
+              !isSourceGuideRedirect(page) &&
+              !isPortRoot(page) &&
               !isLegacyTmuxManualPath(new URL(page).pathname) &&
               !/\/tmux\/(?!latest\/)[^/]+\/(?:manual|reference)\//.test(new URL(page).pathname),
           }),
@@ -352,27 +371,35 @@ export default defineConfig({
 
   vite: {
     resolve: { tsconfigPaths: false, noExternal: ['@tailwindcss/typography'] },
-    plugins: [tailwindcss() as never, {
-      name: 'libtmux-shared-assets-dev',
-      apply: 'serve',
-      configureServer(server) {
-        // Port builds use a nested base, while their shell assets belong to
-        // the locale root. Serve the same public files at that root in dev.
-        const root = (env.LIBTMUX_DOCS_ROOT ?? '/').replace(/\/+$/, '')
-        if (base.replace(/\/+$/, '') === root) return
-        server.middlewares.use((request, response, next) => {
-          const pathname = new URL(request.url ?? '/', 'http://localhost').pathname
-          if (!pathname.startsWith(`${root}/`)) return next()
-          const asset = pathname.slice(root.length + 1)
-          if (!/^(?:brand\/|_shell\/|versions\.json$)/.test(asset) || asset.includes('..')) return next()
-          const file = fileURLToPath(new URL(`./public/${asset}`, import.meta.url))
-          if (!existsSync(file) || !statSync(file).isFile()) return next()
-          const contentType = asset.endsWith('.svg') ? 'image/svg+xml' : asset.endsWith('.css') ? 'text/css'
-            : asset.endsWith('.js') ? 'text/javascript' : 'application/json'
-          response.setHeader('Content-Type', contentType)
-          createReadStream(file).pipe(response)
-        })
+    plugins: [
+      tailwindcss() as never,
+      {
+        name: 'libtmux-shared-assets-dev',
+        apply: 'serve',
+        configureServer(server) {
+          // Port builds use a nested base, while their shell assets belong to
+          // the locale root. Serve the same public files at that root in dev.
+          const root = (env.LIBTMUX_DOCS_ROOT ?? '/').replace(/\/+$/, '')
+          if (base.replace(/\/+$/, '') === root) return
+          server.middlewares.use((request, response, next) => {
+            const pathname = new URL(request.url ?? '/', 'http://localhost').pathname
+            if (!pathname.startsWith(`${root}/`)) return next()
+            const asset = pathname.slice(root.length + 1)
+            if (!/^(?:brand\/|_shell\/|versions\.json$)/.test(asset) || asset.includes('..')) return next()
+            const file = fileURLToPath(new URL(`./public/${asset}`, import.meta.url))
+            if (!existsSync(file) || !statSync(file).isFile()) return next()
+            const contentType = asset.endsWith('.svg')
+              ? 'image/svg+xml'
+              : asset.endsWith('.css')
+                ? 'text/css'
+                : asset.endsWith('.js')
+                  ? 'text/javascript'
+                  : 'application/json'
+            response.setHeader('Content-Type', contentType)
+            createReadStream(file).pipe(response)
+          })
+        },
       },
-    }],
+    ],
   },
 })
diff --git a/site/ec.config.mjs b/site/ec.config.mjs
index 513588ad4..6e5f5e364 100644
--- a/site/ec.config.mjs
+++ b/site/ec.config.mjs
@@ -23,16 +23,17 @@ export default defineEcConfig({
     theme.settings.push(
       { scope: ['support.type.property-name.json'], settings: { foreground: dark ? '#f0a0c0' : '#963b63' } },
       { scope: ['string.quoted.double.json'], settings: { foreground: dark ? '#e6c86e' : '#755400' } },
-      { scope: ['constant.language.json', 'constant.numeric.json'], settings: { foreground: dark ? '#c3a6f4' : '#6840a0' } },
+      {
+        scope: ['constant.language.json', 'constant.numeric.json'],
+        settings: { foreground: dark ? '#c3a6f4' : '#6840a0' },
+      },
     )
   },
   plugins: [shellPrompt(), copyReadiness()],
   shiki: { langs: [tmuxUsage, ...bash, tmuxShell, tmuxConfig], langAlias: { sbt: 'scala', tmux: 'tmux-config' } },
   useDarkModeMediaQuery: false,
   themeCssSelector: (theme) =>
-    theme.name === 'github-light'
-      ? '[data-theme-mode]:not([data-theme-mode="dark"])'
-      : '[data-theme-mode="dark"]',
+    theme.name === 'github-light' ? '[data-theme-mode]:not([data-theme-mode="dark"])' : '[data-theme-mode="dark"]',
   styleOverrides: {
     borderRadius: '0.375rem',
     borderWidth: '1px',
diff --git a/site/scripts/check-clipboard.mjs b/site/scripts/check-clipboard.mjs
index 3b8362860..8c9d8dac2 100644
--- a/site/scripts/check-clipboard.mjs
+++ b/site/scripts/check-clipboard.mjs
@@ -14,55 +14,81 @@ export function assertCompleteApiExample(rendered, example) {
     const files = example.files.filter((entry) => entry.sourceFile === file)
     const linkGroups = files.length ? files.map((entry) => rendered.sourceLinks[entry.block]) : [rendered.links]
     for (const links of linkGroups) {
-      assert.deepEqual(links.filter((link) => link.href === href),
-        [{ href, label: 'View source' }], `${example.symbol}: exact pinned source is a readable link for its file`)
+      assert.deepEqual(
+        links.filter((link) => link.href === href),
+        [{ href, label: 'View source' }],
+        `${example.symbol}: exact pinned source is a readable link for its file`,
+      )
     }
   }
   assert(!rendered.text.includes('[source example]('), `${example.symbol}: no literal Markdown link`)
   for (const file of example.files) {
     if (file.clipboardSha256) {
-      assert.equal(createHash('sha256').update(rendered.files[file.block]).digest('hex'),
-        file.clipboardSha256, `${example.symbol}/${file.name}: exact clipboard bytes`)
+      assert.equal(
+        createHash('sha256').update(rendered.files[file.block]).digest('hex'),
+        file.clipboardSha256,
+        `${example.symbol}/${file.name}: exact clipboard bytes`,
+      )
     }
-    const digest = createHash('sha256').update(rendered.files[file.block] + '\n').digest('hex')
+    const digest = createHash('sha256')
+      .update(rendered.files[file.block] + '\n')
+      .digest('hex')
     assert.equal(digest, file.sha256, `${example.symbol}/${file.name}: copied file matches native receipt`)
   }
   if (example.consoleBlocks) {
-    assert.deepEqual(example.consoleBlocks.map((index) => rendered.files[index]), example.shellRecipe,
-      `${example.symbol}: copied setup and run commands match native receipts`)
+    assert.deepEqual(
+      example.consoleBlocks.map((index) => rendered.files[index]),
+      example.shellRecipe,
+      `${example.symbol}: copied setup and run commands match native receipts`,
+    )
   }
 }
 
 /** Inspect rendered API examples against their native execution receipts. */
 export async function checkCompleteApiExamples(browser, base) {
-  const examples = JSON.parse(readFileSync(new URL('../test/fixtures/api-examples.json', import.meta.url), 'utf8')).examples
+  const examples = JSON.parse(
+    readFileSync(new URL('../test/fixtures/api-examples.json', import.meta.url), 'utf8'),
+  ).examples
   const page = await browser.newPage()
   try {
     for (const example of examples) {
       const path = example.page.replace(`ports/${example.port}/`, `${example.port}/latest/`)
       const response = await page.request.get(`${base}/${path}/`)
       assert(response.ok(), `${example.symbol}: HTTP ${response.status()}`)
-      const rendered = await page.evaluate(({ html, symbol }) => {
-        const doc = new DOMParser().parseFromString(html, 'text/html')
-        const section = doc.getElementById(`${symbol}.examples`)
-        return section && {
-          text: section.textContent,
-          links: [...section.querySelectorAll('.gp-sphinx-api-example-intro a')]
-            .map((link) => ({ href: link.getAttribute('href'), label: link.textContent })),
-          sourceLinks: [...section.querySelectorAll('.gp-sphinx-api-example')].map((block) => {
-            const intro = block.previousElementSibling
-            return intro?.matches('.gp-sphinx-api-example-intro')
-              ? [...intro.querySelectorAll('a')].map((link) => ({ href: link.getAttribute('href'), label: link.textContent }))
-              : []
-          }),
-          files: [...section.querySelectorAll('.gp-sphinx-api-example [data-code]')]
-            .map((button) => button.getAttribute('data-code').replaceAll('\x7f', '\n')),
-        }
-      }, { html: await response.text(), symbol: example.publicId ?? example.symbol })
+      const rendered = await page.evaluate(
+        ({ html, symbol }) => {
+          const doc = new DOMParser().parseFromString(html, 'text/html')
+          const section = doc.getElementById(`${symbol}.examples`)
+          return (
+            section && {
+              text: section.textContent,
+              links: [...section.querySelectorAll('.gp-sphinx-api-example-intro a')].map((link) => ({
+                href: link.getAttribute('href'),
+                label: link.textContent,
+              })),
+              sourceLinks: [...section.querySelectorAll('.gp-sphinx-api-example')].map((block) => {
+                const intro = block.previousElementSibling
+                return intro?.matches('.gp-sphinx-api-example-intro')
+                  ? [...intro.querySelectorAll('a')].map((link) => ({
+                      href: link.getAttribute('href'),
+                      label: link.textContent,
+                    }))
+                  : []
+              }),
+              files: [...section.querySelectorAll('.gp-sphinx-api-example [data-code]')].map((button) =>
+                button.getAttribute('data-code').replaceAll('\x7f', '\n'),
+              ),
+            }
+          )
+        },
+        { html: await response.text(), symbol: example.publicId ?? example.symbol },
+      )
       assert(rendered, `${example.symbol}: Examples section exists`)
       assertCompleteApiExample(rendered, example)
     }
-    console.log(`API examples: ${examples.length} programs on ${new Set(examples.map((example) => example.page)).size} pages preserve source links and copied file hashes`)
+    console.log(
+      `API examples: ${examples.length} programs on ${new Set(examples.map((example) => example.page)).size} pages preserve source links and copied file hashes`,
+    )
   } finally {
     await page.close()
   }
@@ -101,32 +127,43 @@ export async function checkClipboard(page, base) {
     for (const mode of ['api', 'rejected', 'fallback', 'false', 'throw']) {
       await page.evaluate((mode) => {
         window.__clipboardProbe = { api: [], fallback: [] }
-        Object.defineProperty(navigator, 'clipboard', { configurable: true,
-          value: ['api', 'rejected'].includes(mode) ? {
-            writeText: async (text) => {
-              window.__clipboardProbe.api.push(text)
-              if (mode === 'rejected') throw new Error('Clipboard denied')
-            },
-          } : undefined,
+        Object.defineProperty(navigator, 'clipboard', {
+          configurable: true,
+          value: ['api', 'rejected'].includes(mode)
+            ? {
+                writeText: async (text) => {
+                  window.__clipboardProbe.api.push(text)
+                  if (mode === 'rejected') throw new Error('Clipboard denied')
+                },
+              }
+            : undefined,
+        })
+        Object.defineProperty(document, 'execCommand', {
+          configurable: true,
+          value: () => {
+            window.__clipboardProbe.fallback.push(document.activeElement.value)
+            if (mode === 'throw') throw new Error('Clipboard denied')
+            return mode !== 'false'
+          },
         })
-        Object.defineProperty(document, 'execCommand', { configurable: true, value: () => {
-          window.__clipboardProbe.fallback.push(document.activeElement.value)
-          if (mode === 'throw') throw new Error('Clipboard denied')
-          return mode !== 'false'
-        } })
       }, mode)
-      await button.evaluate((element) => { element.textContent = 'Copy' })
+      await button.evaluate((element) => {
+        element.textContent = 'Copy'
+      })
       const copied = !['false', 'throw'].includes(mode)
       // Record the transient label before a busy renderer can reset it.
-      await button.evaluate((element, label) => {
-        window.__copyFeedback = undefined
-        const observer = new MutationObserver(() => {
-          if (element.textContent !== label) return
-          window.__copyFeedback = label
-          observer.disconnect()
-        })
-        observer.observe(element, { childList: true, characterData: true, subtree: true })
-      }, copied ? 'Copied' : 'Copy failed')
+      await button.evaluate(
+        (element, label) => {
+          window.__copyFeedback = undefined
+          const observer = new MutationObserver(() => {
+            if (element.textContent !== label) return
+            window.__copyFeedback = label
+            observer.disconnect()
+          })
+          observer.observe(element, { childList: true, characterData: true, subtree: true })
+        },
+        copied ? 'Copied' : 'Copy failed',
+      )
       await button.click()
       await page.waitForFunction((label) => window.__copyFeedback === label, copied ? 'Copied' : 'Copy failed')
       const announcement = copied ? 'Copied to clipboard.' : 'Copy failed. Select and copy the text manually.'
@@ -146,48 +183,90 @@ export async function checkClipboard(page, base) {
   const actions = page.locator('[data-page-actions]')
   await actions.locator('summary').click()
   const edit = actions.getByRole('link', { name: 'Edit this page on GitHub' })
-  assert.match(await edit.getAttribute('href'), /\/edit\/main\/site\/src\/content\/docs\/examples\/attach-and-send-keys\.md$/)
+  assert.match(
+    await edit.getAttribute('href'),
+    /\/edit\/main\/site\/src\/content\/docs\/examples\/attach-and-send-keys\.md$/,
+  )
   assert.equal(await page.locator('article').getByRole('link', { name: 'Edit this page on GitHub' }).count(), 0)
   const markdownHref = await page.locator('link[rel="alternate"][type="text/markdown"]').getAttribute('href')
   const markdown = await (await page.request.get(new URL(markdownHref, page.url()).href)).text()
-  const panelHeight = await actions.locator('.page-actions__panel').evaluate((element) => element.getBoundingClientRect().height)
+  const panelHeight = await actions
+    .locator('.page-actions__panel')
+    .evaluate((element) => element.getBoundingClientRect().height)
   for (const mode of ['accepted', 'refused']) {
     await page.evaluate((mode) => {
       window.__markdownCopied = undefined
-      Object.defineProperty(navigator, 'clipboard', { configurable: true, value: {
-        write: async (items) => {
-          if (mode === 'refused') throw new Error('Clipboard denied')
-          window.__markdownCopied = await (await items[0].getType('text/plain')).text()
+      Object.defineProperty(navigator, 'clipboard', {
+        configurable: true,
+        value: {
+          write: async (items) => {
+            if (mode === 'refused') throw new Error('Clipboard denied')
+            window.__markdownCopied = await (await items[0].getType('text/plain')).text()
+          },
         },
-      } })
+      })
     }, mode)
     await actions.getByRole('button', { name: 'Copy Markdown' }).click()
-    await page.waitForFunction(() => /Markdown copied|Could not copy/.test(document.querySelector('[data-page-actions] [role="status"]').textContent))
+    await page.waitForFunction(() =>
+      /Markdown copied|Could not copy/.test(document.querySelector('[data-page-actions] [role="status"]').textContent),
+    )
     if (mode === 'accepted') {
       assert.equal(await page.evaluate(() => window.__markdownCopied), markdown)
       await actions.locator('[data-page-copy][data-copied] .page-actions__copied').waitFor({ state: 'visible' })
-      assert.equal(await actions.locator('.page-actions__panel').evaluate((element) => element.getBoundingClientRect().height), panelHeight,
-        'Copy success does not add a menu row')
-      assert(await actions.locator('[role="status"]').evaluate((element) => element.classList.contains('sr-only')), 'Success is announced without a visible status row')
-      assert(await actions.getByRole('button', { name: 'Copy Markdown' }).evaluate((element) => element === document.activeElement), 'Copy preserves focus')
-      await page.waitForFunction(() => !document.querySelector('[data-page-copy]').hasAttribute('data-copied'), null, { timeout: 3000 })
+      assert.equal(
+        await actions.locator('.page-actions__panel').evaluate((element) => element.getBoundingClientRect().height),
+        panelHeight,
+        'Copy success does not add a menu row',
+      )
+      assert(
+        await actions.locator('[role="status"]').evaluate((element) => element.classList.contains('sr-only')),
+        'Success is announced without a visible status row',
+      )
+      assert(
+        await actions
+          .getByRole('button', { name: 'Copy Markdown' })
+          .evaluate((element) => element === document.activeElement),
+        'Copy preserves focus',
+      )
+      await page.waitForFunction(() => !document.querySelector('[data-page-copy]').hasAttribute('data-copied'), null, {
+        timeout: 3000,
+      })
     } else {
-      assert.equal(await actions.getByRole('link', { name: 'Open Markdown' }).getAttribute('href'), new URL(markdownHref, page.url()).href)
-      assert.equal(await actions.locator('[data-page-copy][data-copied]').count(), 0, 'A failed copy clears the success checkmark')
-      assert(await actions.getByRole('link', { name: 'Open Markdown' }).isVisible(), 'Failure keeps a visible recovery action')
+      assert.equal(
+        await actions.getByRole('link', { name: 'Open Markdown' }).getAttribute('href'),
+        new URL(markdownHref, page.url()).href,
+      )
+      assert.equal(
+        await actions.locator('[data-page-copy][data-copied]').count(),
+        0,
+        'A failed copy clears the success checkmark',
+      )
+      assert(
+        await actions.getByRole('link', { name: 'Open Markdown' }).isVisible(),
+        'Failure keeps a visible recovery action',
+      )
     }
   }
-  await page.evaluate(() => { window.print = () => { window.__pagePrinted = true } })
+  await page.evaluate(() => {
+    window.print = () => {
+      window.__pagePrinted = true
+    }
+  })
   await actions.getByRole('button', { name: 'Print', exact: true }).click()
   assert(await page.evaluate(() => window.__pagePrinted), 'Print invokes the browser print dialog')
   assert.equal(await actions.getAttribute('open'), null)
   await actions.locator('summary').click()
   await page.keyboard.press('Escape')
   assert.equal(await actions.getAttribute('open'), null)
-  assert(await actions.locator('summary').evaluate((element) => document.activeElement === element), 'Escape returns focus to Page actions')
+  assert(
+    await actions.locator('summary').evaluate((element) => document.activeElement === element),
+    'Escape returns focus to Page actions',
+  )
   console.log('Page actions: Markdown bytes, clipboard refusal, Edit, Print and Escape pass')
 
-  const examples = JSON.parse(readFileSync(new URL('../test/fixtures/product-examples.json', import.meta.url), 'utf8')).examples
+  const examples = JSON.parse(
+    readFileSync(new URL('../test/fixtures/product-examples.json', import.meta.url), 'utf8'),
+  ).examples
   const example = examples.find((entry) => entry.page === 'ports/go/workspace/internals/examples')
   assert(example, 'The Go workspace example has a native execution receipt')
   const response = await page.goto(`${base}/go/latest/workspace/internals/examples/`, { waitUntil: 'load' })
@@ -196,21 +275,38 @@ export async function checkClipboard(page, base) {
   for (const file of example.files) {
     const figure = page.getByRole('figure', { name: file.name, exact: true })
     const displayed = await figure.locator('.ec-line .code').allTextContents()
-    assert.equal(digest(displayed.map((line) => line === '\n' ? '' : line).join('\n') + '\n'),
-      file.sha256, `${file.name}: rendering preserves executed bytes, including tabs`)
+    assert.equal(
+      digest(displayed.map((line) => (line === '\n' ? '' : line)).join('\n') + '\n'),
+      file.sha256,
+      `${file.name}: rendering preserves executed bytes, including tabs`,
+    )
     await page.evaluate(() => {
       window.__programCopied = undefined
-      Object.defineProperty(navigator, 'clipboard', { configurable: true, value: {
-        writeText: async (text) => { window.__programCopied = text },
-      } })
+      Object.defineProperty(navigator, 'clipboard', {
+        configurable: true,
+        value: {
+          writeText: async (text) => {
+            window.__programCopied = text
+          },
+        },
+      })
     })
     await figure.getByRole('button', { name: 'Copy to clipboard', exact: true }).click()
     await page.waitForFunction(() => window.__programCopied !== undefined)
-    assert.equal(digest(await page.evaluate(() => window.__programCopied) + '\n'), file.sha256,
-      `${file.name}: the copy button preserves executed bytes`)
+    assert.equal(
+      digest((await page.evaluate(() => window.__programCopied)) + '\n'),
+      file.sha256,
+      `${file.name}: the copy button preserves executed bytes`,
+    )
   }
-  assert.equal(await page.locator('.expressive-code .code').first().evaluate((element) =>
-    getComputedStyle(element).tabSize), '2', 'Literal tabs use two-column tab stops')
+  assert.equal(
+    await page
+      .locator('.expressive-code .code')
+      .first()
+      .evaluate((element) => getComputedStyle(element).tabSize),
+    '2',
+    'Literal tabs use two-column tab stops',
+  )
   console.log('Complete Go example: rendered and copied files match the native receipt, including tabs')
 }
 
diff --git a/site/scripts/check-color-scheme.mjs b/site/scripts/check-color-scheme.mjs
index 3c71ee8eb..b6b634b43 100644
--- a/site/scripts/check-color-scheme.mjs
+++ b/site/scripts/check-color-scheme.mjs
@@ -3,13 +3,23 @@ import assert from 'node:assert/strict'
 /** Compact cycling and wide radios share the same saved preference. */
 export async function checkColorScheme(browser, base) {
   for (const blocked of [false, true]) {
-    const context = await browser.newContext({ viewport: { width: 596, height: 777 }, colorScheme: 'light', reducedMotion: 'reduce' })
+    const context = await browser.newContext({
+      viewport: { width: 596, height: 777 },
+      colorScheme: 'light',
+      reducedMotion: 'reduce',
+    })
     try {
       if (blocked) {
-        await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) => route.fulfill({ contentType: 'application/javascript', body: 'export {}' }))
-        await context.addInitScript(() => Object.defineProperty(window, 'localStorage', {
-          get() { throw new DOMException('Storage blocked', 'SecurityError') },
-        }))
+        await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) =>
+          route.fulfill({ contentType: 'application/javascript', body: 'export {}' }),
+        )
+        await context.addInitScript(() =>
+          Object.defineProperty(window, 'localStorage', {
+            get() {
+              throw new DOMException('Storage blocked', 'SecurityError')
+            },
+          }),
+        )
       }
       const page = await context.newPage()
       const errors = []
@@ -33,10 +43,18 @@ export async function checkColorScheme(browser, base) {
       await cycle.focus()
       await page.keyboard.press('Space')
       await check('dark', 'Dark', 'Auto', 'dark')
-      assert(await cycle.evaluate((element) => parseFloat(getComputedStyle(element).outlineWidth) > 0), 'The cycling button has visible keyboard focus')
+      assert(
+        await cycle.evaluate((element) => parseFloat(getComputedStyle(element).outlineWidth) > 0),
+        'The cycling button has visible keyboard focus',
+      )
       await page.reload()
       await cycle.waitFor({ state: 'visible' })
-      await check(blocked ? 'system' : 'dark', blocked ? 'Auto' : 'Dark', blocked ? 'Light' : 'Auto', blocked ? 'light' : 'dark')
+      await check(
+        blocked ? 'system' : 'dark',
+        blocked ? 'Auto' : 'Dark',
+        blocked ? 'Light' : 'Auto',
+        blocked ? 'light' : 'dark',
+      )
       if (!blocked) {
         assert.equal(await page.evaluate(() => localStorage.getItem('color-scheme')), 'dark')
         await cycle.focus()
@@ -49,7 +67,11 @@ export async function checkColorScheme(browser, base) {
       await page.setViewportSize({ width: 763, height: 777 })
       assert(await radio.isVisible())
       assert.equal(await cycle.isVisible(), false)
-      assert.equal(await page.locator('.site-header__search-label').isVisible(), false, 'Search text stays hidden at the intermediate width')
+      assert.equal(
+        await page.locator('.site-header__search-label').isVisible(),
+        false,
+        'Search text stays hidden at the intermediate width',
+      )
       await radio.locator('[data-scheme="light"]').click()
       await page.setViewportSize({ width: 628, height: 777 })
       await check('light', 'Light', 'Dark', 'light')
@@ -58,7 +80,11 @@ export async function checkColorScheme(browser, base) {
       await context.close()
     }
   }
-  const reader = await browser.newContext({ viewport: { width: 1062, height: 789 }, colorScheme: 'light', reducedMotion: 'reduce' })
+  const reader = await browser.newContext({
+    viewport: { width: 1062, height: 789 },
+    colorScheme: 'light',
+    reducedMotion: 'reduce',
+  })
   try {
     const page = await reader.newPage()
     await page.goto(`${base}/tmux/concepts/server-session-window-pane/`)
@@ -70,7 +96,11 @@ export async function checkColorScheme(browser, base) {
     assert(position > 500, 'Exercise the sticky scheme controls while reading down the page')
     const checkPosition = async () => {
       await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))))
-      assert.equal(await page.evaluate(() => scrollY), position, 'Changing colour scheme preserves the reading position')
+      assert.equal(
+        await page.evaluate(() => scrollY),
+        position,
+        'Changing colour scheme preserves the reading position',
+      )
     }
     for (const scheme of ['dark', 'system', 'light']) {
       // Click the visible label: focusing the visually hidden radio directly
@@ -85,7 +115,12 @@ export async function checkColorScheme(browser, base) {
     await page.keyboard.press('ArrowRight')
     await checkPosition()
     assert.equal(await page.locator('html').getAttribute('data-color-scheme'), 'dark')
-    assert(await page.locator('[data-scheme="dark"]').evaluate((element) => parseFloat(getComputedStyle(element).outlineWidth) > 0), 'The radios retain visible keyboard focus')
+    assert(
+      await page
+        .locator('[data-scheme="dark"]')
+        .evaluate((element) => parseFloat(getComputedStyle(element).outlineWidth) > 0),
+      'The radios retain visible keyboard focus',
+    )
     await page.setViewportSize({ width: 596, height: 789 })
     await page.evaluate((top) => window.scrollTo({ top, behavior: 'instant' }), position)
     const compact = await page.locator('[data-scheme-cycle]').boundingBox()
@@ -101,9 +136,14 @@ export async function checkColorScheme(browser, base) {
     const page = await context.newPage()
     await page.goto(`${base}/`)
     assert.equal(await page.locator('[data-scheme-cycle]').isVisible(), false)
-    assert(await page.locator('[data-scheme-switch]').isVisible(), 'The original radio group remains the no-JS fallback')
+    assert(
+      await page.locator('[data-scheme-switch]').isVisible(),
+      'The original radio group remains the no-JS fallback',
+    )
   } finally {
     await context.close()
   }
-  console.log('Colour scheme: compact cycling, keyboard, accessible names, Auto, persistence, blocked storage, resize, reading position and no-JS fallback PASS')
+  console.log(
+    'Colour scheme: compact cycling, keyboard, accessible names, Auto, persistence, blocked storage, resize, reading position and no-JS fallback PASS',
+  )
 }
diff --git a/site/scripts/check-dev-sample.mjs b/site/scripts/check-dev-sample.mjs
index 2c01c92b0..00d4cf66e 100644
--- a/site/scripts/check-dev-sample.mjs
+++ b/site/scripts/check-dev-sample.mjs
@@ -25,7 +25,10 @@ export async function checkDevSample(browser, base) {
         const layout = await page.evaluate(() => {
           const controls = ['.site-header__search', '.scheme-switch, .scheme-cycle', '.site-header__menu-button']
             .map((selector) => [...document.querySelectorAll(selector)].find((node) => node.checkVisibility()))
-            .map((node) => { const { top, height } = node.getBoundingClientRect(); return { top, height } })
+            .map((node) => {
+              const { top, height } = node.getBoundingClientRect()
+              return { top, height }
+            })
           const table = document.querySelector('table')
           const head = [...(table?.tHead?.rows[0]?.cells ?? [])]
           const body = [...(table?.tBodies[0]?.rows[0]?.cells ?? [])]
@@ -35,24 +38,45 @@ export async function checkDevSample(browser, base) {
             headerPicker: Boolean(document.querySelector('.site-header-language [data-page-port-switcher]')),
             controls,
             tableColumns: head.length,
-            columns: head.length === body.length ? head.map((cell, index) =>
-              Math.abs(cell.getBoundingClientRect().x - body[index].getBoundingClientRect().x)) : null,
+            columns:
+              head.length === body.length
+                ? head.map((cell, index) =>
+                    Math.abs(cell.getBoundingClientRect().x - body[index].getBoundingClientRect().x),
+                  )
+                : null,
           }
         })
         const headerLimit = layout.headerPicker && width <= 560 ? 97 : 53
         assert(layout.overflow <= 1 && layout.header <= headerLimit, `${path}/${width}: page and responsive header fit`)
-        assert(layout.controls.every((control) => control.height > 0
-          && Math.abs(control.height - layout.controls[0].height) < .1
-          && Math.abs(control.top - layout.controls[0].top) < .1), `${path}/${width}: visible controls align`)
+        assert(
+          layout.controls.every(
+            (control) =>
+              control.height > 0 &&
+              Math.abs(control.height - layout.controls[0].height) < 0.1 &&
+              Math.abs(control.top - layout.controls[0].top) < 0.1,
+          ),
+          `${path}/${width}: visible controls align`,
+        )
         if (path === 'mcp/tools/') {
-          assert(layout.tableColumns > 1 && layout.columns?.every((delta) => delta <= 1), `${width}: MCP table columns align`)
+          assert(
+            layout.tableColumns > 1 && layout.columns?.every((delta) => delta <= 1),
+            `${width}: MCP table columns align`,
+          )
         }
       }
       if (path.startsWith('tmux/')) {
         assert.match(await page.title(), /\| tmux \| libtmux\.org$/)
         const picker = page.locator('[data-page-port-switcher]')
-        assert.equal(await page.locator('.site-header-language [data-page-port-switcher]').count(), 1, 'Language selection is in the top bar')
-        assert.equal(await page.locator('[data-documentation-context] [data-page-port-switcher]').count(), 0, 'The subbar has no duplicate language picker')
+        assert.equal(
+          await page.locator('.site-header-language [data-page-port-switcher]').count(),
+          1,
+          'Language selection is in the top bar',
+        )
+        assert.equal(
+          await page.locator('[data-documentation-context] [data-page-port-switcher]').count(),
+          0,
+          'The subbar has no duplicate language picker',
+        )
         await picker.locator('summary').click()
         const panel = picker.locator('[data-picker-panel]')
         await panel.waitFor({ state: 'visible' })
@@ -60,22 +84,34 @@ export async function checkDevSample(browser, base) {
         assert(bounds && bounds.x >= 0 && bounds.x + bounds.width <= 391, 'Phone language menu fits the viewport')
         await page.keyboard.press('Escape')
         assert.equal(await picker.getAttribute('open'), null)
-        assert(await picker.locator('summary').evaluate((node) => node === document.activeElement), 'Escape restores focus')
+        assert(
+          await picker.locator('summary').evaluate((node) => node === document.activeElement),
+          'Escape restores focus',
+        )
       }
       if (path === 'api-example-probe/') {
         const declaration = page.locator('dt.gp-sphinx-api-header').first()
         const identity = await declaration.getAttribute('id')
-        assert.equal(await declaration.locator('a.headerlink').getAttribute('href'), `#${identity}`,
-          'A declaration permalink lands on its signature bar')
-        assert.equal(await declaration.locator('.section-anchor-alias').getAttribute('id'), `${identity}.declaration`,
-          'The previous declaration fragment remains available')
+        assert.equal(
+          await declaration.locator('a.headerlink').getAttribute('href'),
+          `#${identity}`,
+          'A declaration permalink lands on its signature bar',
+        )
+        assert.equal(
+          await declaration.locator('.section-anchor-alias').getAttribute('id'),
+          `${identity}.declaration`,
+          'The previous declaration fragment remains available',
+        )
         const equivalents = page.locator('.api-elsewhere a')
         const hrefs = await equivalents.evaluateAll((links) => links.map((link) => link.getAttribute('href')))
         const java = hrefs.find((href) => /\/java\/latest\/reference\/.*capture/.test(href))
         assert(java, 'Pane.capture has its verified Java equivalent')
         const equivalent = await page.request.get(new URL(java, base).href)
         assert(equivalent.ok(), `${java}: equivalent declaration HTTP ${equivalent.status()}`)
-        assert(await page.locator('.gp-sphinx-api-example [data-code]').count() > 0, 'API example has a copyable program')
+        assert(
+          (await page.locator('.gp-sphinx-api-example [data-code]').count()) > 0,
+          'API example has a copyable program',
+        )
       }
     }
     await page.goto(`${base}/?port=rs&prompt=eval-sweep&errors=1&cleanup=0`)
diff --git a/site/scripts/check-dev.mjs b/site/scripts/check-dev.mjs
index 18904c5ee..72975438b 100644
--- a/site/scripts/check-dev.mjs
+++ b/site/scripts/check-dev.mjs
@@ -7,7 +7,13 @@ import { dev } from 'astro'
 import { chromium, firefox, webkit } from 'playwright'
 import { API_MODEL_PORTS, PORTS, productAvailable } from '../src/lib/ports.ts'
 import { checkClipboard, checkCompleteApiExamples } from './check-clipboard.mjs'
-import { checkApiAnchorArrival, checkApiExampleOwnership, checkApiNavigation, checkDocumentationNavigation, checkNavigation } from './check-navigation.mjs'
+import {
+  checkApiAnchorArrival,
+  checkApiExampleOwnership,
+  checkApiNavigation,
+  checkDocumentationNavigation,
+  checkNavigation,
+} from './check-navigation.mjs'
 import { checkReferencePreferences, checkGlobalHeader } from './check-reference-preferences.mjs'
 import { checkHomeLauncher } from './check-home-launcher.mjs'
 import { checkHomeTaskReset } from './check-home-task-reset.mjs'
@@ -20,7 +26,8 @@ const apiAnchorsOnly = process.argv.includes('--api-anchors')
 const apiSignaturesOnly = process.argv.includes('--api-signatures')
 const referenceLayoutOnly = process.argv.includes('--reference-layout')
 const keywordHelpOnly = process.argv.includes('--keyword-help')
-const signaturePorts = apiSignaturesOnly ? API_MODEL_PORTS
+const signaturePorts = apiSignaturesOnly
+  ? API_MODEL_PORTS
   : API_MODEL_PORTS.filter((port) => ['py', 'ts'].includes(port.slug))
 const referencePreferencesOnly = process.argv.includes('--reference-preferences')
 const globalHeaderOnly = process.argv.includes('--global-header')
@@ -32,9 +39,14 @@ const workspacePortCount = PORTS.filter((port) => productAvailable(port, 'worksp
 
 Object.assign(process.env, {
   LIBTMUX_DOCS_SITE: 'https://libtmux.org',
-  LIBTMUX_DOCS_BASE: '/en/', LIBTMUX_DOCS_ROOT: '/en', LIBTMUX_DOCS_PORT_ROOT: '/en',
-  LIBTMUX_DOCS_LOCALES_ROOT: '', LIBTMUX_DOCS_LOCALE: 'en', LIBTMUX_DOCS_PORT: '',
-  LIBTMUX_DOCS_VERSION: 'latest', LIBTMUX_DOCS_PORT_DEFAULTS: '{"py":"stable"}',
+  LIBTMUX_DOCS_BASE: '/en/',
+  LIBTMUX_DOCS_ROOT: '/en',
+  LIBTMUX_DOCS_PORT_ROOT: '/en',
+  LIBTMUX_DOCS_LOCALES_ROOT: '',
+  LIBTMUX_DOCS_LOCALE: 'en',
+  LIBTMUX_DOCS_PORT: '',
+  LIBTMUX_DOCS_VERSION: 'latest',
+  LIBTMUX_DOCS_PORT_DEFAULTS: '{"py":"stable"}',
 })
 // Astro always writes root/.astro, so a separate cacheDir alone cannot isolate it.
 const source = fileURLToPath(new URL('../', import.meta.url))
@@ -47,27 +59,37 @@ process.on('exit', () => rmSync(mirror, { recursive: true, force: true }))
 const root = join(mirror, 'site')
 mkdirSync(root)
 cpSync(join(source, 'src'), join(root, 'src'), { recursive: true })
-writeFileSync(join(root, 'src/pages/sidebar-free-layout.astro'), `---
+writeFileSync(
+  join(root, 'src/pages/sidebar-free-layout.astro'),
+  `---
 import DocsLayout from '../layouts/DocsLayout.astro'
 ---
 <DocsLayout title="Empty table of contents" description="A reading page without section headings." pagePath="sidebar-free-layout">
   <p>This article has no sections, so its content should fill the available column.</p>
 </DocsLayout>
-`)
-for (const file of ['astro.config.ts', 'ec.config.mjs', 'package.json', 'tsconfig.json']) cpSync(join(source, file), join(root, file))
+`,
+)
+for (const file of ['astro.config.ts', 'ec.config.mjs', 'package.json', 'tsconfig.json'])
+  cpSync(join(source, file), join(root, file))
 for (const file of ['public', 'node_modules']) symlinkSync(join(source, file), join(root, file), 'dir')
-for (const file of ['scripts', 'packages', 'node_modules']) symlinkSync(join(source, '..', file), join(mirror, file), 'dir')
+for (const file of ['scripts', 'packages', 'node_modules'])
+  symlinkSync(join(source, '..', file), join(mirror, file), 'dir')
 // Exercise the production reference page in the root server. Its model and
 // owner are the same props its port route supplies, without another Vite boot.
-writeFileSync(join(root, 'src/pages/api-example-probe.astro'), `---
+writeFileSync(
+  join(root, 'src/pages/api-example-probe.astro'),
+  `---
 import Reference from './reference/[...slug].astro'
 import { API_MODELS } from '../lib/api-models'
 const model = API_MODELS.ts
 const owner = model.symbols.find((symbol) => symbol.id === 'pane.Pane.capture')
 ---
 <Reference model={model} owner={owner} />
-`)
-writeFileSync(join(root, 'src/pages/api-signature-probe.astro'), `---
+`,
+)
+writeFileSync(
+  join(root, 'src/pages/api-signature-probe.astro'),
+  `---
 import ApiEntry from '../components/api/ApiEntry.astro'
 import DocsLayout from '../layouts/DocsLayout.astro'
 import { API_MODELS, indexFor } from '../lib/api-models'
@@ -91,11 +113,14 @@ const entries = API_MODEL_PORTS.filter(({ slug }) => ${JSON.stringify(signatureP
     </section>
   ))}
 </DocsLayout>
-`)
+`,
+)
 for (const { slug: port } of PORTS) {
   const directory = join(root, `src/pages/${port}/latest/reference`)
   mkdirSync(directory, { recursive: true })
-  writeFileSync(join(directory, '[...slug].astro'), `---
+  writeFileSync(
+    join(directory, '[...slug].astro'),
+    `---
 import Reference from '../../../reference/[...slug].astro'
 import { API_MODELS } from '../../../../lib/api-models'
 export function getStaticPaths() {
@@ -106,18 +131,25 @@ export function getStaticPaths() {
 const { model, owner } = Astro.props
 ---
 <Reference model={model} owner={owner} />
-`)
-  writeFileSync(join(directory, 'tree.json.ts'), `
+`,
+  )
+  writeFileSync(
+    join(directory, 'tree.json.ts'),
+    `
 import { referenceTree } from '../../../../lib/api-tree'
 export const GET = () => new Response(JSON.stringify(referenceTree('${port}')), {
   headers: { 'Content-Type': 'application/json' },
 })
-`)
-  writeFileSync(join(root, `src/pages/${port}/latest/index.astro`), `---
+`,
+  )
+  writeFileSync(
+    join(root, `src/pages/${port}/latest/index.astro`),
+    `---
 import Home from '../../index.astro'
 ---
 <Home port="${port}" />
-`)
+`,
+  )
 }
 let server, browser
 const terminate = async () => {
@@ -127,9 +159,14 @@ const terminate = async () => {
 }
 process.on('SIGTERM', terminate)
 process.on('SIGINT', terminate)
-const startServer = () => dev({ root, cacheDir: join(mirror, 'cache'),
-  vite: { cacheDir: join(mirror, 'vite') }, logLevel: 'error',
-  server: { host: '127.0.0.1', port: 0 } })
+const startServer = () =>
+  dev({
+    root,
+    cacheDir: join(mirror, 'cache'),
+    vite: { cacheDir: join(mirror, 'vite') },
+    logLevel: 'error',
+    server: { host: '127.0.0.1', port: 0 },
+  })
 server = await startServer()
 const base = `http://127.0.0.1:${server.address.port}/en`
 
@@ -152,8 +189,10 @@ async function checkSignatureLayouts(browser, base) {
   try {
     await page.goto(`${base}/api-signature-probe/`, { waitUntil: 'load' })
     const entries = page.locator('[data-signature-port]')
-    assert.equal(new Set(await entries.evaluateAll((elements) => elements.map((entry) =>
-      entry.dataset.signaturePort))).size, signaturePorts.length)
+    assert.equal(
+      new Set(await entries.evaluateAll((elements) => elements.map((entry) => entry.dataset.signaturePort))).size,
+      signaturePorts.length,
+    )
     for (const width of [1440, 768, 390]) {
       await page.setViewportSize({ width, height: 1000 })
       for (const entry of await entries.all()) {
@@ -162,25 +201,32 @@ async function checkSignatureLayouts(browser, base) {
         const signature = entry.locator('.gp-sphinx-api-signature:visible')
         assert.equal(await signature.count(), 1, `${port}: one visible signature at ${width}px`)
         const clean = (text) => text.replace(/\s+/g, ' ').trim()
-        assert.equal(await entry.locator('.gp-sphinx-api-signature').count(), 1,
-          `${port}: one declaration serves every layout`)
+        assert.equal(
+          await entry.locator('.gp-sphinx-api-signature').count(),
+          1,
+          `${port}: one declaration serves every layout`,
+        )
         for (const fold of await signature.locator('details').all()) {
-          if (await fold.getAttribute('open') === null) {
+          if ((await fold.getAttribute('open')) === null) {
             await fold.locator('summary').focus()
             await page.keyboard.press('Enter')
           }
         }
         const visibleText = clean(await signature.innerText())
         if (await signature.locator('.api-native-signature').count()) {
-          for (const declaration of model.signatures) assert(visibleText.includes(clean(declaration.raw)),
-            `${port}: native declaration survives at ${width}px`)
+          for (const declaration of model.signatures)
+            assert(visibleText.includes(clean(declaration.raw)), `${port}: native declaration survives at ${width}px`)
         } else {
-          assert.deepEqual(await signature.locator('.sig-param > :is(.n, .api-parameter-name)').allTextContents(),
+          assert.deepEqual(
+            await signature.locator('.sig-param > :is(.n, .api-parameter-name)').allTextContents(),
             model.signatures.flatMap((declaration) => declaration.params.map((param) => param.name)),
-            `${port}: all parameters survive at ${width}px`)
-          assert.deepEqual((await signature.locator('.sig-return-typehint').allTextContents()).map(clean),
-            model.signatures.flatMap((declaration) => declaration.returns ? [clean(declaration.returns)] : []),
-            `${port}: all return types survive at ${width}px`)
+            `${port}: all parameters survive at ${width}px`,
+          )
+          assert.deepEqual(
+            (await signature.locator('.sig-return-typehint').allTextContents()).map(clean),
+            model.signatures.flatMap((declaration) => (declaration.returns ? [clean(declaration.returns)] : [])),
+            `${port}: all return types survive at ${width}px`,
+          )
           for (const declaration of model.signatures) {
             for (const param of declaration.params) {
               if (param.default) assert(visibleText.includes(param.default), `${port}: default remains visible`)
@@ -191,13 +237,19 @@ async function checkSignatureLayouts(browser, base) {
             assert(visibleText.includes(model.value), `${port}: attribute value survives`)
           }
         }
-        assert(await signature.evaluate((element) => element.getBoundingClientRect().right <= innerWidth + 1),
-          `${port}: declaration fits at ${width}px`)
+        assert(
+          await signature.evaluate((element) => element.getBoundingClientRect().right <= innerWidth + 1),
+          `${port}: declaration fits at ${width}px`,
+        )
       }
-      assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
-        `API signatures fit at ${width}px`)
+      assert(
+        await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+        `API signatures fit at ${width}px`,
+      )
     }
-    console.log(`API signatures: ${signaturePorts.length} ports retain declarations without JavaScript at 1440/768/390px`)
+    console.log(
+      `API signatures: ${signaturePorts.length} ports retain declarations without JavaScript at 1440/768/390px`,
+    )
     await page.goto(`${base}/fsharp/latest/reference/libtmux-fsharp-server/`, { waitUntil: 'load' })
     const module = page.locator('dt[data-symbol-id="LibTmux.FSharp.Server"]')
     for (const colorScheme of apiSignaturesOnly ? ['light', 'dark'] : ['light']) {
@@ -206,8 +258,10 @@ async function checkSignatureLayouts(browser, base) {
         await page.setViewportSize({ width, height: 900 })
         const code = await module.locator('.gp-sphinx-api-layout-left').boundingBox()
         const toolbar = await module.locator('.gp-sphinx-api-layout-right').boundingBox()
-        assert(Math.abs(code.y + code.height / 2 - toolbar.y - toolbar.height / 2) < 2,
-          `${colorScheme}/${width}px: module declaration and toolbar share a row`)
+        assert(
+          Math.abs(code.y + code.height / 2 - toolbar.y - toolbar.height / 2) < 2,
+          `${colorScheme}/${width}px: module declaration and toolbar share a row`,
+        )
         assert(code.x + code.width <= toolbar.x, `${colorScheme}/${width}px: declaration does not overlap controls`)
         assert((await module.boundingBox()).height < 50, `${colorScheme}/${width}px: short module header stays compact`)
       }
@@ -221,35 +275,60 @@ async function checkSignatureLayouts(browser, base) {
         const keyword = declaration.locator('.api-keyword', { hasText: 'val' })
         const name = declaration.locator('.api-declaration-name')
         assert.equal(await name.innerText(), 'tryFindClient')
-        const colors = await Promise.all([keyword, name, declaration.locator('.api-parameter-name').first()]
-          .map((token) => token.evaluate((element) => getComputedStyle(element).color)))
-        assert.equal(new Set(colors).size, 3, `${colorScheme}/${width}px: keyword, function and parameters are distinct`)
+        const colors = await Promise.all(
+          [keyword, name, declaration.locator('.api-parameter-name').first()].map((token) =>
+            token.evaluate((element) => getComputedStyle(element).color),
+          ),
+        )
+        assert.equal(
+          new Set(colors).size,
+          3,
+          `${colorScheme}/${width}px: keyword, function and parameters are distinct`,
+        )
         for (const arrow of await declaration.locator('.api-operator').all()) {
-          assert.equal(await arrow.evaluate((element) => element.getClientRects().length), 1,
-            `${colorScheme}/${width}px: arrows remain intact`)
+          assert.equal(
+            await arrow.evaluate((element) => element.getClientRects().length),
+            1,
+            `${colorScheme}/${width}px: arrows remain intact`,
+          )
         }
-        assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
-          `${colorScheme}/${width}px: F# signature fits`)
+        assert(
+          await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+          `${colorScheme}/${width}px: F# signature fits`,
+        )
         if (width === 803) {
           const first = await keyword.boundingBox()
           const parameter = await declaration.locator('.api-parameter-name').first().boundingBox()
-          assert(Math.abs(first.y + first.height / 2 - parameter.y - parameter.height / 2) < 2,
-            'F# source indentation does not force an empty signature row')
+          assert(
+            Math.abs(first.y + first.height / 2 - parameter.y - parameter.height / 2) < 2,
+            'F# source indentation does not force an empty signature row',
+          )
         }
       }
     }
-    assert.equal(await page.locator('.gp-sphinx-api-parameters a', { hasText: 'System.ArgumentException' })
-      .getAttribute('href'), 'https://learn.microsoft.com/dotnet/api/system.argumentexception')
+    assert.equal(
+      await page.locator('.gp-sphinx-api-parameters a', { hasText: 'System.ArgumentException' }).getAttribute('href'),
+      'https://learn.microsoft.com/dotnet/api/system.argumentexception',
+    )
     await page.goto(`${base}/kotlin/latest/reference/`, { waitUntil: 'load' })
     const helper = page.locator('.api-index-card[id="io.github.libtmux.kotlin.withServer"]')
     assert.equal(await helper.count(), 1, 'Kotlin withServer has one index card')
-    assert.equal(await page.locator('.api-index-section .gp-sphinx-api-container').count(), 0,
-      'Browse pages link to declarations instead of expanding them inline')
+    assert.equal(
+      await page.locator('.api-index-section .gp-sphinx-api-container').count(),
+      0,
+      'Browse pages link to declarations instead of expanding them inline',
+    )
     await helper.locator('.api-index-card__link').click()
-    assert.match(page.url(), /\/reference\/io-github-libtmux-kotlin-withserver\/$/,
-      'The function card opens its individual reference page')
-    assert.equal(await page.locator('dt[data-symbol-id="io.github.libtmux.kotlin.withServer"]').count(), 1,
-      'The individual page retains the complete declaration')
+    assert.match(
+      page.url(),
+      /\/reference\/io-github-libtmux-kotlin-withserver\/$/,
+      'The function card opens its individual reference page',
+    )
+    assert.equal(
+      await page.locator('dt[data-symbol-id="io.github.libtmux.kotlin.withServer"]').count(),
+      1,
+      'The individual page retains the complete declaration',
+    )
     const kotlin = page.locator('dt[data-symbol-id="io.github.libtmux.kotlin.withServer"]')
     for (const colorScheme of apiSignaturesOnly ? ['light', 'dark'] : ['light']) {
       await page.emulateMedia({ colorScheme })
@@ -258,18 +337,23 @@ async function checkSignatureLayouts(browser, base) {
         const code = await kotlin.locator('.gp-sphinx-api-layout-left').boundingBox()
         const toolbar = await kotlin.locator('.gp-sphinx-api-layout-right').boundingBox()
         if (width === 803 || width === 1920) {
-          assert(Math.abs(code.y - toolbar.y) < 2,
-            `${colorScheme}/${width}px: toolbar shares the declaration's first row when it fits`)
-          assert(code.x + code.width <= toolbar.x,
-            `${colorScheme}/${width}px: declaration leaves room for its toolbar`)
+          assert(
+            Math.abs(code.y - toolbar.y) < 2,
+            `${colorScheme}/${width}px: toolbar shares the declaration's first row when it fits`,
+          )
+          assert(code.x + code.width <= toolbar.x, `${colorScheme}/${width}px: declaration leaves room for its toolbar`)
         }
         if (width <= 390) {
-          assert(toolbar.y >= code.y + code.height,
-            `${colorScheme}/${width}px: toolbar follows the full-width signature`)
+          assert(
+            toolbar.y >= code.y + code.height,
+            `${colorScheme}/${width}px: toolbar follows the full-width signature`,
+          )
         }
         assert(toolbar.height < 30, `${colorScheme}/${width}px: badges and links stay in one compact row`)
-        assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
-          `${colorScheme}/${width}px: declaration and toolbar fit without clipping`)
+        assert(
+          await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+          `${colorScheme}/${width}px: declaration and toolbar fit without clipping`,
+        )
       }
     }
     console.log('Native browse layout: compact F# modules and linked Kotlin function cards work without JavaScript')
@@ -308,21 +392,38 @@ async function checkKeywordHelp(browser, base) {
             const { left, right, width } = document.documentElement.getBoundingClientRect()
             return { left, right, width, height: innerHeight }
           })
-          assert(box.x >= viewport.left && box.y >= 0 && box.x + box.width <= viewport.right + 1 && box.y + box.height <= viewport.height + 1,
-            `${colorScheme}/${width}px/JS=${javaScriptEnabled}: keyword help stays inside the viewport: ${JSON.stringify({ box, viewport })}`)
+          assert(
+            box.x >= viewport.left &&
+              box.y >= 0 &&
+              box.x + box.width <= viewport.right + 1 &&
+              box.y + box.height <= viewport.height + 1,
+            `${colorScheme}/${width}px/JS=${javaScriptEnabled}: keyword help stays inside the viewport: ${JSON.stringify({ box, viewport })}`,
+          )
           if (!javaScriptEnabled) {
-            assert(Math.abs(box.x + box.width / 2 - (viewport.left + viewport.right) / 2) < 1 && Math.abs(box.y + box.height / 2 - viewport.height / 2) < 1,
-              `Native keyword help stays centered without JavaScript: ${JSON.stringify({ box, viewport })}`)
+            assert(
+              Math.abs(box.x + box.width / 2 - (viewport.left + viewport.right) / 2) < 1 &&
+                Math.abs(box.y + box.height / 2 - viewport.height / 2) < 1,
+              `Native keyword help stays centered without JavaScript: ${JSON.stringify({ box, viewport })}`,
+            )
           }
           const after = await declaration.boundingBox()
           assert.equal(after.height, before.height, 'Keyword help does not change the signature height')
           const docs = panel.getByRole('link', { name: 'Language documentation' })
-          assert.equal(await docs.getAttribute('href'), 'https://kotlinlang.org/docs/coroutines-basics.html#suspending-functions')
+          assert.equal(
+            await docs.getAttribute('href'),
+            'https://kotlinlang.org/docs/coroutines-basics.html#suspending-functions',
+          )
           const close = panel.getByRole('button', { name: 'Close preview', exact: true })
           await page.keyboard.press('Tab')
-          assert(await close.evaluate((element) => element === document.activeElement), 'Tab reaches the close control first')
+          assert(
+            await close.evaluate((element) => element === document.activeElement),
+            'Tab reaches the close control first',
+          )
           await page.keyboard.press('Tab')
-          assert(await docs.evaluate((element) => element === document.activeElement), 'Tab reaches the documentation link')
+          assert(
+            await docs.evaluate((element) => element === document.activeElement),
+            'Tab reaches the documentation link',
+          )
           await page.keyboard.press('Escape')
           await panel.waitFor({ state: 'hidden' })
           await page.setViewportSize({ width, height: 360 })
@@ -330,8 +431,10 @@ async function checkKeywordHelp(browser, base) {
           await panel.waitFor({ state: 'visible' })
           if (javaScriptEnabled) await page.evaluate(() => new Promise(requestAnimationFrame))
           const reopened = await panel.boundingBox()
-          assert(reopened.y >= 0 && reopened.y + reopened.height <= 361,
-            'Keyboard reopening after a resize uses the current viewport')
+          assert(
+            reopened.y >= 0 && reopened.y + reopened.height <= 361,
+            'Keyboard reopening after a resize uses the current viewport',
+          )
           await page.keyboard.press('Escape')
           await panel.waitFor({ state: 'hidden' })
           await page.setViewportSize({ width, height: 900 })
@@ -353,8 +456,10 @@ async function checkKeywordHelp(browser, base) {
               await new Promise(requestAnimationFrame)
             })
             const resized = await panel.boundingBox()
-            assert(resized.y >= 0 && resized.y + resized.height <= 361,
-              'Open help remains in view after scrolling its keyword offscreen')
+            assert(
+              resized.y >= 0 && resized.y + resized.height <= 361,
+              'Open help remains in view after scrolling its keyword offscreen',
+            )
             await page.keyboard.press('Escape')
           }
         }
@@ -364,7 +469,9 @@ async function checkKeywordHelp(browser, base) {
       await page.close()
     }
   }
-  console.log('Keyword help: official docs, hover, keyboard, dismissal and viewport bounds pass with and without JavaScript')
+  console.log(
+    'Keyword help: official docs, hover, keyboard, dismissal and viewport bounds pass with and without JavaScript',
+  )
 }
 
 async function checkReferenceAndHeroes(browser, base) {
@@ -375,13 +482,23 @@ async function checkReferenceAndHeroes(browser, base) {
     for (const path of ['ts/latest/workspace/', 'ruby/latest/mcp/', 'cxx/latest/workspace/', 'cxx/latest/mcp/']) {
       await page.goto(`${base}/${path}`, { waitUntil: 'load' })
       const hero = page.locator('.port-hero, .product-hero').first()
-      assert(!(await hero.locator('h1').textContent()).includes('(in development)'), `${path}: development stays in the callout`)
+      assert(
+        !(await hero.locator('h1').textContent()).includes('(in development)'),
+        `${path}: development stays in the callout`,
+      )
       const source = hero.getByRole('link', { name: 'GitHub', exact: true })
       assert.equal(await source.count(), 1, `${path}: source button belongs to the heading`)
       if (path.startsWith('cxx/')) {
         const product = path.includes('/mcp/') ? 'mcp' : 'workspace'
-        assert.equal(await source.getAttribute('href'), `https://github.com/libtmux/libtmux-cxx/tree/master/apps/${product}`)
-        assert.equal(await hero.locator('.port-link').count(), 1, 'C++ source applications do not advertise a registry package')
+        assert.equal(
+          await source.getAttribute('href'),
+          `https://github.com/libtmux/libtmux-cxx/tree/master/apps/${product}`,
+        )
+        assert.equal(
+          await hero.locator('.port-link').count(),
+          1,
+          'C++ source applications do not advertise a registry package',
+        )
       } else {
         assert.equal(await hero.locator('.port-link').count(), 2, `${path}: source and registry buttons`)
       }
@@ -404,20 +521,31 @@ async function checkReferenceAndHeroes(browser, base) {
     await page.goto(`${base}/kotlin/latest/reference/io-github-libtmux-kotlin-server-livestate/`)
     for (const width of [1440, 768, 390]) {
       await page.setViewportSize({ width, height: 900 })
-      assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
-        `Kotlin parameter and exception fields fit at ${width}px`)
+      assert(
+        await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+        `Kotlin parameter and exception fields fit at ${width}px`,
+      )
       const namespace = await page.locator('.api-qualified-namespace').boundingBox()
       const copy = await page.getByRole('button', { name: 'Copy fully qualified name' }).boundingBox()
       const row = await page.locator('.api-qualified-name').boundingBox()
       const title = await page.locator('.api-reference-heading h1').boundingBox()
-      assert(Math.abs(namespace.y + namespace.height / 2 - copy.y - copy.height / 2) < 2,
-        `Package and copy control share a center line at ${width}px`)
-      assert(row.height <= 32 && row.y - title.y - title.height <= 8,
-        `Package stays in one compact row beneath the heading at ${width}px`)
+      assert(
+        Math.abs(namespace.y + namespace.height / 2 - copy.y - copy.height / 2) < 2,
+        `Package and copy control share a center line at ${width}px`,
+      )
+      assert(
+        row.height <= 32 && row.y - title.y - title.height <= 8,
+        `Package stays in one compact row beneath the heading at ${width}px`,
+      )
     }
     for (const name of ['config', 'defaultTimeout', 'toKotlinDuration', 'Duration', 'CoroutineScope', 'StateFlow']) {
-      assert(await page.locator('main a').filter({ hasText: new RegExp(`^${name}$`) }).count() > 0,
-        `Kotlin liveState links ${name}`)
+      assert(
+        (await page
+          .locator('main a')
+          .filter({ hasText: new RegExp(`^${name}$`) })
+          .count()) > 0,
+        `Kotlin liveState links ${name}`,
+      )
     }
     console.log('Native API: Kotlin call-chain links and parameter layout pass at 1440/768/390px')
     const qualified = page.locator('.api-qualified-name')
@@ -425,20 +553,29 @@ async function checkReferenceAndHeroes(browser, base) {
     const namespace = qualified.locator('.api-qualified-namespace')
     assert.equal(await namespace.innerText(), 'io.github.libtmux.kotlin')
     assert.equal(await namespace.getAttribute('title'), 'io.github.libtmux.kotlin')
-    assert.equal(await qualified.locator('[data-api-expand-name]').count(), 0,
-      'Ordinary package names remain fully visible without an expansion control')
+    assert.equal(
+      await qualified.locator('[data-api-expand-name]').count(),
+      0,
+      'Ordinary package names remain fully visible without an expansion control',
+    )
     for (const reject of [false, true]) {
       await page.evaluate((reject) => {
-        Object.defineProperty(navigator, 'clipboard', { configurable: true, value: {
-          writeText: async (text) => {
-            window.__copiedQualifiedName = text
-            if (reject) throw new Error('Clipboard denied')
+        Object.defineProperty(navigator, 'clipboard', {
+          configurable: true,
+          value: {
+            writeText: async (text) => {
+              window.__copiedQualifiedName = text
+              if (reject) throw new Error('Clipboard denied')
+            },
           },
-        } })
+        })
       }, reject)
       await qualified.getByRole('button', { name: 'Copy fully qualified name' }).click()
-      await page.waitForFunction((reject) => document.querySelector('.api-copy-status').textContent
-        .startsWith(reject ? 'Copy failed' : 'Name copied'), reject)
+      await page.waitForFunction(
+        (reject) =>
+          document.querySelector('.api-copy-status').textContent.startsWith(reject ? 'Copy failed' : 'Name copied'),
+        reject,
+      )
       assert.equal(await page.evaluate(() => window.__copiedQualifiedName), fullName)
     }
     const anchors = await page.locator('[id]').evaluateAll((elements) => elements.map((element) => element.id))
@@ -447,56 +584,95 @@ async function checkReferenceAndHeroes(browser, base) {
     await page.setViewportSize({ width: 1440, height: 900 })
     const contents = page.getByRole('navigation', { name: 'On this page', exact: true })
     assert(await contents.isVisible(), 'Wide reference pages show section navigation')
-    assert.deepEqual(await page.locator('[data-api-section-link]').evaluateAll((links) => links
-      .map((link) => decodeURIComponent(link.hash.slice(1)))
-      .filter((id) => [...document.querySelectorAll('[id]')].filter((element) => element.id === id).length !== 1)), [],
-    'Every reference section link has exactly one target')
+    assert.deepEqual(
+      await page
+        .locator('[data-api-section-link]')
+        .evaluateAll((links) =>
+          links
+            .map((link) => decodeURIComponent(link.hash.slice(1)))
+            .filter((id) => [...document.querySelectorAll('[id]')].filter((element) => element.id === id).length !== 1),
+        ),
+      [],
+      'Every reference section link has exactly one target',
+    )
     await contents.getByRole('link', { name: 'Parameters', exact: true }).click()
-    await page.waitForFunction(() => document.querySelector('api-page-contents a[aria-current="location"]')?.textContent === 'Parameters')
+    await page.waitForFunction(
+      () => document.querySelector('api-page-contents a[aria-current="location"]')?.textContent === 'Parameters',
+    )
     await page.goto(`${base}/kotlin/latest/reference/io-github-libtmux-kotlin-server/`)
     const memberNames = await page.locator('.api-member-link').allTextContents()
     assert.deepEqual(memberNames.slice(0, 3), ['sessions', 'windows', 'panes'])
     assert.equal(new Set(memberNames).size, memberNames.length, 'Grouped members appear once')
-    assert(await page.getByRole('navigation', { name: 'Related APIs' }).getByRole('link', { name: 'io.github.libtmux.kotlin.Session', exact: true }).count())
+    assert(
+      await page
+        .getByRole('navigation', { name: 'Related APIs' })
+        .getByRole('link', { name: 'io.github.libtmux.kotlin.Session', exact: true })
+        .count(),
+    )
     for (const width of [1440, 768, 390]) {
       await page.setViewportSize({ width, height: 900 })
       assert.equal(await page.locator('api-page-contents').isVisible(), width >= 1360)
-      assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), `Reference columns fit at ${width}px`)
+      assert(
+        await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+        `Reference columns fit at ${width}px`,
+      )
     }
     console.log('Reference contents: section targets, active links, related declarations and grouped member order pass')
     await page.goto(`${base}/scala/latest/reference/io-github-libtmux-scaladsl-server-windows/`)
     const signature = page.locator('dt.api-native-header').first()
-    const links = await signature.locator('.api-native-signature a').evaluateAll((elements) =>
-      elements.map((element) => ({ name: element.textContent, href: element.getAttribute('href') })))
+    const links = await signature
+      .locator('.api-native-signature a')
+      .evaluateAll((elements) =>
+        elements.map((element) => ({ name: element.textContent, href: element.getAttribute('href') })),
+      )
     for (const name of ['def', 'extension', 'self', 'windows', 'id', 'expression']) {
       assert(!links.some((link) => link.name === name), `${name} is a declaration token, not an API link`)
     }
     for (const name of ['Server', 'Window', 'io.github.libtmux.WindowId']) {
-      assert(links.some((link) => link.name === name), `Scala signature links ${name}`)
+      assert(
+        links.some((link) => link.name === name),
+        `Scala signature links ${name}`,
+      )
     }
-    assert(links.filter((link) => link.name === 'Vector').every((link) =>
-      link.href === 'https://www.scala-lang.org/api/3.x/scala/collection/immutable/Vector.html'),
-    'Scala Vector links to its own collection type')
+    assert(
+      links
+        .filter((link) => link.name === 'Vector')
+        .every((link) => link.href === 'https://www.scala-lang.org/api/3.x/scala/collection/immutable/Vector.html'),
+      'Scala Vector links to its own collection type',
+    )
     for (const width of [1440, 768, 390]) {
       await page.setViewportSize({ width, height: 900 })
       const header = await signature.boundingBox()
-      const code = await signature.locator('.gp-sphinx-api-layout-left:visible, .gp-sphinx-api-layout-bottom:visible').boundingBox()
+      const code = await signature
+        .locator('.gp-sphinx-api-layout-left:visible, .gp-sphinx-api-layout-bottom:visible')
+        .boundingBox()
       assert(code.width >= header.width - 36, `Scala overloads use the signature width at ${width}px`)
-      assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
-        `Scala overloads fit at ${width}px`)
+      assert(
+        await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+        `Scala overloads fit at ${width}px`,
+      )
     }
-    console.log('Scala overloads: only API symbols link, Vector resolves to Scala, and badges leave the full code width')
+    console.log(
+      'Scala overloads: only API symbols link, Vector resolves to Scala, and badges leave the full code width',
+    )
     await page.goto(`${base}/kotlin/latest/reference/io-github-libtmux-kotlin-server-session/`)
     const errors = page.locator('[id="io.github.libtmux.kotlin.Server.session.errors"] + dd')
     assert.match(await errors.innerText(), /NoMatch/)
     assert.match(await errors.innerText(), /MultipleMatches/)
     assert.match(await errors.innerText(), /session\(expression\)/, 'Errors identify the expression overload')
-    const fieldIds = await page.locator('.gp-sphinx-api-parameters [id]').evaluateAll((elements) => elements.map((element) => element.id))
+    const fieldIds = await page
+      .locator('.gp-sphinx-api-parameters [id]')
+      .evaluateAll((elements) => elements.map((element) => element.id))
     assert.equal(fieldIds.length, new Set(fieldIds).size, 'Overload parameters retain unique anchors')
-    assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), 'Overload field labels fit on a phone')
+    assert(
+      await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+      'Overload field labels fit on a phone',
+    )
     await page.goto(`${base}/kotlin/latest/reference/io-github-libtmux-kotlin-options-get/`)
-    assert(await page.locator('[id="io.github.libtmux.kotlin.Options.get.returns"] + dd').innerText(),
-      'The earlier get overload retains its return documentation')
+    assert(
+      await page.locator('[id="io.github.libtmux.kotlin.Options.get.returns"] + dd').innerText(),
+      'The earlier get overload retains its return documentation',
+    )
     console.log('Overload contracts: earlier errors and returns render with their owning calls and unique anchors')
     for (const [slug, qualifiedName] of [
       ['server-server', 'io.github.libtmux.Server'],
@@ -506,22 +682,35 @@ async function checkReferenceAndHeroes(browser, base) {
       await page.goto(`${base}/java/latest/reference/io-github-libtmux-${slug}/`)
       assert.equal(await page.title(), `${qualifiedName} | libtmux-java`)
       assert.equal(await page.locator('.api-qualified-namespace').innerText(), 'io.github.libtmux')
-      assert.equal(await page.locator('[data-api-expand-name]').count(), 0,
-        'Ordinary Java package names remain fully visible without an expansion control')
+      assert.equal(
+        await page.locator('[data-api-expand-name]').count(),
+        0,
+        'Ordinary Java package names remain fully visible without an expansion control',
+      )
       assert.equal(await page.locator('[data-api-copy-name]').getAttribute('data-api-copy-name'), qualifiedName)
       const legacyId = qualifiedName.replace('libtmux.Server', 'libtmux.Server.Server')
-      assert(await page.locator(`[id="${legacyId}"]`).evaluate((element) => element.matches('dt.gp-sphinx-api-header')),
-        'The stable symbol fragment reaches its declaration')
-      assert(await page.locator('.api-qualified-name').textContent().then((text) => text.includes(qualifiedName)),
-        `${qualifiedName}: complete source name remains in accessible HTML`)
+      assert(
+        await page.locator(`[id="${legacyId}"]`).evaluate((element) => element.matches('dt.gp-sphinx-api-header')),
+        'The stable symbol fragment reaches its declaration',
+      )
+      assert(
+        await page
+          .locator('.api-qualified-name')
+          .textContent()
+          .then((text) => text.includes(qualifiedName)),
+        `${qualifiedName}: complete source name remains in accessible HTML`,
+      )
       if (!qualifiedName.endsWith('.sessions')) {
         const declaration = page.locator(`dt[data-symbol-id="${legacyId}"]`)
         assert.equal(await declaration.locator('.section-anchor-alias').getAttribute('id'), `${legacyId}.declaration`)
         for (const width of [1440, 390]) {
           await page.setViewportSize({ width, height: 900 })
           const signature = declaration.locator('.gp-sphinx-api-signature:visible')
-          assert.equal((await signature.locator(':scope > .sig-prename, :scope > .sig-name').allTextContents()).join(''), qualifiedName,
-            `${width}px ${qualifiedName}: visible declaration uses its source-qualified name`)
+          assert.equal(
+            (await signature.locator(':scope > .sig-prename, :scope > .sig-name').allTextContents()).join(''),
+            qualifiedName,
+            `${width}px ${qualifiedName}: visible declaration uses its source-qualified name`,
+          )
         }
       }
     }
@@ -531,23 +720,43 @@ async function checkReferenceAndHeroes(browser, base) {
     for (const width of [1440, 390]) {
       await page.setViewportSize({ width, height: 900 })
       const signature = productDeclaration.locator('.gp-sphinx-api-signature:visible')
-      assert.equal((await signature.locator(':scope > .sig-prename, :scope > .sig-name').allTextContents()).join(''), 'io.github.libtmux.mcp.Main',
-        `${width}px Java product declaration uses its source-qualified name`)
+      assert.equal(
+        (await signature.locator(':scope > .sig-prename, :scope > .sig-name').allTextContents()).join(''),
+        'io.github.libtmux.mcp.Main',
+        `${width}px Java product declaration uses its source-qualified name`,
+      )
     }
     const manifest = await page.request.get(`${base}/docs.json`).then((response) => response.json())
-    const javaReference = manifest.pages.find((entry) => new URL(entry.url).pathname.endsWith('/java/latest/reference/'))
+    const javaReference = manifest.pages.find((entry) =>
+      new URL(entry.url).pathname.endsWith('/java/latest/reference/'),
+    )
     assert.equal(javaReference.title, 'API reference')
-    assert.deepEqual(javaReference.symbols.find((entry) => entry.id === 'io.github.libtmux.Server.Server'), {
-      id: 'io.github.libtmux.Server.Server', name: 'Server', kind: 'class',
-      url: 'https://libtmux.org/en/java/latest/reference/io-github-libtmux-server-server/',
-      qualifiedName: 'io.github.libtmux.Server', namespace: 'io.github.libtmux',
-    }, 'Java manifest records source identity alongside its stable declaration URL')
+    assert.deepEqual(
+      javaReference.symbols.find((entry) => entry.id === 'io.github.libtmux.Server.Server'),
+      {
+        id: 'io.github.libtmux.Server.Server',
+        name: 'Server',
+        kind: 'class',
+        url: 'https://libtmux.org/en/java/latest/reference/io-github-libtmux-server-server/',
+        qualifiedName: 'io.github.libtmux.Server',
+        namespace: 'io.github.libtmux',
+      },
+      'Java manifest records source identity alongside its stable declaration URL',
+    )
     await page.goto(`${base}/kotlin/latest/reference/io-github-libtmux-kotlin-server/`)
-    const javaEquivalent = page.locator('.api-elsewhere a[href$="/java/latest/reference/io-github-libtmux-server-server/"]')
-    assert.equal(await javaEquivalent.locator(':scope > code').textContent(), 'io.github.libtmux.Server',
-      'Equivalent Java API labels use the target source identity while retaining its stable URL')
-    assert.equal(await javaEquivalent.locator(':scope > .api-badge--kind-class[aria-hidden="true"]').textContent(), 'C',
-      'The decorative kind badge remains separate from the exact source name')
+    const javaEquivalent = page.locator(
+      '.api-elsewhere a[href$="/java/latest/reference/io-github-libtmux-server-server/"]',
+    )
+    assert.equal(
+      await javaEquivalent.locator(':scope > code').textContent(),
+      'io.github.libtmux.Server',
+      'Equivalent Java API labels use the target source identity while retaining its stable URL',
+    )
+    assert.equal(
+      await javaEquivalent.locator(':scope > .api-badge--kind-class[aria-hidden="true"]').textContent(),
+      'C',
+      'The decorative kind badge remains separate from the exact source name',
+    )
     console.log('Java names: source package and exact qualified names render without changing declaration anchors')
   } finally {
     await page.close()
@@ -557,10 +766,18 @@ async function checkReferenceAndHeroes(browser, base) {
 try {
   // Compile the first page during setup; navigation assertions measure
   // the running app. The outer loop still budgets this initial compilation.
-  const firstPage = homeLauncherOnly || homeControlsOnly ? '/'
-    : keywordHelpOnly ? '/kotlin/latest/reference/io-github-libtmux-kotlin-withserver/'
-    : documentationNavigationOnly ? '/py/latest/' : apiSignaturesOnly ? '/api-signature-probe/'
-    : apiNavigationOnly ? '/lua/latest/reference/libtmux-server/' : '/tmux/concepts/server-session-window-pane/'
+  const firstPage =
+    homeLauncherOnly || homeControlsOnly
+      ? '/'
+      : keywordHelpOnly
+        ? '/kotlin/latest/reference/io-github-libtmux-kotlin-withserver/'
+        : documentationNavigationOnly
+          ? '/py/latest/'
+          : apiSignaturesOnly
+            ? '/api-signature-probe/'
+            : apiNavigationOnly
+              ? '/lua/latest/reference/libtmux-server/'
+              : '/tmux/concepts/server-session-window-pane/'
   const ready = fetch(`${base}${firstPage}`).then(async (response) => {
     assert(response.ok, `Browser setup: HTTP ${response.status} at ${firstPage}`)
     await response.text()
@@ -605,7 +822,10 @@ try {
     // before starting the next, including the main page walk below.
     let previous = Promise.resolve()
     const schedule = (check) => {
-      const pending = previous.then(check).then(() => null, (error) => error)
+      const pending = previous.then(check).then(
+        () => null,
+        (error) => error,
+      )
       previous = pending
       return pending
     }
@@ -623,9 +843,13 @@ try {
     const clipboard = schedule(() => checkClipboard(clipboardPage, base).finally(() => clipboardPage.close()))
     const navigationPage = await browser.newPage({ reducedMotion: 'reduce' })
     navigationPage.setDefaultTimeout(process.env.CI ? 20000 : 10000)
-    const navigation = schedule(() => retryReload(() => checkNavigation(navigationPage, base)).finally(() => navigationPage.close()))
-    const reference = schedule(() => checkReferenceAndHeroes(browser, base).then(() => checkSignatureLayouts(browser, base))
-      .then(() => retryReload(() => checkKeywordHelp(browser, base)))
+    const navigation = schedule(() =>
+      retryReload(() => checkNavigation(navigationPage, base)).finally(() => navigationPage.close()),
+    )
+    const reference = schedule(() =>
+      checkReferenceAndHeroes(browser, base)
+        .then(() => checkSignatureLayouts(browser, base))
+        .then(() => retryReload(() => checkKeywordHelp(browser, base))),
     )
     const preferences = schedule(() => checkReferencePreferences(browser, base))
     const globalHeader = schedule(() => checkGlobalHeader(browser, base))
@@ -633,160 +857,238 @@ try {
     const documentationNavigation = schedule(() => retryReload(() => checkDocumentationNavigation(browser, base)))
     const apiNavigationPage = await browser.newPage({ reducedMotion: 'reduce' })
     apiNavigationPage.setDefaultTimeout(process.env.CI ? 20000 : 10000)
-    const apiNavigation = schedule(() => retryReload(() => checkApiNavigation(apiNavigationPage, base)).finally(() => apiNavigationPage.close()))
+    const apiNavigation = schedule(() =>
+      retryReload(() => checkApiNavigation(apiNavigationPage, base)).finally(() => apiNavigationPage.close()),
+    )
     const apiAnchors = schedule(() => retryReload(() => checkApiAnchorArrival(browser, base)))
     await apiAnchors
-    const paths = ['tmux/concepts/server-session-window-pane', 'tmux/examples/attach-and-send-keys', 'mcp/tools', 'ts/latest/workspace/reference/builder-applyworkspace',
-      'ts/latest/workspace/internals/guides', 'py/stable/workspace/guides',
-      'ts/latest/mcp/tools', 'csharp/latest/mcp/tools/capture_pane']
-    for (const path of paths) await retryReload(async () => {
-      await page.setViewportSize({ width: 1440, height: 1000 })
-      const response = await page.goto(`${base}/${path}/`, { waitUntil: 'load' })
-      assert(response?.ok(), `${path}: HTTP ${response?.status()}`)
-      await page.evaluate(() => document.fonts.ready)
-      assert.equal(await page.locator('header nav[aria-label="Documentation destinations"]').count(), 0)
-      const switcher = page.locator('[data-page-port-switcher]')
-      const portLinks = switcher.locator('a[data-port]')
-      const hasSwitcher = path !== 'mcp/tools'
-      // Dependency optimization can replace the loaded document during startup.
-      if (hasSwitcher) await switcher.waitFor({ state: 'visible' })
-      assert.equal(await switcher.count(), hasSwitcher ? 1 : 0, `${path}: one page language switcher when available`)
-      const isReference = path.includes('/reference/')
-      if (hasSwitcher) {
-        assert.equal(await page.locator('[data-page-toolbar] nav[aria-label="Breadcrumb"]').count(), 1, `${path}: breadcrumbs above the heading`)
-        const geometry = await page.evaluate(() => {
-          const toolbar = document.querySelector('[data-page-toolbar]').getBoundingClientRect()
-          const breadcrumb = document.querySelector('[data-page-toolbar] nav').getBoundingClientRect()
-          const picker = document.querySelector('[data-page-port-switcher]').getBoundingClientRect()
-          const title = document.querySelector('h1').getBoundingClientRect()
-          const context = document.querySelector('[data-documentation-context]')?.getBoundingClientRect()
-          return { above: toolbar.bottom <= title.top, contextAbove: context ? context.bottom <= breadcrumb.top : picker.top < breadcrumb.bottom && breadcrumb.top < picker.bottom }
-        })
-        assert(geometry.above && geometry.contextAbove, `${path}: context controls precede the breadcrumb and heading`)
-      }
-      const expected = isReference ? '/en/py/stable/workspace/reference/tmuxp-workspace-builder-classicworkspacebuilder-build/' : path.includes('workspace/') ? `/en/${path}/`
-        : path === 'csharp/latest/mcp/tools/capture_pane' ? '/en/py/stable/mcp/tools/capture_pane/' : `/en/py/stable/${path.replace(/^(?:ts\/latest\/|tmux\/)/, '')}/`
-      if (hasSwitcher) {
-        assert.equal(await portLinks.first().getAttribute('href'), expected)
-        assert.equal(await switcher.locator('.tmux-area a').getAttribute('href'), '/en/tmux/')
-      }
-      if (path === 'py/stable/workspace/guides') {
-        // Native PowerShell and Julia articles live at workspace/source-guide,
-        // not this guide index; product availability alone is not a counterpart.
-        const guidePorts = ['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
-        assert.deepEqual((await portLinks.evaluateAll((links) => links.map((link) => link.dataset.port))).sort(),
-          [...guidePorts].sort())
-        assert.equal(await portLinks.count(), guidePorts.length)
-        const unmatched = switcher.locator('.doc-picker-option--unmatched')
-        const unavailablePorts = PORTS.filter((port) => !guidePorts.includes(port.slug))
-        assert.deepEqual((await unmatched.evaluateAll((rows) => rows.map((row) => row.dataset.port))).sort(),
-          unavailablePorts.map((port) => port.slug).sort())
-        assert.equal(await unmatched.count(), PORTS.length - guidePorts.length)
-        for (const port of unavailablePorts) {
-          const row = switcher.locator(`.doc-picker-option--unmatched[data-port="${port.slug}"]`)
-          assert.equal(await row.locator('a[data-port]').count(), 0, `${port.name}: no guide-index equivalent`)
-          assert.equal(await row.getAttribute('aria-disabled'), null, `${port.name}: home exit remains available`)
-          const workspace = productAvailable(port, 'workspace')
-          assert.equal(await row.locator('[data-picker-home]').getAttribute('href'),
-            `/en/${port.slug}/latest/${workspace ? 'workspace/' : ''}`)
-          assert.equal(await row.locator('[data-picker-home]').getAttribute('aria-label'),
-            `Go to ${port.name}${workspace ? ' Workspace Manager' : ''} home`)
+    const paths = [
+      'tmux/concepts/server-session-window-pane',
+      'tmux/examples/attach-and-send-keys',
+      'mcp/tools',
+      'ts/latest/workspace/reference/builder-applyworkspace',
+      'ts/latest/workspace/internals/guides',
+      'py/stable/workspace/guides',
+      'ts/latest/mcp/tools',
+      'csharp/latest/mcp/tools/capture_pane',
+    ]
+    for (const path of paths)
+      await retryReload(async () => {
+        await page.setViewportSize({ width: 1440, height: 1000 })
+        const response = await page.goto(`${base}/${path}/`, { waitUntil: 'load' })
+        assert(response?.ok(), `${path}: HTTP ${response?.status()}`)
+        await page.evaluate(() => document.fonts.ready)
+        assert.equal(await page.locator('header nav[aria-label="Documentation destinations"]').count(), 0)
+        const switcher = page.locator('[data-page-port-switcher]')
+        const portLinks = switcher.locator('a[data-port]')
+        const hasSwitcher = path !== 'mcp/tools'
+        // Dependency optimization can replace the loaded document during startup.
+        if (hasSwitcher) await switcher.waitFor({ state: 'visible' })
+        assert.equal(await switcher.count(), hasSwitcher ? 1 : 0, `${path}: one page language switcher when available`)
+        const isReference = path.includes('/reference/')
+        if (hasSwitcher) {
+          assert.equal(
+            await page.locator('[data-page-toolbar] nav[aria-label="Breadcrumb"]').count(),
+            1,
+            `${path}: breadcrumbs above the heading`,
+          )
+          const geometry = await page.evaluate(() => {
+            const toolbar = document.querySelector('[data-page-toolbar]').getBoundingClientRect()
+            const breadcrumb = document.querySelector('[data-page-toolbar] nav').getBoundingClientRect()
+            const picker = document.querySelector('[data-page-port-switcher]').getBoundingClientRect()
+            const title = document.querySelector('h1').getBoundingClientRect()
+            const context = document.querySelector('[data-documentation-context]')?.getBoundingClientRect()
+            return {
+              above: toolbar.bottom <= title.top,
+              contextAbove: context
+                ? context.bottom <= breadcrumb.top
+                : picker.top < breadcrumb.bottom && breadcrumb.top < picker.bottom,
+            }
+          })
+          assert(
+            geometry.above && geometry.contextAbove,
+            `${path}: context controls precede the breadcrumb and heading`,
+          )
         }
-      }
-      if (path === 'ts/latest/workspace/internals/guides') {
-        const python = switcher.locator('.doc-picker-option--unmatched[data-port="py"]')
-        assert.equal(await python.count(), 1, 'Python internals guide stays unmatched')
-        assert.match(await python.textContent(), /No matching page/)
-        assert.equal(await python.locator('a[data-port]').count(), 0)
-        assert.equal(await python.getAttribute('aria-disabled'), null)
-        assert.equal(await python.locator('[data-picker-home]').getAttribute('href'), '/en/py/stable/workspace/')
-        assert.equal(await python.locator('[data-picker-home]').getAttribute('aria-label'), 'Go to Python Workspace Manager home')
-      }
-      if (path === 'csharp/latest/mcp/tools/capture_pane') {
-        const capturePorts = ['py', 'julia', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
-        assert.deepEqual((await portLinks.evaluateAll((links) => links.map((link) => ({
-          port: link.dataset.port, href: link.getAttribute('href'),
-        })))).sort((a, b) => a.port.localeCompare(b.port)),
-        capturePorts.map((port) => ({
-          port, href: `/en/${port}/${port === 'py' ? 'stable' : 'latest'}/mcp/tools/capture_pane/`,
-        })).sort((a, b) => a.port.localeCompare(b.port)))
-        assert.equal(await switcher.locator('a[aria-current="page"]').getAttribute('href'), `/en/${path}/`)
-      }
-      if (isReference) {
-        assert.equal(
-          await portLinks.count(),
-          workspacePortCount,
-          'Workspace construction has an equivalent in every published workspace product',
-        )
-        const target = await page.request.get(base.replace(/\/en$/, '') + expected)
-        assert(target.ok(), `Equivalent target: HTTP ${target.status()}`)
-      }
-      for (const width of [1600, 1440, 1024, 832, 768, 390]) {
-        await page.setViewportSize({ width, height: 1000 })
-
-        const result = await page.evaluate(() => ({
-          overflow: document.documentElement.scrollWidth - innerWidth,
-          headerHeight: document.querySelector('.site-header__bar').getBoundingClientRect().height,
-          headerPicker: Boolean(document.querySelector('.site-header-language [data-page-port-switcher]')),
-          badgeForeground: getComputedStyle(document.querySelector('.prerelease-notice__badge')).color,
-          schemeLabelWidth: document.querySelector('.scheme-switch__label').getBoundingClientRect().width,
-          headerControls: ['.site-header__search', '.scheme-switch, .scheme-cycle', '.site-header__menu-button'].map((selector) => {
-            const control = [...document.querySelectorAll(selector)].find((node) => node.checkVisibility())
-            const { top, height } = control.getBoundingClientRect()
-            return { top, height }
-          }),
-          redundantHeaderLinks: document.querySelectorAll('.site-header__wide-link').length,
-          columns: [...document.querySelectorAll('table')].flatMap((table) => {
-            const head = [...(table.tHead?.rows[0]?.cells ?? [])]
-            const body = [...(table.tBodies[0]?.rows[0]?.cells ?? [])]
-            return head.length === body.length && [...head, ...body].every((cell) => cell.colSpan === 1)
-              ? head.map((cell, i) => Math.abs(cell.getBoundingClientRect().x - body[i].getBoundingClientRect().x)) : []
-          }),
-        }))
-        assert(result.headerHeight <= (result.headerPicker && width <= 560 ? 97 : 53), `${path} at ${width}px: responsive header fits`)
-        assert.equal(result.redundantHeaderLinks, 0, 'Surface destinations are absent from the header bar')
-        assert(result.headerControls.every((control) => Math.abs(control.height - result.headerControls[0].height) < 0.1
-          && Math.abs(control.top - result.headerControls[0].top) < 0.1), `${path} at ${width}px: header controls align at equal heights`)
-        assert.equal(result.badgeForeground, 'rgb(255, 255, 255)', 'Filled badge uses white foreground')
-        if (width < 1536) assert(result.schemeLabelWidth <= 1, 'Compact color-scheme controls hide their text visually')
-        assert(result.overflow <= 1, `${path} at ${width}px: page overflow ${result.overflow}px`)
-        assert(result.columns.every((delta) => delta <= 1), `${path} at ${width}px: table columns misaligned`)
+        const expected = isReference
+          ? '/en/py/stable/workspace/reference/tmuxp-workspace-builder-classicworkspacebuilder-build/'
+          : path.includes('workspace/')
+            ? `/en/${path}/`
+            : path === 'csharp/latest/mcp/tools/capture_pane'
+              ? '/en/py/stable/mcp/tools/capture_pane/'
+              : `/en/py/stable/${path.replace(/^(?:ts\/latest\/|tmux\/)/, '')}/`
         if (hasSwitcher) {
-          const selector = await switcher.locator('summary').boundingBox()
-          const action = await page.locator('[data-page-actions] > summary').boundingBox()
-          const icon = await page.locator('[data-page-actions] > summary > svg').boundingBox()
-          if (await page.locator('[data-documentation-context]').count() === 0) {
-            assert(Math.abs(action.height - selector.height) < 0.1, `${path}: page controls have equal height at ${width}px`)
-            assert(Math.abs(action.y - selector.y) < 0.1, `${path}: page controls align at ${width}px`)
+          assert.equal(await portLinks.first().getAttribute('href'), expected)
+          assert.equal(await switcher.locator('.tmux-area a').getAttribute('href'), '/en/tmux/')
+        }
+        if (path === 'py/stable/workspace/guides') {
+          // Native PowerShell and Julia articles live at workspace/source-guide,
+          // not this guide index; product availability alone is not a counterpart.
+          const guidePorts = ['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
+          assert.deepEqual(
+            (await portLinks.evaluateAll((links) => links.map((link) => link.dataset.port))).sort(),
+            [...guidePorts].sort(),
+          )
+          assert.equal(await portLinks.count(), guidePorts.length)
+          const unmatched = switcher.locator('.doc-picker-option--unmatched')
+          const unavailablePorts = PORTS.filter((port) => !guidePorts.includes(port.slug))
+          assert.deepEqual(
+            (await unmatched.evaluateAll((rows) => rows.map((row) => row.dataset.port))).sort(),
+            unavailablePorts.map((port) => port.slug).sort(),
+          )
+          assert.equal(await unmatched.count(), PORTS.length - guidePorts.length)
+          for (const port of unavailablePorts) {
+            const row = switcher.locator(`.doc-picker-option--unmatched[data-port="${port.slug}"]`)
+            assert.equal(await row.locator('a[data-port]').count(), 0, `${port.name}: no guide-index equivalent`)
+            assert.equal(await row.getAttribute('aria-disabled'), null, `${port.name}: home exit remains available`)
+            const workspace = productAvailable(port, 'workspace')
+            assert.equal(
+              await row.locator('[data-picker-home]').getAttribute('href'),
+              `/en/${port.slug}/latest/${workspace ? 'workspace/' : ''}`,
+            )
+            assert.equal(
+              await row.locator('[data-picker-home]').getAttribute('aria-label'),
+              `Go to ${port.name}${workspace ? ' Workspace Manager' : ''} home`,
+            )
           }
-          assert(Math.abs(icon.x + icon.width / 2 - action.x - action.width / 2) < 0.1, `${path}: action icon centered horizontally`)
-          assert(Math.abs(icon.y + icon.height / 2 - action.y - action.height / 2) < 0.1, `${path}: action icon centered vertically`)
         }
-      }
+        if (path === 'ts/latest/workspace/internals/guides') {
+          const python = switcher.locator('.doc-picker-option--unmatched[data-port="py"]')
+          assert.equal(await python.count(), 1, 'Python internals guide stays unmatched')
+          assert.match(await python.textContent(), /No matching page/)
+          assert.equal(await python.locator('a[data-port]').count(), 0)
+          assert.equal(await python.getAttribute('aria-disabled'), null)
+          assert.equal(await python.locator('[data-picker-home]').getAttribute('href'), '/en/py/stable/workspace/')
+          assert.equal(
+            await python.locator('[data-picker-home]').getAttribute('aria-label'),
+            'Go to Python Workspace Manager home',
+          )
+        }
+        if (path === 'csharp/latest/mcp/tools/capture_pane') {
+          const capturePorts = ['py', 'julia', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
+          assert.deepEqual(
+            (
+              await portLinks.evaluateAll((links) =>
+                links.map((link) => ({
+                  port: link.dataset.port,
+                  href: link.getAttribute('href'),
+                })),
+              )
+            ).sort((a, b) => a.port.localeCompare(b.port)),
+            capturePorts
+              .map((port) => ({
+                port,
+                href: `/en/${port}/${port === 'py' ? 'stable' : 'latest'}/mcp/tools/capture_pane/`,
+              }))
+              .sort((a, b) => a.port.localeCompare(b.port)),
+          )
+          assert.equal(await switcher.locator('a[aria-current="page"]').getAttribute('href'), `/en/${path}/`)
+        }
+        if (isReference) {
+          assert.equal(
+            await portLinks.count(),
+            workspacePortCount,
+            'Workspace construction has an equivalent in every published workspace product',
+          )
+          const target = await page.request.get(base.replace(/\/en$/, '') + expected)
+          assert(target.ok(), `Equivalent target: HTTP ${target.status()}`)
+        }
+        for (const width of [1600, 1440, 1024, 832, 768, 390]) {
+          await page.setViewportSize({ width, height: 1000 })
 
-      if (hasSwitcher) {
-        assert.equal(await switcher.count(), 1, `${path}: one page port switcher`)
-        await switcher.locator('summary').click()
-        await switcher.locator('[data-picker-panel]').waitFor({ state: 'visible' })
-        const menu = await switcher.locator('[data-picker-panel]').boundingBox()
-        assert(menu && menu.x >= 0 && menu.x + menu.width <= 390, `${path}: dropdown leaves phone viewport`)
-      }
-    }, page)
+          const result = await page.evaluate(() => ({
+            overflow: document.documentElement.scrollWidth - innerWidth,
+            headerHeight: document.querySelector('.site-header__bar').getBoundingClientRect().height,
+            headerPicker: Boolean(document.querySelector('.site-header-language [data-page-port-switcher]')),
+            badgeForeground: getComputedStyle(document.querySelector('.prerelease-notice__badge')).color,
+            schemeLabelWidth: document.querySelector('.scheme-switch__label').getBoundingClientRect().width,
+            headerControls: ['.site-header__search', '.scheme-switch, .scheme-cycle', '.site-header__menu-button'].map(
+              (selector) => {
+                const control = [...document.querySelectorAll(selector)].find((node) => node.checkVisibility())
+                const { top, height } = control.getBoundingClientRect()
+                return { top, height }
+              },
+            ),
+            redundantHeaderLinks: document.querySelectorAll('.site-header__wide-link').length,
+            columns: [...document.querySelectorAll('table')].flatMap((table) => {
+              const head = [...(table.tHead?.rows[0]?.cells ?? [])]
+              const body = [...(table.tBodies[0]?.rows[0]?.cells ?? [])]
+              return head.length === body.length && [...head, ...body].every((cell) => cell.colSpan === 1)
+                ? head.map((cell, i) => Math.abs(cell.getBoundingClientRect().x - body[i].getBoundingClientRect().x))
+                : []
+            }),
+          }))
+          assert(
+            result.headerHeight <= (result.headerPicker && width <= 560 ? 97 : 53),
+            `${path} at ${width}px: responsive header fits`,
+          )
+          assert.equal(result.redundantHeaderLinks, 0, 'Surface destinations are absent from the header bar')
+          assert(
+            result.headerControls.every(
+              (control) =>
+                Math.abs(control.height - result.headerControls[0].height) < 0.1 &&
+                Math.abs(control.top - result.headerControls[0].top) < 0.1,
+            ),
+            `${path} at ${width}px: header controls align at equal heights`,
+          )
+          assert.equal(result.badgeForeground, 'rgb(255, 255, 255)', 'Filled badge uses white foreground')
+          if (width < 1536)
+            assert(result.schemeLabelWidth <= 1, 'Compact color-scheme controls hide their text visually')
+          assert(result.overflow <= 1, `${path} at ${width}px: page overflow ${result.overflow}px`)
+          assert(
+            result.columns.every((delta) => delta <= 1),
+            `${path} at ${width}px: table columns misaligned`,
+          )
+          if (hasSwitcher) {
+            const selector = await switcher.locator('summary').boundingBox()
+            const action = await page.locator('[data-page-actions] > summary').boundingBox()
+            const icon = await page.locator('[data-page-actions] > summary > svg').boundingBox()
+            if ((await page.locator('[data-documentation-context]').count()) === 0) {
+              assert(
+                Math.abs(action.height - selector.height) < 0.1,
+                `${path}: page controls have equal height at ${width}px`,
+              )
+              assert(Math.abs(action.y - selector.y) < 0.1, `${path}: page controls align at ${width}px`)
+            }
+            assert(
+              Math.abs(icon.x + icon.width / 2 - action.x - action.width / 2) < 0.1,
+              `${path}: action icon centered horizontally`,
+            )
+            assert(
+              Math.abs(icon.y + icon.height / 2 - action.y - action.height / 2) < 0.1,
+              `${path}: action icon centered vertically`,
+            )
+          }
+        }
+
+        if (hasSwitcher) {
+          assert.equal(await switcher.count(), 1, `${path}: one page port switcher`)
+          await switcher.locator('summary').click()
+          await switcher.locator('[data-picker-panel]').waitFor({ state: 'visible' })
+          const menu = await switcher.locator('[data-picker-panel]').boundingBox()
+          assert(menu && menu.x >= 0 && menu.x + menu.width <= 390, `${path}: dropdown leaves phone viewport`)
+        }
+      }, page)
     for (const path of [
       'py/latest/reference/libtmux-server',
       'py/stable/workspace/reference/tmuxp-workspace-builder-classicworkspacebuilder',
       'java/latest/workspace/reference/io-github-libtmux-workspace-workspacebuilder-workspacebuilder',
-    ]) await retryReload(async () => {
-      const response = await page.goto(`${base}/${path}/`, { waitUntil: 'load' })
-      assert(response?.ok(), `${path}: HTTP ${response?.status()}`)
-      await page.evaluate(() => document.fonts.ready)
-      await page.locator('.api-elsewhere').evaluateAll((entries) => entries.forEach((entry) => { entry.open = true }))
-      for (const width of [1440, 768, 390]) {
-        await page.setViewportSize({ width, height: 1000 })
-        const overflow = await page.evaluate(() => document.documentElement.scrollWidth - innerWidth)
-        assert(overflow <= 1, `${path} at ${width}px: declaration page overflow ${overflow}px`)
-      }
-    })
+    ])
+      await retryReload(async () => {
+        const response = await page.goto(`${base}/${path}/`, { waitUntil: 'load' })
+        assert(response?.ok(), `${path}: HTTP ${response?.status()}`)
+        await page.evaluate(() => document.fonts.ready)
+        await page.locator('.api-elsewhere').evaluateAll((entries) =>
+          entries.forEach((entry) => {
+            entry.open = true
+          }),
+        )
+        for (const width of [1440, 768, 390]) {
+          await page.setViewportSize({ width, height: 1000 })
+          const overflow = await page.evaluate(() => document.documentElement.scrollWidth - innerWidth)
+          assert(overflow <= 1, `${path} at ${width}px: declaration page overflow ${overflow}px`)
+        }
+      })
     for (const width of [1440, 1920]) {
       await page.setViewportSize({ width, height: 1000 })
       await page.goto(`${base}/sidebar-free-layout/`, { waitUntil: 'load' })
@@ -799,16 +1101,22 @@ try {
           toc: document.querySelector('starlight-toc') !== null,
         }
       })
-      assert(reading.unused < 1 && !reading.rightSidebar && !reading.toc,
-        `Empty table of contents at ${width}px must leave no unused article column: ${JSON.stringify(reading)}`)
+      assert(
+        reading.unused < 1 && !reading.rightSidebar && !reading.toc,
+        `Empty table of contents at ${width}px must leave no unused article column: ${JSON.stringify(reading)}`,
+      )
       await page.goto(`${base}/reference/`, { waitUntil: 'load' })
       const reference = await page.evaluate(() => {
         const main = document.querySelector('main')
-        return { children: main.children.length,
-          unused: main.getBoundingClientRect().width - main.lastElementChild.getBoundingClientRect().width }
+        return {
+          children: main.children.length,
+          unused: main.getBoundingClientRect().width - main.lastElementChild.getBoundingClientRect().width,
+        }
       })
-      assert(reference.children === 1 && reference.unused < 1,
-        `Reference index at ${width}px must not reserve an empty navigation column: ${JSON.stringify(reference)}`)
+      assert(
+        reference.children === 1 && reference.unused < 1,
+        `Reference index at ${width}px must not reserve an empty navigation column: ${JSON.stringify(reference)}`,
+      )
     }
     console.log('Empty sidebars: article and reference index use their available width')
     await page.goto(`${base}/`, { waitUntil: 'load' })
@@ -820,14 +1128,17 @@ try {
       context.fillRect(0, 0, 1, 1)
       return [...context.getImageData(0, 0, 1, 1).data]
     })
-    assert(chipPixel[2] > chipPixel[1] && chipPixel[1] > chipPixel[0],
-      `Python dark chip must retain its blue-gray hue: ${chipPixel}`)
-    const darkSurface = () => page.evaluate(() => ({
-      background: getComputedStyle(document.body).backgroundColor,
-      foreground: getComputedStyle(document.body).color,
-      navigation: getComputedStyle(document.querySelector('.topnav-chip:not([aria-current])')).color,
-      notice: getComputedStyle(document.querySelector('.prerelease-notice')).backgroundColor,
-    }))
+    assert(
+      chipPixel[2] > chipPixel[1] && chipPixel[1] > chipPixel[0],
+      `Python dark chip must retain its blue-gray hue: ${chipPixel}`,
+    )
+    const darkSurface = () =>
+      page.evaluate(() => ({
+        background: getComputedStyle(document.body).backgroundColor,
+        foreground: getComputedStyle(document.body).color,
+        navigation: getComputedStyle(document.querySelector('.topnav-chip:not([aria-current])')).color,
+        notice: getComputedStyle(document.querySelector('.prerelease-notice')).backgroundColor,
+      }))
     const pythonSurface = await darkSurface()
     await page.goto(`${base}/cxx/latest/mcp/`, { waitUntil: 'load' })
     assert.deepEqual(await darkSurface(), pythonSurface, 'C++ keeps the shared neutral dark surfaces')
@@ -840,7 +1151,8 @@ try {
           const tokens = getComputedStyle(document.documentElement)
           const style = (selector) => getComputedStyle(document.querySelector(selector))
           return {
-            text: style('.prose > p').color, heading: style('.prose h1').color,
+            text: style('.prose > p').color,
+            heading: style('.prose h1').color,
             muted: tokens.getPropertyValue('--color-foreground-muted').trim(),
             background: style('body').backgroundColor,
             surface: tokens.getPropertyValue('--color-background-secondary').trim(),
@@ -861,21 +1173,35 @@ try {
       const toolbar = await page.evaluate(() => {
         delete document.documentElement.dataset.themeMode
         const style = (selector) => getComputedStyle(document.querySelector(selector))
-        return { background: style('.mobile-toolbar').backgroundColor, page: style('body').backgroundColor,
-          icon: style('.toolbar-button').color, text: style('body').color }
+        return {
+          background: style('.mobile-toolbar').backgroundColor,
+          page: style('body').backgroundColor,
+          icon: style('.toolbar-button').color,
+          text: style('body').color,
+        }
       })
-      assert.equal(toolbar.background, toolbar.page, `${colorScheme}: toolbar uses the page surface before theme initialization`)
+      assert.equal(
+        toolbar.background,
+        toolbar.page,
+        `${colorScheme}: toolbar uses the page surface before theme initialization`,
+      )
       assert.equal(toolbar.icon, toolbar.text, `${colorScheme}: toolbar icons use the page text color`)
-      const context = await browser.newContext({ javaScriptEnabled: false, colorScheme, viewport: { width: 390, height: 844 } })
+      const context = await browser.newContext({
+        javaScriptEnabled: false,
+        colorScheme,
+        viewport: { width: 390, height: 844 },
+      })
       const noScript = await context.newPage()
       await noScript.goto(`${base}/tmux/concepts/server-session-window-pane/`, { waitUntil: 'load' })
       const checkContrast = async (scheme, selectors = ['h1', '.prose h2', '.prose p']) => {
         const samples = await noScript.evaluate((selectors) => {
           const context = document.createElement('canvas').getContext('2d')
           const luminance = () => {
-            const channels = [...context.getImageData(0, 0, 1, 1).data].slice(0, 3)
-              .map((v) => v / 255).map((v) => v <= .04045 ? v / 12.92 : ((v + .055) / 1.055) ** 2.4)
-            return channels[0] * .2126 + channels[1] * .7152 + channels[2] * .0722
+            const channels = [...context.getImageData(0, 0, 1, 1).data]
+              .slice(0, 3)
+              .map((v) => v / 255)
+              .map((v) => (v <= 0.04045 ? v / 12.92 : ((v + 0.055) / 1.055) ** 2.4))
+            return channels[0] * 0.2126 + channels[1] * 0.7152 + channels[2] * 0.0722
           }
           return selectors.map((selector) => {
             const element = document.querySelector(selector)
@@ -894,7 +1220,11 @@ try {
             context.fillStyle = getComputedStyle(element).color
             context.fillRect(0, 0, 1, 1)
             const values = [luminance(), background].sort((a, b) => b - a)
-            return { selector, contrast: (values[0] + .05) / (values[1] + .05), opacity: getComputedStyle(element).opacity }
+            return {
+              selector,
+              contrast: (values[0] + 0.05) / (values[1] + 0.05),
+              opacity: getComputedStyle(element).opacity,
+            }
           })
         }, selectors)
         for (const sample of samples) {
@@ -903,14 +1233,22 @@ try {
         }
       }
       await checkContrast(colorScheme)
-      assert.equal(await noScript.locator('.documentation-context-navigation').isVisible(), false, 'No-JS hides inactive context drawer buttons')
+      assert.equal(
+        await noScript.locator('.documentation-context-navigation').isVisible(),
+        false,
+        'No-JS hides inactive context drawer buttons',
+      )
       assert.equal(await noScript.locator('.mobile-fallback').isVisible(), true, 'No-JS has usable mobile navigation')
-      await checkContrast(colorScheme, ['.mobile-fallback summary', '.documentation-context .surface-current strong', '.site-header-language [data-page-port-switcher] > summary'])
+      await checkContrast(colorScheme, [
+        '.mobile-fallback summary',
+        '.documentation-context .surface-current strong',
+        '.site-header-language [data-page-port-switcher] > summary',
+      ])
       const browse = noScript.locator('.mobile-fallback > details').first()
       await browse.locator('summary').first().focus()
       await noScript.keyboard.press('Enter')
       assert.equal(await browse.getAttribute('open'), '', 'Keyboard opens the native navigation disclosure')
-      assert.equal(await browse.locator('a:visible').count() > 0, true, 'The navigation disclosure exposes links')
+      assert.equal((await browse.locator('a:visible').count()) > 0, true, 'The navigation disclosure exposes links')
       await browse.locator('summary').first().click()
       const contents = noScript.locator('.mobile-fallback > details').nth(1)
       await contents.locator('summary').click()
@@ -918,18 +1256,32 @@ try {
       await contents.locator('a').first().click()
       assert.equal(new URL(noScript.url()).hash, destination, 'No-JS contents reaches its section')
       const override = colorScheme === 'dark' ? 'light' : 'dark'
-      await noScript.evaluate((mode) => { document.documentElement.dataset.themeMode = mode }, override)
+      await noScript.evaluate((mode) => {
+        document.documentElement.dataset.themeMode = mode
+      }, override)
       await checkContrast(`${colorScheme} with ${override} override`)
       await noScript.goto(`${base}/scala/latest/reference/io-github-libtmux-scaladsl-server-windows/`)
       await checkContrast(colorScheme, ['.api-native-signature .api-type-label', '.api-native-signature .api-punct'])
       await context.close()
     }
-    console.log('Fresh Astro + browser: prose, workspace, MCP tools, API equivalents, 390–1600px header and dark hue PASS')
+    console.log(
+      'Fresh Astro + browser: prose, workspace, MCP tools, API equivalents, 390–1600px header and dark hue PASS',
+    )
     await page.close()
-    const failures = (await Promise.all([
-      navigation, apiExamples, reference, preferences, globalHeader, apiNavigation,
-      clipboard, documentationNavigation, homeLauncher, apiAnchors,
-    ])).filter(Boolean)
+    const failures = (
+      await Promise.all([
+        navigation,
+        apiExamples,
+        reference,
+        preferences,
+        globalHeader,
+        apiNavigation,
+        clipboard,
+        documentationNavigation,
+        homeLauncher,
+        apiAnchors,
+      ])
+    ).filter(Boolean)
     if (failures.length) throw new AggregateError(failures, 'Browser checks failed')
   }
 } finally {
diff --git a/site/scripts/check-fonts.mjs b/site/scripts/check-fonts.mjs
index e33074361..d710ea716 100755
--- a/site/scripts/check-fonts.mjs
+++ b/site/scripts/check-fonts.mjs
@@ -163,7 +163,9 @@ try {
   // as it failing. A fresh checkout and a CI job without `serve.sh` both land
   // here, and reporting eight "no response" failures would train a reader to
   // ignore this command's output.
-  const reachable = await fetch(BASE, { method: 'HEAD' }).then((r) => r.ok).catch(() => false)
+  const reachable = await fetch(BASE, { method: 'HEAD' })
+    .then((r) => r.ok)
+    .catch(() => false)
   if (!reachable) throw new Error(`nothing serving at ${BASE}`)
   const { chromium } = await import('playwright')
   const browser = await chromium.launch()
@@ -219,8 +221,8 @@ function collect() {
       })
     }
   }
-  const preloaded = [...document.querySelectorAll('link[rel="preload"][as="font"]')].map((l) =>
-    new URL(l.getAttribute('href'), location.href).pathname,
+  const preloaded = [...document.querySelectorAll('link[rel="preload"][as="font"]')].map(
+    (l) => new URL(l.getAttribute('href'), location.href).pathname,
   )
   // What the preload actually cost, from the network rather than from disk:
   // a preloaded face is fetched at the highest priority the browser has, so
@@ -270,7 +272,12 @@ if (usage) {
       }
     }
     // Per page: a face opened with but not preloaded is text `block` hides.
-    const pre = new Set(page.preloaded.map((p) => byUrl.get(p)).filter(Boolean).map(label))
+    const pre = new Set(
+      page.preloaded
+        .map((p) => byUrl.get(p))
+        .filter(Boolean)
+        .map(label),
+    )
     const late = page.used
       .filter((u) => FAMILIES.some((f) => u.family.startsWith(f)))
       .map(label)
@@ -286,7 +293,9 @@ if (usage) {
   // A preload entry with no page beside it has no reason to be on the list.
   notes.push('preload cost per archetype:')
   for (const page of usage)
-    notes.push(`  ${page.name.padEnd(20)} ${String(page.preloaded.length).padStart(2)} faces  ${(page.bytes / 1024).toFixed(0).padStart(4)} KB`)
+    notes.push(
+      `  ${page.name.padEnd(20)} ${String(page.preloaded.length).padStart(2)} faces  ${(page.bytes / 1024).toFixed(0).padStart(4)} KB`,
+    )
   notes.push('faces opened with, and by which archetype:')
   for (const [face, pages] of [...needed].sort())
     if (pages.length) notes.push(`  ${face.padEnd(28)} ${[...new Set(pages)].join(', ')}`)
diff --git a/site/scripts/check-home-example-options.mjs b/site/scripts/check-home-example-options.mjs
index 732f438c0..ff70350a4 100644
--- a/site/scripts/check-home-example-options.mjs
+++ b/site/scripts/check-home-example-options.mjs
@@ -7,10 +7,16 @@ export async function checkHomeExampleOptions(browser, base) {
     const context = await browser.newContext({ viewport: { width: 944, height: 777 }, reducedMotion: 'reduce' })
     try {
       if (blocked) {
-        await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) => route.fulfill({ contentType: 'application/javascript', body: 'export {}' }))
-        await context.addInitScript(() => Object.defineProperty(window, 'localStorage', {
-          get() { throw new DOMException('Storage blocked', 'SecurityError') },
-        }))
+        await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) =>
+          route.fulfill({ contentType: 'application/javascript', body: 'export {}' }),
+        )
+        await context.addInitScript(() =>
+          Object.defineProperty(window, 'localStorage', {
+            get() {
+              throw new DOMException('Storage blocked', 'SecurityError')
+            },
+          }),
+        )
       }
       const page = await context.newPage()
       const runtimeErrors = []
@@ -19,12 +25,18 @@ export async function checkHomeExampleOptions(browser, base) {
       const errors = active.locator('[data-example-errors]')
       const cleanup = active.locator('[data-example-cleanup]')
       const check = async (handling, cleaning) => {
-        const actual = await page.locator('[data-home-example]').evaluateAll((examples) => examples.map((example) => ({
-          handling: example.querySelector('[data-example-errors]').checked,
-          cleaning: example.querySelector('[data-example-cleanup]').checked,
-        })))
-        assert.deepEqual(actual, PORTS.map(() => ({ handling, cleaning })), 'Every language shares both choices')
-        const view = handling ? (cleaning ? 'full' : 'errors') : (cleaning ? 'cleanup' : 'concise')
+        const actual = await page.locator('[data-home-example]').evaluateAll((examples) =>
+          examples.map((example) => ({
+            handling: example.querySelector('[data-example-errors]').checked,
+            cleaning: example.querySelector('[data-example-cleanup]').checked,
+          })),
+        )
+        assert.deepEqual(
+          actual,
+          PORTS.map(() => ({ handling, cleaning })),
+          'Every language shares both choices',
+        )
+        const view = handling ? (cleaning ? 'full' : 'errors') : cleaning ? 'cleanup' : 'concise'
         assert.equal(await active.locator('[data-home-view]:visible').getAttribute('data-home-view'), view)
       }
       await page.goto(`${base}/?port=rs&prompt=eval-sweep&from=a&from=b#program`)
@@ -56,7 +68,11 @@ export async function checkHomeExampleOptions(browser, base) {
         await page.goto(`${base}/?port=py`)
         await page.waitForSelector('[data-task-enhanced]:not([hidden])')
         await check(true, true)
-        assert.equal(new URL(page.url()).searchParams.get('errors'), '1', 'Stored choices are reflected in shareable URLs')
+        assert.equal(
+          new URL(page.url()).searchParams.get('errors'),
+          '1',
+          'Stored choices are reflected in shareable URLs',
+        )
       }
       await page.goto(`${base}/?port=rs&errors=0&cleanup=0`)
       await page.waitForSelector('[data-task-enhanced]:not([hidden])')
@@ -68,10 +84,14 @@ export async function checkHomeExampleOptions(browser, base) {
       await cleanup.uncheck()
       assert.equal(new URL(page.url()).searchParams.has('errors'), false)
       assert.equal(new URL(page.url()).searchParams.has('cleanup'), false)
-      if (!blocked) assert.deepEqual(await page.evaluate(() => [
-        localStorage.getItem('libtmux-docs.home-example.errors'),
-        localStorage.getItem('libtmux-docs.home-example.cleanup'),
-      ]), [null, null])
+      if (!blocked)
+        assert.deepEqual(
+          await page.evaluate(() => [
+            localStorage.getItem('libtmux-docs.home-example.errors'),
+            localStorage.getItem('libtmux-docs.home-example.cleanup'),
+          ]),
+          [null, null],
+        )
       await page.reload()
       await page.waitForSelector('[data-task-enhanced]:not([hidden])')
       await check(false, false)
@@ -79,16 +99,22 @@ export async function checkHomeExampleOptions(browser, base) {
       const transition = async (navigate) => {
         await page.evaluate(() => {
           window.__homeOptionsPageLoaded = false
-          document.addEventListener('astro:page-load', () => {
-            window.__homeOptionsPageLoaded = true
-          }, { once: true })
+          document.addEventListener(
+            'astro:page-load',
+            () => {
+              window.__homeOptionsPageLoaded = true
+            },
+            { once: true },
+          )
         })
         await navigate()
         await page.waitForFunction(() => window.__homeOptionsPageLoaded)
       }
       await page.goto(`${base}/?port=rs&errors=1&cleanup=0#first`)
       await page.waitForSelector('[data-task-enhanced]:not([hidden])')
-      await page.evaluate(() => { location.hash = 'second' })
+      await page.evaluate(() => {
+        location.hash = 'second'
+      })
       await errors.uncheck()
       await cleanup.check()
       await check(false, true)
@@ -119,5 +145,7 @@ export async function checkHomeExampleOptions(browser, base) {
       await context.close()
     }
   }
-  console.log('Example options: shared across 13 ports, independent defaults, URL/storage/reload/history, explicit zero, uncheck removal, task and URL preservation, blocked storage PASS')
+  console.log(
+    'Example options: shared across 13 ports, independent defaults, URL/storage/reload/history, explicit zero, uncheck removal, task and URL preservation, blocked storage PASS',
+  )
 }
diff --git a/site/scripts/check-home-hover.mjs b/site/scripts/check-home-hover.mjs
index 7cebbf22b..96589b0d1 100644
--- a/site/scripts/check-home-hover.mjs
+++ b/site/scripts/check-home-hover.mjs
@@ -3,19 +3,24 @@ import { PORTS } from '../src/lib/ports.ts'
 
 /** Real pointer events, with the clock advanced instead of sleeping per option. */
 export async function checkHomeHover(browser, base) {
-  const context = await browser.newContext({ viewport: { width: 914, height: 777 }, colorScheme: 'light', reducedMotion: 'no-preference' })
+  const context = await browser.newContext({
+    viewport: { width: 914, height: 777 },
+    colorScheme: 'light',
+    reducedMotion: 'no-preference',
+  })
   const page = await context.newPage()
   const errors = []
   page.on('pageerror', (error) => errors.push(error.message))
-  const read = () => page.evaluate(() => ({
-    port: document.documentElement.dataset.homeSelectedPort ?? null,
-    savedPort: localStorage.getItem('libtmux-docs.package-install.port'),
-    promptPort: document.querySelector('.lm-agent-prompt')?.dataset.activePort,
-    scheme: document.documentElement.dataset.colorScheme,
-    mode: document.documentElement.dataset.themeMode,
-    savedScheme: localStorage.getItem('color-scheme'),
-    checked: document.querySelector('[data-scheme-switch] input:checked')?.value,
-  }))
+  const read = () =>
+    page.evaluate(() => ({
+      port: document.documentElement.dataset.homeSelectedPort ?? null,
+      savedPort: localStorage.getItem('libtmux-docs.package-install.port'),
+      promptPort: document.querySelector('.lm-agent-prompt')?.dataset.activePort,
+      scheme: document.documentElement.dataset.colorScheme,
+      mode: document.documentElement.dataset.themeMode,
+      savedScheme: localStorage.getItem('color-scheme'),
+      checked: document.querySelector('[data-scheme-switch] input:checked')?.value,
+    }))
   const language = page.locator('[data-home-launcher] [data-page-port-switcher]')
   const scheme = (value) => page.locator(`[data-scheme-switch] [data-scheme="${value}"]`)
   const leave = () => page.mouse.move(5, 400)
@@ -37,10 +42,17 @@ export async function checkHomeHover(browser, base) {
       assert.equal(state.promptPort, slug, 'The current prompt follows the preview')
       assert.equal(state.savedPort, 'py', 'Hover does not save a language')
       assert.equal(page.url(), url, 'Hover does not change any URL state')
-      assert.equal(await language.locator('[aria-current]').getAttribute('data-port'), 'py', 'Only the committed menu option is checked')
+      assert.equal(
+        await language.locator('[aria-current]').getAttribute('data-port'),
+        'py',
+        'Only the committed menu option is checked',
+      )
       assert(await page.locator(`.home-examples > [data-home-language="${slug}"]`).isVisible())
       assert.equal(await page.locator('.lm-agent-prompt [data-select="topic"]').inputValue(), 'session-switcher')
-      assert.match(await page.locator(`.lm-agent-prompt__panel[data-port="${slug}"] [data-prompt-text]`).innerText(), /Then build a tmux session switcher/)
+      assert.match(
+        await page.locator(`.lm-agent-prompt__panel[data-port="${slug}"] [data-prompt-text]`).innerText(),
+        /Then build a tmux session switcher/,
+      )
       await leave()
       assert.equal((await read()).port, 'py', 'Leaving restores the committed language')
     }
@@ -77,7 +89,10 @@ export async function checkHomeHover(browser, base) {
       assert.equal(during.savedScheme, before.savedScheme)
       assert.equal(during.scheme, before.scheme)
       assert.equal(during.checked, before.checked, 'A preview does not select a radio')
-      assert.equal(await page.locator('body').evaluate((el) => getComputedStyle(el).transitionDuration), '0.18s, 0.18s, 0.18s')
+      assert.equal(
+        await page.locator('body').evaluate((el) => getComputedStyle(el).transitionDuration),
+        '0.18s, 0.18s, 0.18s',
+      )
       await leave()
       assert.equal((await read()).mode, before.mode)
     }
@@ -101,7 +116,11 @@ export async function checkHomeHover(browser, base) {
     await leave()
     await page.clock.fastForward(1000)
     await page.emulateMedia({ reducedMotion: 'no-preference' })
-    assert.equal(await page.locator('html').getAttribute('data-home-scheme-fade'), null, 'Changing motion preference during a fade cleans up its styling')
+    assert.equal(
+      await page.locator('html').getAttribute('data-home-scheme-fade'),
+      null,
+      'Changing motion preference during a fade cleans up its styling',
+    )
     await page.emulateMedia({ reducedMotion: 'reduce' })
     await scheme('light').hover()
     await page.clock.fastForward(1200)
@@ -111,7 +130,12 @@ export async function checkHomeHover(browser, base) {
     await language.locator('summary').click()
     await language.locator('a[data-port="ruby"]').hover()
     await page.clock.fastForward(1200)
-    assert.equal(await page.evaluate(() => document.getAnimations().filter((a) => a.effect?.target?.matches('[data-home-language]')).length), 0)
+    assert.equal(
+      await page.evaluate(
+        () => document.getAnimations().filter((a) => a.effect?.target?.matches('[data-home-language]')).length,
+      ),
+      0,
+    )
     await page.keyboard.press('Escape')
     await language.locator('a[data-port="ruby"]').dispatchEvent('pointerenter', { pointerType: 'touch' })
     await page.clock.fastForward(1200)
@@ -120,7 +144,13 @@ export async function checkHomeHover(browser, base) {
     // A real client-side navigation unbinds homepage previews.
     await page.evaluate(() => {
       window.__homeNavigationComplete = false
-      document.addEventListener('astro:page-load', () => { window.__homeNavigationComplete = true }, { once: true })
+      document.addEventListener(
+        'astro:page-load',
+        () => {
+          window.__homeNavigationComplete = true
+        },
+        { once: true },
+      )
     })
     await page.locator('.site-header__mark').click()
     await page.waitForFunction(() => window.__homeNavigationComplete && document.querySelector('[data-home-launcher]'))
@@ -136,5 +166,7 @@ export async function checkHomeHover(browser, base) {
   } finally {
     await context.close()
   }
-  console.log('Homepage hover: all 13 languages, task sync, dwell, restore, commit, URL/storage, Auto/Light/Dark, reduced motion and documentation exclusion PASS')
+  console.log(
+    'Homepage hover: all 13 languages, task sync, dwell, restore, commit, URL/storage, Auto/Light/Dark, reduced motion and documentation exclusion PASS',
+  )
 }
diff --git a/site/scripts/check-home-launcher.mjs b/site/scripts/check-home-launcher.mjs
index a72784f9b..03afddc0f 100644
--- a/site/scripts/check-home-launcher.mjs
+++ b/site/scripts/check-home-launcher.mjs
@@ -12,48 +12,82 @@ export async function checkHomeLanguageIcon(page, port = null) {
   const trigger = page.locator('[data-home-launcher] [data-page-port-switcher] > summary')
   const icons = trigger.locator('img:visible')
   assert.equal(await icons.count(), port ? 1 : 0, 'Only the selected language icon is visible')
-  assert.equal(await trigger.locator('[data-home-default-icon]').isVisible(), !port, 'An unset language keeps the code glyph')
+  assert.equal(
+    await trigger.locator('[data-home-default-icon]').isVisible(),
+    !port,
+    'An unset language keeps the code glyph',
+  )
   const geometry = await trigger.evaluate((element) => {
     const icon = element.querySelector('.home-language-icon').getBoundingClientRect()
     const label = [...element.querySelectorAll('.page-port-name, .page-port-short-name')]
-      .find((node) => node.checkVisibility()).getBoundingClientRect()
+      .find((node) => node.checkVisibility())
+      .getBoundingClientRect()
     const button = element.getBoundingClientRect()
     const clear = element.closest('.clearable-picker').querySelector('.picker-clear')
     const caretElement = element.querySelector('.doc-picker-caret')
     const caret = caretElement.getBoundingClientRect()
     const clearBox = clear.getBoundingClientRect()
     const sizer = element.querySelector('.page-port-label-sizer')
-    return { height: button.height, iconHeight: icon.height, iconRight: icon.right, labelLeft: label.left,
-      clearFits: clear.hidden || (label.right < clearBox.left && clearBox.right <= button.right
-        && Math.abs(clearBox.x + clearBox.width / 2 - caret.x - caret.width / 2) < 1),
+    return {
+      height: button.height,
+      iconHeight: icon.height,
+      iconRight: icon.right,
+      labelLeft: label.left,
+      clearFits:
+        clear.hidden ||
+        (label.right < clearBox.left &&
+          clearBox.right <= button.right &&
+          Math.abs(clearBox.x + clearBox.width / 2 - caret.x - caret.width / 2) < 1),
       caretVisible: getComputedStyle(caretElement).visibility !== 'hidden',
       sizerHidden: getComputedStyle(sizer).visibility === 'hidden' && sizer.getBoundingClientRect().height === 0,
-      centerOffset: Math.abs(icon.y + icon.height / 2 - (button.y + button.height / 2)) }
+      centerOffset: Math.abs(icon.y + icon.height / 2 - (button.y + button.height / 2)),
+    }
   })
   assert.equal(geometry.height, 36, `The trigger keeps the same height for every language: ${JSON.stringify(geometry)}`)
   assert.equal(geometry.iconHeight, 24, 'Every language uses the same icon box')
   assert(geometry.clearFits, 'Clear occupies the chevron slot without covering the language label')
   assert.equal(geometry.caretVisible, !port, 'The clear button replaces the chevron only for an explicit language')
   assert(geometry.sizerHidden, 'Width measurement never exposes extra language labels')
-  assert.equal((await trigger.innerText()).trim(), port ? PORTS.find((entry) => entry.slug === port).name
-    : page.viewportSize().width <= 736 ? 'Port' : 'Language', 'The trigger shows only its current label')
-  const solution = await page.locator('[data-home-launcher] .home-launcher-solution:not([hidden]) .surface-picker > summary').boundingBox()
-  const solutionIcon = await page.locator('[data-home-launcher] .home-launcher-solution:not([hidden]) .surface-picker > summary > .surface-artwork').boundingBox()
+  assert.equal(
+    (await trigger.innerText()).trim(),
+    port ? PORTS.find((entry) => entry.slug === port).name : page.viewportSize().width <= 736 ? 'Port' : 'Language',
+    'The trigger shows only its current label',
+  )
+  const solution = await page
+    .locator('[data-home-launcher] .home-launcher-solution:not([hidden]) .surface-picker > summary')
+    .boundingBox()
+  const solutionIcon = await page
+    .locator('[data-home-launcher] .home-launcher-solution:not([hidden]) .surface-picker > summary > .surface-artwork')
+    .boundingBox()
   assert.equal(solution.height, geometry.height, 'The two launcher buttons have equal heights')
   assert.equal(solutionIcon.height, geometry.iconHeight, 'Language and solution icons use the same size')
-  assert(geometry.centerOffset < 1 && geometry.iconRight < geometry.labelLeft, 'The icon sits beside and centered with its label')
+  assert(
+    geometry.centerOffset < 1 && geometry.iconRight < geometry.labelLeft,
+    'The icon sits beside and centered with its label',
+  )
   if (port) {
     assert.equal(await icons.getAttribute('data-home-language-icon'), port)
     assert((await icons.getAttribute('src')).endsWith(`/brand/languages/${port}/icon.svg`))
-    assert(await icons.evaluate((img) => img.complete && img.naturalWidth > 0), 'The selected language SVG is already loaded')
+    assert(
+      await icons.evaluate((img) => img.complete && img.naturalWidth > 0),
+      'The selected language SVG is already loaded',
+    )
     const image = await icons.boundingBox()
     const box = await trigger.locator('.home-language-icon').boundingBox()
-    assert(Math.abs(image.width - 24) < .1, 'The image fits the icon box width')
-    assert(Math.abs(image.height - 24) < .1, 'Non-square artwork fits the icon box height')
-    assert(Math.abs(image.x - box.x) < 1 && Math.abs(image.y - box.y) <= 2, 'The image fits beside the label, allowing a small optical correction')
+    assert(Math.abs(image.width - 24) < 0.1, 'The image fits the icon box width')
+    assert(Math.abs(image.height - 24) < 0.1, 'Non-square artwork fits the icon box height')
+    assert(
+      Math.abs(image.x - box.x) < 1 && Math.abs(image.y - box.y) <= 2,
+      'The image fits beside the label, allowing a small optical correction',
+    )
   }
-  const menuSources = await page.locator('[data-home-launcher] .port-artwork').evaluateAll((images) => images.map((img) => img.getAttribute('src')))
-  assert(menuSources.length === PORTS.length && menuSources.every((src) => !src.includes('/brand/languages/')), 'Menu options keep their libtmux artwork')
+  const menuSources = await page
+    .locator('[data-home-launcher] .port-artwork')
+    .evaluateAll((images) => images.map((img) => img.getAttribute('src')))
+  assert(
+    menuSources.length === PORTS.length && menuSources.every((src) => !src.includes('/brand/languages/')),
+    'Menu options keep their libtmux artwork',
+  )
 }
 
 /** Keep compact labels and example options inside their available row. */
@@ -69,7 +103,12 @@ export async function checkHomeResponsiveLayout(page, width, port = null) {
   assert.equal(await launcher.locator('.page-port-name').isVisible(), !compact)
   assert.equal(await launcher.locator('.page-port-short-name').isVisible(), compact)
   if (!port && compact) assert.equal(await launcher.locator('.page-port-short-name').innerText(), 'Port')
-  if (port && compact) assert.equal(await launcher.locator('.page-port-short-name').innerText(), PORTS.find((entry) => entry.slug === port).name, 'Compact layouts retain the full language name')
+  if (port && compact)
+    assert.equal(
+      await launcher.locator('.page-port-short-name').innerText(),
+      PORTS.find((entry) => entry.slug === port).name,
+      'Compact layouts retain the full language name',
+    )
   const solution = launcher.locator('.home-launcher-solution:not([hidden])')
   assert.equal(await solution.locator('.home-solution-name-full').isVisible(), !compact)
   assert.equal(await solution.locator('.home-solution-name-short').isVisible(), compact)
@@ -124,15 +163,29 @@ export async function checkHomeLauncher(browser, base) {
     assert(await reset.isVisible(), 'A chosen language can be reset')
     assert.equal(await logo.count(), 0, 'The top header keeps only the wordmark')
     await checkHomeLanguageIcon(page, port)
-    assert.equal((await language.locator('summary').boundingBox()).width, previousWidth, 'Changing language leaves the adjacent solution selector in place')
-    const cards = await page.locator(`.home-intro [data-home-language="${port}"] .home-solutions > a`).evaluateAll((links) => links.map((link) => ({
-      display: getComputedStyle(link).display,
-      border: getComputedStyle(link).borderTopWidth,
-      label: getComputedStyle(link.querySelector('strong')).display,
-      description: getComputedStyle(link.querySelector('small')).display,
-    })))
-    assert(cards.length > 0 && cards.every((card) => card.display === 'flex' && card.border === '1px'
-      && card.label === 'block' && card.description === 'block'), `${port}: solution cards retain their layout and borders`)
+    assert.equal(
+      (await language.locator('summary').boundingBox()).width,
+      previousWidth,
+      'Changing language leaves the adjacent solution selector in place',
+    )
+    const cards = await page
+      .locator(`.home-intro [data-home-language="${port}"] .home-solutions > a`)
+      .evaluateAll((links) =>
+        links.map((link) => ({
+          display: getComputedStyle(link).display,
+          border: getComputedStyle(link).borderTopWidth,
+          label: getComputedStyle(link.querySelector('strong')).display,
+          description: getComputedStyle(link.querySelector('small')).display,
+        })),
+      )
+    assert(
+      cards.length > 0 &&
+        cards.every(
+          (card) =>
+            card.display === 'flex' && card.border === '1px' && card.label === 'block' && card.description === 'block',
+        ),
+      `${port}: solution cards retain their layout and borders`,
+    )
   }
   try {
     await page.goto(`${base}/`)
@@ -149,9 +202,15 @@ export async function checkHomeLauncher(browser, base) {
     for (const { slug } of PORTS) {
       await choose(slug)
       const links = await solution.locator('a').evaluateAll((links) => links.map((link) => link.getAttribute('href')))
-      assert(links.length > 0 && links.every((href) => href.startsWith(`${new URL(base).pathname}/${slug}/`)), `${slug}: owned solution destinations`)
+      assert(
+        links.length > 0 && links.every((href) => href.startsWith(`${new URL(base).pathname}/${slug}/`)),
+        `${slug}: owned solution destinations`,
+      )
       if (['kotlin', 'scala', 'fsharp'].includes(slug)) assert.equal(links.length, 1, `${slug}: core library only`)
-      assert.match(await prompt.locator(`[data-port="${slug}"] [data-prompt-text]`).innerText(), new RegExp(`/en/${slug}/`))
+      assert.match(
+        await prompt.locator(`[data-port="${slug}"] [data-prompt-text]`).innerText(),
+        new RegExp(`/en/${slug}/`),
+      )
       await checkHomeResponsiveLayout(page, 840, slug)
       await checkHomeResponsiveLayout(page, 280, slug)
       await page.setViewportSize({ width: 1280, height: 777 })
@@ -171,8 +230,16 @@ export async function checkHomeLauncher(browser, base) {
     await checkHomeLanguageIcon(page, 'fsharp')
     assert.equal(await prompt.locator('[data-select="topic"]').inputValue(), 'session-switcher')
     await choose('go')
-    assert.equal(new URL(page.url()).searchParams.get('prompt'), 'session-switcher', 'Language changes preserve the task')
-    assert.equal(new URL(page.url()).searchParams.get('from'), 'shared', 'Language changes preserve unrelated parameters')
+    assert.equal(
+      new URL(page.url()).searchParams.get('prompt'),
+      'session-switcher',
+      'Language changes preserve the task',
+    )
+    assert.equal(
+      new URL(page.url()).searchParams.get('from'),
+      'shared',
+      'Language changes preserve unrelated parameters',
+    )
     assert.equal(new URL(page.url()).hash, '#example')
     await prompt.locator('[data-action="reroll"]').click()
     const rerolled = await prompt.locator('[data-select="topic"]').inputValue()
@@ -180,7 +247,11 @@ export async function checkHomeLauncher(browser, base) {
     assert.equal(new URL(page.url()).searchParams.get('port'), 'go', 'Task changes preserve the language')
     await page.reload()
     await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'go')
-    assert.equal(await prompt.locator('[data-select="topic"]').inputValue(), rerolled, 'Reload restores the language and task')
+    assert.equal(
+      await prompt.locator('[data-select="topic"]').inputValue(),
+      rerolled,
+      'Reload restores the language and task',
+    )
     await language.locator('summary').click()
     const resetGap = await language.locator('.doc-picker-title-actions').evaluate((actions) => {
       const button = actions.querySelector('button').getBoundingClientRect()
@@ -198,39 +269,62 @@ export async function checkHomeLauncher(browser, base) {
     assert.equal(await logo.count(), 0, 'Reset keeps the wordmark without duplicate artwork')
     await checkHomeLanguageIcon(page)
     assert.equal(await language.locator('[aria-current]').count(), 0, 'Reset leaves no selected language')
-    assert(await language.locator('summary').evaluate((element) => document.activeElement === element), 'Reset keeps focus on the language picker')
+    assert(
+      await language.locator('summary').evaluate((element) => document.activeElement === element),
+      'Reset keeps focus on the language picker',
+    )
     await page.reload()
-    await page.waitForFunction(() => document.querySelector('[data-home-launcher] .page-port-name')?.innerText.trim() === 'Language')
+    await page.waitForFunction(
+      () => document.querySelector('[data-home-launcher] .page-port-name')?.innerText.trim() === 'Language',
+    )
     assert.equal(await reset.isVisible(), false, 'The cleared choice stays cleared on reload')
     await checkHomeLanguageIcon(page)
     assert.equal(await prompt.getAttribute('data-active-port'), PORTS[0].slug)
     await choose('fsharp')
     await reset.click()
-    assert.equal(new URL(page.url()).searchParams.has('port'), false, 'The header reset also removes the port parameter')
+    assert.equal(
+      new URL(page.url()).searchParams.has('port'),
+      false,
+      'The header reset also removes the port parameter',
+    )
     await page.goto(`${base}/?port=constructor&prompt=setup`)
-    await page.waitForFunction(() => document.querySelector('[data-home-launcher] .page-port-name')?.innerText.trim() === 'Language')
+    await page.waitForFunction(
+      () => document.querySelector('[data-home-launcher] .page-port-name')?.innerText.trim() === 'Language',
+    )
     assert.equal(new URL(page.url()).searchParams.has('port'), false, 'Unknown languages do not become a selection')
     await page.goto(`${base}/?port=fsharp&prompt=setup#first`)
     await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'fsharp')
-    await page.evaluate(() => { location.hash = 'second' })
+    await page.evaluate(() => {
+      location.hash = 'second'
+    })
     await choose('go')
     await chooseHomeTask(page, 'session-switcher')
     await page.goBack()
-    await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'fsharp'
-      && document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === 'setup')
+    await page.waitForFunction(
+      () =>
+        document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'fsharp' &&
+        document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === 'setup',
+    )
     assert.equal(new URL(page.url()).hash, '#first', 'Back restores the matching language and task')
     await checkHomeLanguageIcon(page, 'fsharp')
     // The popstate handlers restore choices before Astro swaps this page.
     await page.evaluate(() => {
       window.__homeNavigationComplete = false
-      document.addEventListener('astro:page-load', () => {
-        window.__homeNavigationComplete = true
-      }, { once: true })
+      document.addEventListener(
+        'astro:page-load',
+        () => {
+          window.__homeNavigationComplete = true
+        },
+        { once: true },
+      )
     })
     await page.goForward()
     await page.waitForFunction(() => window.__homeNavigationComplete)
-    await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'go'
-      && document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === 'session-switcher')
+    await page.waitForFunction(
+      () =>
+        document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'go' &&
+        document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === 'session-switcher',
+    )
     assert.equal(new URL(page.url()).hash, '#second', 'Forward restores the matching language and task')
     await checkHomeLanguageIcon(page, 'go')
     await choose('py')
@@ -238,16 +332,28 @@ export async function checkHomeLauncher(browser, base) {
     await chooseHomeTask(page, 'setup')
     const original = await prompt.locator('[data-port="py"] [data-prompt-text]').innerText()
     const tasks = await topic.locator('option').evaluateAll((options) => options.map((option) => option.value))
-    await chooseHomeTask(page, tasks.find((value) => value !== 'setup'))
+    await chooseHomeTask(
+      page,
+      tasks.find((value) => value !== 'setup'),
+    )
     const text = await prompt.locator('[data-port="py"] [data-prompt-text]').innerText()
     assert.notEqual(text, original, 'Task selection still recomposes the prompt')
-    await page.evaluate(() => Object.defineProperty(navigator, 'clipboard', { configurable: true, value: {
-      writeText: async (text) => { window.__homeCopiedPrompt = text },
-    } }))
+    await page.evaluate(() =>
+      Object.defineProperty(navigator, 'clipboard', {
+        configurable: true,
+        value: {
+          writeText: async (text) => {
+            window.__homeCopiedPrompt = text
+          },
+        },
+      }),
+    )
     await prompt.locator('[data-port="py"] [data-action="copy"]').click()
     assert.equal(await page.evaluate(() => window.__homeCopiedPrompt), text, 'Copy preserves all prompt bytes')
     for (const theme of ['light', 'dark']) {
-      await page.evaluate((theme) => { document.documentElement.dataset.themeMode = theme }, theme)
+      await page.evaluate((theme) => {
+        document.documentElement.dataset.themeMode = theme
+      }, theme)
       const colors = await page.evaluate(() => {
         const code = document.querySelector('.home-examples [data-home-language="py"] .expressive-code pre')
         const prompt = document.querySelector('.lm-agent-prompt__code')
@@ -256,8 +362,14 @@ export async function checkHomeLauncher(browser, base) {
       assert.equal(colors[0], colors[1], `${theme}: code and prompt use the same background`)
       for (const width of [1920, 1440, 1135, 906, 390, 320]) {
         await page.setViewportSize({ width, height: 777 })
-        assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), `${theme}/${width}: no page overflow`)
-        assert(await language.isVisible() && await solution.isVisible(), `${theme}/${width}: both header pickers visible`)
+        assert(
+          await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+          `${theme}/${width}: no page overflow`,
+        )
+        assert(
+          (await language.isVisible()) && (await solution.isVisible()),
+          `${theme}/${width}: both header pickers visible`,
+        )
       }
     }
     await choose('rs')
@@ -270,7 +382,9 @@ export async function checkHomeLauncher(browser, base) {
           name: file.dataset.homeFile,
           code: file.querySelector('[data-code]').getAttribute('data-code').replaceAll('\x7f', '\n'),
         })),
-        commands: [...element.querySelectorAll('[data-home-command] [data-code]')].map((button) => button.getAttribute('data-code').replaceAll('\x7f', '\n')),
+        commands: [...element.querySelectorAll('[data-home-command] [data-code]')].map((button) =>
+          button.getAttribute('data-code').replaceAll('\x7f', '\n'),
+        ),
       }))
       const hash = (text) => createHash('sha256').update(text).digest('hex')
       assert.deepEqual(rendered.commands, proof.shellRecipe, `${proof.port}: exact setup and run copy payloads`)
@@ -278,18 +392,32 @@ export async function checkHomeLauncher(browser, base) {
         await panel.locator('[data-example-errors]').setChecked(view === 'errors' || view === 'full')
         await panel.locator('[data-example-cleanup]').setChecked(view === 'cleanup' || view === 'full')
         const selected = panel.locator(`[data-home-view="${view}"]`)
-        assert.equal(await panel.locator('[data-home-view]:visible').count(), 1, `${proof.port}/${view}: exactly one complete program is shown`)
+        assert.equal(
+          await panel.locator('[data-home-view]:visible').count(),
+          1,
+          `${proof.port}/${view}: exactly one complete program is shown`,
+        )
         assert(await selected.isVisible(), `${proof.port}/${view}: the selected program is shown`)
         const binding = view === 'full' ? proof : proof.variants[view]
         const main = await selected.locator('[data-code]').getAttribute('data-code')
         const codeText = main.replaceAll('\x7f', '\n')
         assert.equal(hash(codeText), binding.excerptSha256, `${proof.port}/${view}: exact visible program`)
-        await page.evaluate(() => { window.__homeCopiedPrompt = null })
+        await page.evaluate(() => {
+          window.__homeCopiedPrompt = null
+        })
         await selected.locator('[data-code]').click()
-        assert.equal(await page.evaluate(() => window.__homeCopiedPrompt), codeText, `${proof.port}/${view}: Copy matches the visible program`)
+        assert.equal(
+          await page.evaluate(() => window.__homeCopiedPrompt),
+          codeText,
+          `${proof.port}/${view}: Copy matches the visible program`,
+        )
         const files = [{ name: await selected.getAttribute('data-home-file'), code: codeText }, ...rendered.files]
         const byName = (a, b) => a.name.localeCompare(b.name)
-        assert.deepEqual(files.map((file) => ({ name: file.name, sha256: hash(file.code) })).sort(byName), binding.files.map((file) => ({ name: file.name, sha256: file.clipboardSha256 })).sort(byName), `${proof.port}/${view}: complete native-verified file copy payloads`)
+        assert.deepEqual(
+          files.map((file) => ({ name: file.name, sha256: hash(file.code) })).sort(byName),
+          binding.files.map((file) => ({ name: file.name, sha256: file.clipboardSha256 })).sort(byName),
+          `${proof.port}/${view}: complete native-verified file copy payloads`,
+        )
         const pre = selected.locator('pre')
         const width = await pre.evaluate(async (element) => {
           // Container-query sizes settle after a previously hidden panel is painted.
@@ -297,18 +425,32 @@ export async function checkHomeLauncher(browser, base) {
           await new Promise(requestAnimationFrame)
           await document.fonts.ready
           await new Promise(requestAnimationFrame)
-          return { available: element.clientWidth, content: element.scrollWidth,
+          return {
+            available: element.clientWidth,
+            content: element.scrollWidth,
             font: getComputedStyle(element.querySelector('code')).fontSize,
             gutter: getComputedStyle(element).scrollbarGutter,
             container: getComputedStyle(element).containerType,
             columns: element.closest('[data-home-view]').style.getPropertyValue('--home-code-columns'),
-            lines: [...element.querySelectorAll('.code')].map((line) => {
-              const range = document.createRange(); range.selectNodeContents(line)
-              return { text: line.textContent, width: range.getBoundingClientRect().width,
-                font: getComputedStyle(line).font, padding: getComputedStyle(line).padding }
-            }).sort((a, b) => b.width - a.width).slice(0, 2) }
+            lines: [...element.querySelectorAll('.code')]
+              .map((line) => {
+                const range = document.createRange()
+                range.selectNodeContents(line)
+                return {
+                  text: line.textContent,
+                  width: range.getBoundingClientRect().width,
+                  font: getComputedStyle(line).font,
+                  padding: getComputedStyle(line).padding,
+                }
+              })
+              .sort((a, b) => b.width - a.width)
+              .slice(0, 2),
+          }
         })
-        assert(width.content <= width.available + 1, `${proof.port}/${view}: no horizontal scrollbar at 1093px ${JSON.stringify(width)}`)
+        assert(
+          width.content <= width.available + 1,
+          `${proof.port}/${view}: no horizontal scrollbar at 1093px ${JSON.stringify(width)}`,
+        )
       }
     }
     await choose('rs')
@@ -319,7 +461,9 @@ export async function checkHomeLauncher(browser, base) {
       const layout = await page.evaluate(() => {
         const intro = document.querySelector('.home-intro').getBoundingClientRect()
         const examples = document.querySelector('.home-examples').getBoundingClientRect()
-        const font = getComputedStyle(document.querySelector('.home-examples [data-home-language="rs"] [data-home-view="full"] pre code')).fontSize
+        const font = getComputedStyle(
+          document.querySelector('.home-examples [data-home-language="rs"] [data-home-view="full"] pre code'),
+        ).fontSize
         return { intro: intro.width, examples: examples.width, font: parseFloat(font) }
       })
       assert(layout.intro <= 320.5, `${width}: intro stops at 20rem`)
@@ -328,11 +472,28 @@ export async function checkHomeLauncher(browser, base) {
       fontSizes.push(layout.font)
     }
     assert(fontSizes[0] < fontSizes[2], 'Code grows with its container')
-    await page.locator('.home-examples').evaluate((element) => { element.style.width = '360px' })
-    assert.equal(await code.evaluate((element) => getComputedStyle(element).fontSize), '13px', 'Sizing follows the container at the same viewport')
-    await code.locator('.ec-line').first().evaluate((line) => { line.textContent = 'unusuallyLongSymbol'.repeat(12) })
-    assert(await code.locator('..').evaluate((pre) => pre.scrollWidth > pre.clientWidth), 'An indivisible symbol remains scrollable')
-    assert(await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1), 'Long symbols do not widen the page')
+    await page.locator('.home-examples').evaluate((element) => {
+      element.style.width = '360px'
+    })
+    assert.equal(
+      await code.evaluate((element) => getComputedStyle(element).fontSize),
+      '13px',
+      'Sizing follows the container at the same viewport',
+    )
+    await code
+      .locator('.ec-line')
+      .first()
+      .evaluate((line) => {
+        line.textContent = 'unusuallyLongSymbol'.repeat(12)
+      })
+    assert(
+      await code.locator('..').evaluate((pre) => pre.scrollWidth > pre.clientWidth),
+      'An indivisible symbol remains scrollable',
+    )
+    assert(
+      await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth + 1),
+      'Long symbols do not widen the page',
+    )
     await page.reload()
     await language.locator('[data-port="rs"]').waitFor({ state: 'attached' })
     await page.setViewportSize({ width: 906, height: 777 })
@@ -340,7 +501,10 @@ export async function checkHomeLauncher(browser, base) {
     await page.keyboard.press('Enter')
     await page.keyboard.press('Escape')
     assert.equal(await language.getAttribute('open'), null, 'Escape closes the picker')
-    assert(await language.locator('summary').evaluate((element) => document.activeElement === element), 'Escape restores focus')
+    assert(
+      await language.locator('summary').evaluate((element) => document.activeElement === element),
+      'Escape restores focus',
+    )
     assert.deepEqual(errors, [], 'Homepage has no runtime errors')
   } finally {
     await context.close()
@@ -348,10 +512,16 @@ export async function checkHomeLauncher(browser, base) {
   const blockedStorage = await browser.newContext()
   try {
     // Astro's development toolbar reads storage unguarded; it is absent from published pages.
-    await blockedStorage.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) => route.fulfill({ contentType: 'application/javascript', body: 'export {}' }))
-    await blockedStorage.addInitScript(() => Object.defineProperty(window, 'localStorage', {
-      get() { throw new DOMException('Storage blocked', 'SecurityError') },
-    }))
+    await blockedStorage.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) =>
+      route.fulfill({ contentType: 'application/javascript', body: 'export {}' }),
+    )
+    await blockedStorage.addInitScript(() =>
+      Object.defineProperty(window, 'localStorage', {
+        get() {
+          throw new DOMException('Storage blocked', 'SecurityError')
+        },
+      }),
+    )
     const page = await blockedStorage.newPage()
     page.on('pageerror', (error) => errors.push(error.message))
     await page.goto(`${base}/?port=fsharp&prompt=session-switcher`)
@@ -364,7 +534,9 @@ export async function checkHomeLauncher(browser, base) {
     await checkHomeLanguageIcon(page)
     assert.equal(new URL(page.url()).searchParams.has('port'), false)
     await page.reload()
-    await page.waitForFunction(() => document.querySelector('[data-home-launcher] .page-port-name')?.innerText.trim() === 'Language')
+    await page.waitForFunction(
+      () => document.querySelector('[data-home-launcher] .page-port-name')?.innerText.trim() === 'Language',
+    )
     assert.deepEqual(errors, [], 'Shared links and reset work without storage')
   } finally {
     await blockedStorage.close()
@@ -383,9 +555,16 @@ export async function checkHomeLauncher(browser, base) {
     }
     await picker.locator('summary').click()
     await checkHomeLanguageIcon(page)
-    assert.equal(await picker.locator('a[data-port]:visible').count(), PORTS.length, 'No-JS still exposes real language links')
+    assert.equal(
+      await picker.locator('a[data-port]:visible').count(),
+      PORTS.length,
+      'No-JS still exposes real language links',
+    )
     assert(await picker.locator('.tmux-area a').isVisible(), 'No-JS retains the separate tmux destination')
-    assert(await page.locator('.lm-agent-prompt__panel[data-default] [data-prompt-text]').isVisible(), 'Default prompt remains readable without JavaScript')
+    assert(
+      await page.locator('.lm-agent-prompt__panel[data-default] [data-prompt-text]').isVisible(),
+      'Default prompt remains readable without JavaScript',
+    )
     await picker.locator('a[data-port="ruby"]').click()
     await page.waitForURL('**/ruby/latest/')
   } finally {
@@ -395,5 +574,7 @@ export async function checkHomeLauncher(browser, base) {
   await checkHomeTaskReset(browser, base)
   await checkColorScheme(browser, base)
   await checkHomeExampleOptions(browser, base)
-  console.log('Homepage: 13 languages, 52 complete selectable programs/copy, owned solutions, shared URLs, reset, blocked storage, prompt tasks/copy, shared themes, container sizing, keyboard and no-JS PASS')
+  console.log(
+    'Homepage: 13 languages, 52 complete selectable programs/copy, owned solutions, shared URLs, reset, blocked storage, prompt tasks/copy, shared themes, container sizing, keyboard and no-JS PASS',
+  )
 }
diff --git a/site/scripts/check-home-task-reset.mjs b/site/scripts/check-home-task-reset.mjs
index d6845020e..a4171c061 100644
--- a/site/scripts/check-home-task-reset.mjs
+++ b/site/scripts/check-home-task-reset.mjs
@@ -1,17 +1,26 @@
 import assert from 'node:assert/strict'
 
 async function checkTaskFirstPaint(browser, base) {
-  const versions = { schema: 1, ports: { ts: [
-    { slug: 'latest', label: 'latest', kind: 'trunk', supported: true },
-    { slug: 'next', label: 'next', kind: 'alias', supported: true },
-    { slug: 'v0.1.0-alpha.12', label: 'v0.1.0-alpha.12', kind: 'prerelease', supported: true },
-  ] } }
+  const versions = {
+    schema: 1,
+    ports: {
+      ts: [
+        { slug: 'latest', label: 'latest', kind: 'trunk', supported: true },
+        { slug: 'next', label: 'next', kind: 'alias', supported: true },
+        { slug: 'v0.1.0-alpha.12', label: 'v0.1.0-alpha.12', kind: 'prerelease', supported: true },
+      ],
+    },
+  }
   for (const width of [853, 390, 280]) {
     const context = await browser.newContext({ viewport: { width, height: 789 }, reducedMotion: 'reduce' })
     let releaseWidget
-    const widgetReady = new Promise((resolve) => { releaseWidget = resolve })
+    const widgetReady = new Promise((resolve) => {
+      releaseWidget = resolve
+    })
     try {
-      await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) => route.fulfill({ contentType: 'application/javascript', body: 'export {}' }))
+      await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) =>
+        route.fulfill({ contentType: 'application/javascript', body: 'export {}' }),
+      )
       await context.route('**/*AgentPrompt*', async (route) => {
         if (route.request().resourceType() === 'script') await widgetReady
         await route.continue()
@@ -25,23 +34,42 @@ async function checkTaskFirstPaint(browser, base) {
       const native = widget.locator('[data-task-native] select')
       await native.waitFor({ state: 'visible' })
       await page.evaluate(() => document.fonts.ready)
-      assert.equal((await native.boundingBox()).height, 36, `${width}: the initial task selector reserves its enhanced height`)
-      const geometry = () => widget.locator('.lm-agent-prompt__controls').evaluate((bar) => {
-        const origin = bar.getBoundingClientRect()
-        const elements = ['.lm-agent-prompt__task', '[data-action="reroll"]', '[data-summary]'].map((selector) => [selector, bar.querySelector(selector)])
-        elements.push(['task control', bar.querySelector('[data-task-native]:not([hidden]) select, [data-task-enhanced]:not([hidden]) [data-task-menu] > summary')])
-        return Object.fromEntries(elements.map(([name, element]) => {
-          if (!element.getClientRects().length) return [name, null]
-          const box = element.getBoundingClientRect()
-          return [name, { x: box.x - origin.x, y: box.y - origin.y, width: box.width, height: box.height }]
-        }))
-      })
+      assert.equal(
+        (await native.boundingBox()).height,
+        36,
+        `${width}: the initial task selector reserves its enhanced height`,
+      )
+      const geometry = () =>
+        widget.locator('.lm-agent-prompt__controls').evaluate((bar) => {
+          const origin = bar.getBoundingClientRect()
+          const elements = ['.lm-agent-prompt__task', '[data-action="reroll"]', '[data-summary]'].map((selector) => [
+            selector,
+            bar.querySelector(selector),
+          ])
+          elements.push([
+            'task control',
+            bar.querySelector(
+              '[data-task-native]:not([hidden]) select, [data-task-enhanced]:not([hidden]) [data-task-menu] > summary',
+            ),
+          ])
+          return Object.fromEntries(
+            elements.map(([name, element]) => {
+              if (!element.getClientRects().length) return [name, null]
+              const box = element.getBoundingClientRect()
+              return [name, { x: box.x - origin.x, y: box.y - origin.y, width: box.width, height: box.height }]
+            }),
+          )
+        })
       const before = await geometry()
       releaseWidget()
       await page.waitForLoadState('load')
       await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'ts')
       await page.waitForLoadState('networkidle')
-      assert.equal(await widget.locator('[data-version-control]').count(), 0, 'Published versions do not insert another homepage control')
+      assert.equal(
+        await widget.locator('[data-version-control]').count(),
+        0,
+        'Published versions do not insert another homepage control',
+      )
       assert.deepEqual(await geometry(), before, `${width}: initializing the task picker leaves the row in place`)
       const visiblePrompt = widget.locator('[data-port="ts"] [data-prompt-text]')
       assert.match(await visiblePrompt.innerText(), /\/ts\/latest\//, 'The homepage prompt uses the port default')
@@ -50,7 +78,11 @@ async function checkTaskFirstPaint(browser, base) {
         const version = page.locator('.lm-agent-prompt [data-select="version"]')
         await version.waitFor({ state: 'visible' })
         await version.selectOption('v0.1.0-alpha.12')
-        assert.match(await page.locator('.lm-agent-prompt [data-port="ts"] [data-prompt-text]').innerText(), /\/ts\/v0\.1\.0-alpha\.12\//, 'Dedicated prompts retain version selection')
+        assert.match(
+          await page.locator('.lm-agent-prompt [data-port="ts"] [data-prompt-text]').innerText(),
+          /\/ts\/v0\.1\.0-alpha\.12\//,
+          'Dedicated prompts retain version selection',
+        )
       }
     } finally {
       releaseWidget()
@@ -61,9 +93,12 @@ async function checkTaskFirstPaint(browser, base) {
 
 export async function chooseHomeTask(page, topic) {
   const menu = page.locator('[data-task-menu]')
-  if (!await menu.evaluate((element) => element.open)) await menu.locator('summary .doc-picker-caret').click()
+  if (!(await menu.evaluate((element) => element.open))) await menu.locator('summary .doc-picker-caret').click()
   await menu.locator(`[data-task-option="${topic}"]`).click()
-  await page.waitForFunction((topic) => document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === topic, topic)
+  await page.waitForFunction(
+    (topic) => document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === topic,
+    topic,
+  )
   await menu.locator('summary').waitFor({ state: 'visible' })
   await page.evaluate(() => new Promise(requestAnimationFrame))
 }
@@ -74,10 +109,16 @@ export async function checkHomeTaskReset(browser, base) {
     const context = await browser.newContext({ viewport: { width: 914, height: 777 }, reducedMotion: 'reduce' })
     try {
       if (blocked) {
-        await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) => route.fulfill({ contentType: 'application/javascript', body: 'export {}' }))
-        await context.addInitScript(() => Object.defineProperty(window, 'localStorage', {
-          get() { throw new DOMException('Storage blocked', 'SecurityError') },
-        }))
+        await context.route('**/astro/runtime/client/dev-toolbar/entrypoint.js', (route) =>
+          route.fulfill({ contentType: 'application/javascript', body: 'export {}' }),
+        )
+        await context.addInitScript(() =>
+          Object.defineProperty(window, 'localStorage', {
+            get() {
+              throw new DOMException('Storage blocked', 'SecurityError')
+            },
+          }),
+        )
       }
       const page = await context.newPage()
       const errors = []
@@ -91,15 +132,23 @@ export async function checkHomeTaskReset(browser, base) {
       await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'ruby')
       await page.evaluate(() => {
         window.__taskNavigations = 0
-        document.addEventListener('astro:before-preparation', () => { window.__taskNavigations++ })
+        document.addEventListener('astro:before-preparation', () => {
+          window.__taskNavigations++
+        })
       })
       assert.equal(await reset.isVisible(), false, 'The default task is not an explicit selection')
       await chooseHomeTask(page, 'session-switcher')
-      assert.equal(await page.evaluate(() => window.__taskNavigations), 0, 'Choosing a task updates the widget without starting page navigation')
+      assert.equal(
+        await page.evaluate(() => window.__taskNavigations),
+        0,
+        'Choosing a task updates the widget without starting page navigation',
+      )
       assert(await reset.isVisible())
       assert.equal(new URL(page.url()).searchParams.get('prompt'), 'session-switcher')
       await page.reload()
-      await page.waitForFunction(() => document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === 'session-switcher')
+      await page.waitForFunction(
+        () => document.querySelector('.lm-agent-prompt [data-select="topic"]')?.value === 'session-switcher',
+      )
       assert(await reset.isVisible(), 'A shared task offers Reset after reload')
       await reset.click()
       assert.equal(await select.inputValue(), 'setup')
@@ -108,8 +157,12 @@ export async function checkHomeTaskReset(browser, base) {
       assert.deepEqual(new URL(page.url()).searchParams.getAll('from'), ['a', 'b'])
       assert.equal(new URL(page.url()).hash, '#prompt')
       assert.equal(await reset.isVisible(), false)
-      assert(await control.evaluate((element) => element === document.activeElement), 'Clear moves focus to the task selector')
-      if (!blocked) assert.equal(await page.evaluate(() => localStorage.getItem('libtmux-docs.agent-prompt.topic')), null)
+      assert(
+        await control.evaluate((element) => element === document.activeElement),
+        'Clear moves focus to the task selector',
+      )
+      if (!blocked)
+        assert.equal(await page.evaluate(() => localStorage.getItem('libtmux-docs.agent-prompt.topic')), null)
       assert.match(await widget.locator('[data-port="ruby"] [data-prompt-text]').innerText(), /^Set up libtmux/)
       await page.reload()
       await page.waitForFunction(() => document.querySelector('.lm-agent-prompt')?.dataset.activePort === 'ruby')
@@ -124,7 +177,9 @@ export async function checkHomeTaskReset(browser, base) {
       assert.equal(new URL(page.url()).searchParams.get('prompt'), 'setup')
       if (!blocked) {
         await page.goto(`${base}/?port=ruby`)
-        await page.waitForFunction(() => !document.querySelector('.lm-agent-prompt [data-action="reset-topic"]')?.hidden)
+        await page.waitForFunction(
+          () => !document.querySelector('.lm-agent-prompt [data-action="reset-topic"]')?.hidden,
+        )
         assert.equal(await select.inputValue(), 'setup', 'A saved explicit default can be reset')
       }
       for (const width of [914, 850, 778, 659, 628, 596, 390, 320, 280]) {
@@ -135,18 +190,38 @@ export async function checkHomeTaskReset(browser, base) {
             const { x, y, width, height } = bar.querySelector(selector).getBoundingClientRect()
             return { x, y, width, height, center: y + height / 2 }
           }
-          return { client: bar.clientWidth, scroll: bar.scrollWidth, bar: bar.getBoundingClientRect().toJSON(),
-            select: bounds('[data-task-menu] > summary'), label: bounds('[data-task-current]'), reroll: bounds('[data-action="reroll"]'), reset: bounds('[data-action="reset-topic"]'), caret: bounds('[data-task-menu] > summary .doc-picker-caret') }
+          return {
+            client: bar.clientWidth,
+            scroll: bar.scrollWidth,
+            bar: bar.getBoundingClientRect().toJSON(),
+            select: bounds('[data-task-menu] > summary'),
+            label: bounds('[data-task-current]'),
+            reroll: bounds('[data-action="reroll"]'),
+            reset: bounds('[data-action="reset-topic"]'),
+            caret: bounds('[data-task-menu] > summary .doc-picker-caret'),
+          }
         })
-        assert(geometry.scroll <= geometry.client + 1, `${width}: task bar does not overflow ${JSON.stringify(geometry)}`)
+        assert(
+          geometry.scroll <= geometry.client + 1,
+          `${width}: task bar does not overflow ${JSON.stringify(geometry)}`,
+        )
         assert(Math.abs(geometry.select.center - geometry.reset.center) < 1, `${width}: Reset stays on the task row`)
         assert(Math.abs(geometry.select.center - geometry.reroll.center) < 1, `${width}: reroll stays on the task row`)
         assert.equal(geometry.reroll.height, geometry.select.height, `${width}: reroll matches the selector height`)
         assert.equal(geometry.reroll.width, geometry.reroll.height, 'The reroll button is square')
         assert(geometry.select.width >= 100, `${width}: the selector remains usable ${JSON.stringify(geometry)}`)
-        assert(geometry.reset.x > geometry.select.x && geometry.reset.x + geometry.reset.width <= geometry.caret.x, 'Clear is inside the control before the chevron')
-        assert(geometry.label.x + geometry.label.width < geometry.reset.x, 'The task label cannot extend underneath Clear')
-        assert(geometry.select.x + geometry.select.width - geometry.caret.x - geometry.caret.width < 11, 'The chevron stays at the right edge')
+        assert(
+          geometry.reset.x > geometry.select.x && geometry.reset.x + geometry.reset.width <= geometry.caret.x,
+          'Clear is inside the control before the chevron',
+        )
+        assert(
+          geometry.label.x + geometry.label.width < geometry.reset.x,
+          'The task label cannot extend underneath Clear',
+        )
+        assert(
+          geometry.select.x + geometry.select.width - geometry.caret.x - geometry.caret.width < 11,
+          'The chevron stays at the right edge',
+        )
         assert(geometry.reset.width >= 24 && geometry.reset.height >= 24, 'Clear has a usable hit target')
         assert.equal(await reset.getAttribute('aria-label'), 'Clear task selection')
         assert(await control.getAttribute('title'), 'The full task description remains available when abbreviated')
@@ -156,15 +231,20 @@ export async function checkHomeTaskReset(browser, base) {
       const tasks = await select.locator('option').evaluateAll((options) => options.map((option) => option.value))
       for (const width of [850, 628, 596, 280]) {
         await page.setViewportSize({ width, height: 777 })
-        const read = () => widget.locator('.lm-agent-prompt__controls').evaluate((bar) => {
-          const select = bar.querySelector('[data-task-menu] > summary').getBoundingClientRect()
-          const reroll = bar.querySelector('[data-action="reroll"]').getBoundingClientRect()
-          return { width: select.width, x: reroll.x, height: bar.getBoundingClientRect().height }
-        })
+        const read = () =>
+          widget.locator('.lm-agent-prompt__controls').evaluate((bar) => {
+            const select = bar.querySelector('[data-task-menu] > summary').getBoundingClientRect()
+            const reroll = bar.querySelector('[data-action="reroll"]').getBoundingClientRect()
+            return { width: select.width, x: reroll.x, height: bar.getBoundingClientRect().height }
+          })
         const original = await read()
         for (const task of tasks) {
           await chooseHomeTask(page, task)
-          assert.deepEqual(await read(), original, `${width}/${task}: selecting a task leaves control geometry unchanged`)
+          assert.deepEqual(
+            await read(),
+            original,
+            `${width}/${task}: selecting a task leaves control geometry unchanged`,
+          )
         }
         await widget.locator('[data-action="reroll"]').click()
         assert.deepEqual(await read(), original, `${width}: reroll does not move its target`)
@@ -173,11 +253,15 @@ export async function checkHomeTaskReset(browser, base) {
         if (width >= 628) {
           await chooseHomeTask(page, 'agent-orchestrator')
           const description = await widget.locator('[data-summary]').evaluate((element) => ({
-            height: element.clientHeight, lineHeight: parseFloat(getComputedStyle(element).lineHeight),
+            height: element.clientHeight,
+            lineHeight: parseFloat(getComputedStyle(element).lineHeight),
             clamp: getComputedStyle(element).webkitLineClamp,
           }))
           assert.equal(description.clamp, '2')
-          assert(Math.abs(description.height - 2 * description.lineHeight) < 1, 'The description reserves two lines before truncation')
+          assert(
+            Math.abs(description.height - 2 * description.lineHeight) < 1,
+            'The description reserves two lines before truncation',
+          )
           assert.equal((await read()).width, 224, 'The task selector has a fixed 14rem width when it fits')
         }
       }
@@ -191,8 +275,14 @@ export async function checkHomeTaskReset(browser, base) {
       assert.equal(await select.inputValue(), 'session-freezer', 'Search and keyboard select the task')
       assert(await control.evaluate((element) => element === document.activeElement))
       await page.keyboard.press('Tab')
-      assert(await reset.evaluate((element) => element === document.activeElement), 'Clear follows the task selector in the tab order')
-      assert(await reset.evaluate((element) => parseFloat(getComputedStyle(element).outlineWidth) > 0), 'Clear has a visible keyboard focus indicator')
+      assert(
+        await reset.evaluate((element) => element === document.activeElement),
+        'Clear follows the task selector in the tab order',
+      )
+      assert(
+        await reset.evaluate((element) => parseFloat(getComputedStyle(element).outlineWidth) > 0),
+        'Clear has a visible keyboard focus indicator',
+      )
       await page.keyboard.press('Enter')
       assert.equal(new URL(page.url()).searchParams.has('prompt'), false, 'Keyboard clear removes the query parameter')
       await control.click()
@@ -204,5 +294,7 @@ export async function checkHomeTaskReset(browser, base) {
       await context.close()
     }
   }
-  console.log('Task picker: fixed width across every task, stable reroll, two-line descriptions, clear placement, URL/storage, search, keyboard and single-row controls at 280–914px PASS')
+  console.log(
+    'Task picker: fixed width across every task, stable reroll, two-line descriptions, clear placement, URL/storage, search, keyboard and single-row controls at 280–914px PASS',
+  )
 }
diff --git a/site/scripts/check-mobile-nav.mjs b/site/scripts/check-mobile-nav.mjs
index 02c001b00..ae4992fce 100755
--- a/site/scripts/check-mobile-nav.mjs
+++ b/site/scripts/check-mobile-nav.mjs
@@ -25,9 +25,11 @@ import { chromium } from 'playwright'
 import { checkApiNavigation } from './check-navigation.mjs'
 const BASE = (process.argv[2] ?? 'http://localhost:8080').replace(/\/$/, '')
 const b = await chromium.launch()
-const fails = [], ok = []
+const fails = [],
+  ok = []
 const note = (pass, msg) => (pass ? ok : fails).push(msg)
-const WITH_TOC = '/tmux/topics/traversal/', NO_TOC = '/tmux/concepts/'
+const WITH_TOC = '/tmux/topics/traversal/',
+  NO_TOC = '/tmux/concepts/'
 const ctx = await b.newContext()
 const apiPage = await ctx.newPage()
 try {
@@ -43,29 +45,38 @@ async function page(path, w = 390) {
   await p.goto(BASE + path, { waitUntil: 'networkidle' })
   return p
 }
-const openState = (p, id, closedClass) => p.evaluate(([i, c]) => {
-  const el = document.getElementById(i)
-  return !!el && !el.classList.contains(c)
-}, [id, closedClass])
+const openState = (p, id, closedClass) =>
+  p.evaluate(
+    ([i, c]) => {
+      const el = document.getElementById(i)
+      return !!el && !el.classList.contains(c)
+    },
+    [id, closedClass],
+  )
 
 // aria-expanded
 {
-  const p = await page(WITH_TOC), t = p.locator('#mobile-sidebar-toggle')
+  const p = await page(WITH_TOC),
+    t = p.locator('#mobile-sidebar-toggle')
   note((await t.getAttribute('aria-expanded')) === 'false', 'aria-expanded=false when closed')
-  await t.click(); await p.waitForTimeout(250)
+  await t.click()
+  await p.waitForTimeout(250)
   note((await t.getAttribute('aria-expanded')) === 'true', 'aria-expanded=true when open')
-  await p.keyboard.press('Escape'); await p.waitForTimeout(250)
+  await p.keyboard.press('Escape')
+  await p.waitForTimeout(250)
   note((await t.getAttribute('aria-expanded')) === 'false', 'aria-expanded back to false after Escape')
   await p.close()
 }
 // focus in, and back — asserted only after confirming it actually entered
 {
   const p = await page(WITH_TOC)
-  await p.locator('#mobile-sidebar-toggle').click(); await p.waitForTimeout(300)
+  await p.locator('#mobile-sidebar-toggle').click()
+  await p.waitForTimeout(300)
   const inside = await p.evaluate(() => !!document.getElementById('mobile-sidebar')?.contains(document.activeElement))
   note(inside, 'focus moves into the sidebar drawer on open')
   if (inside) {
-    await p.keyboard.press('Escape'); await p.waitForTimeout(300)
+    await p.keyboard.press('Escape')
+    await p.waitForTimeout(300)
     note(await p.evaluate(() => document.activeElement?.id === 'mobile-sidebar-toggle'), 'focus returns to the toggle')
   } else fails.push('focus return untestable — focus never entered')
   await p.close()
@@ -76,7 +87,8 @@ const openState = (p, id, closedClass) => p.evaluate(([i, c]) => {
   const reachable = await p.evaluate(() => {
     const a = document.getElementById('mobile-sidebar')?.querySelector('a')
     if (!a) return false
-    a.focus(); return document.activeElement === a
+    a.focus()
+    return document.activeElement === a
   })
   note(!reachable, 'closed drawer is not focusable')
   await p.close()
@@ -84,15 +96,21 @@ const openState = (p, id, closedClass) => p.evaluate(([i, c]) => {
 // scroll lock released across the breakpoint
 {
   const p = await page(WITH_TOC)
-  await p.locator('#mobile-sidebar-toggle').click(); await p.waitForTimeout(250)
-  await p.setViewportSize({ width: 1440, height: 900 }); await p.waitForTimeout(400)
-  note(!(await p.evaluate(() => document.body.style.overflow === 'hidden')), 'scroll lock released when resized to desktop')
+  await p.locator('#mobile-sidebar-toggle').click()
+  await p.waitForTimeout(250)
+  await p.setViewportSize({ width: 1440, height: 900 })
+  await p.waitForTimeout(400)
+  note(
+    !(await p.evaluate(() => document.body.style.overflow === 'hidden')),
+    'scroll lock released when resized to desktop',
+  )
   await p.close()
 }
 // with one drawer open, the toolbar behind it is not reachable
 {
   const p = await page(WITH_TOC)
-  await p.locator('#mobile-sidebar-toggle').click(); await p.waitForTimeout(300)
+  await p.locator('#mobile-sidebar-toggle').click()
+  await p.waitForTimeout(300)
   note(await openState(p, 'mobile-sidebar', '-translate-x-full'), 'sidebar opened (precondition)')
   const covered = await p.evaluate(() => {
     const btn = document.getElementById('mobile-toc-toggle')
@@ -106,7 +124,8 @@ const openState = (p, id, closedClass) => p.evaluate(([i, c]) => {
 // and if both are ever opened programmatically, the first closes
 {
   const p = await page(WITH_TOC)
-  await p.locator('#mobile-sidebar-toggle').click(); await p.waitForTimeout(250)
+  await p.locator('#mobile-sidebar-toggle').click()
+  await p.waitForTimeout(250)
   note(await openState(p, 'mobile-sidebar', '-translate-x-full'), 'sidebar opened (precondition)')
   await p.evaluate(() => document.getElementById('mobile-toc-toggle').click())
   await p.waitForTimeout(300)
@@ -120,12 +139,20 @@ const openState = (p, id, closedClass) => p.evaluate(([i, c]) => {
 {
   const p = await page(NO_TOC)
   note((await p.locator('#mobile-toc-toggle').count()) === 0, 'no contents button without headings')
-  await p.locator('#mobile-sidebar-toggle').click(); await p.waitForTimeout(250)
+  await p.locator('#mobile-sidebar-toggle').click()
+  await p.waitForTimeout(250)
   note(await openState(p, 'mobile-sidebar', '-translate-x-full'), 'sidebar opens on a page with no contents')
   await p.close()
 }
 // breakpoint
-for (const [w, want] of [[360, true], [390, true], [768, true], [1023, true], [1024, false], [1440, false]]) {
+for (const [w, want] of [
+  [360, true],
+  [390, true],
+  [768, true],
+  [1023, true],
+  [1024, false],
+  [1440, false],
+]) {
   const p = await page(WITH_TOC, w)
   const settings = p.locator('[data-context-settings-toggle]')
   if (await settings.isVisible()) await settings.click()
@@ -141,19 +168,29 @@ for (const path of ['/go/latest/reference/', '/py/stable/reference/libtmux-serve
   const contents = p.locator('#api-nav')
   note(await trigger.isVisible(), `${path}: phone product picker is outside the closed drawer`)
   const headingBefore = await p.locator('main h1').first().boundingBox()
-  note(headingBefore && headingBefore.y >= 0 && headingBefore.y + headingBefore.height <= p.viewportSize().height,
-    `${path}: phone heading is fully visible above the fold`)
-  note((await p.locator('[data-documentation-context]').boundingBox())?.height <= 58,
-    `${path}: documentation context stays compact`)
+  note(
+    headingBefore && headingBefore.y >= 0 && headingBefore.y + headingBefore.height <= p.viewportSize().height,
+    `${path}: phone heading is fully visible above the fold`,
+  )
+  note(
+    (await p.locator('[data-documentation-context]').boundingBox())?.height <= 58,
+    `${path}: documentation context stays compact`,
+  )
   await trigger.click()
-  note((await p.locator('main h1').first().boundingBox())?.y === headingBefore?.y,
-    `${path}: opening the picker does not move the heading`)
-  const workspace = menu.locator('[data-surface-group]').filter({ has: p.locator('summary strong', { hasText: /^Workspace Manager$/ }) })
+  note(
+    (await p.locator('main h1').first().boundingBox())?.y === headingBefore?.y,
+    `${path}: opening the picker does not move the heading`,
+  )
+  const workspace = menu
+    .locator('[data-surface-group]')
+    .filter({ has: p.locator('summary strong', { hasText: /^Workspace Manager$/ }) })
   await workspace.locator(':scope > summary').click()
   const home = workspace.getByRole('link', { name: 'Home', exact: true })
   note(await home.isVisible(), `${path}: workspace remains reachable from the product picker`)
-  note(await home.getAttribute('href') === new URL(`${BASE}${path.replace(/reference\/.*$/, 'workspace/')}`).pathname,
-    `${path}: workspace keeps the current port and version`)
+  note(
+    (await home.getAttribute('href')) === new URL(`${BASE}${path.replace(/reference\/.*$/, 'workspace/')}`).pathname,
+    `${path}: workspace keeps the current port and version`,
+  )
   await p.keyboard.press('Escape')
   note(!(await menu.evaluate((el) => el.open)), `${path}: Escape closes the picker`)
   await p.locator('[data-api-nav-toggle]').click()
@@ -168,15 +205,22 @@ for (const path of ['/go/latest/reference/', '/py/stable/reference/libtmux-serve
   await p.setViewportSize({ width: 390, height: 800 })
   await contents.waitFor({ state: 'hidden' })
   note(await trigger.isVisible(), `${path}: narrowing keeps the product picker`)
-  note(await p.locator('[data-api-nav-toggle]').evaluate((element) => document.activeElement === element),
-    `${path}: narrowing focused navigation returns focus to its toggle`)
+  note(
+    await p.locator('[data-api-nav-toggle]').evaluate((element) => document.activeElement === element),
+    `${path}: narrowing focused navigation returns focus to its toggle`,
+  )
   const heading = p.locator('main h1').first()
-  await heading.evaluate((element) => { element.tabIndex = -1; element.focus() })
+  await heading.evaluate((element) => {
+    element.tabIndex = -1
+    element.focus()
+  })
   for (const width of [1440, 768, 390]) {
     await p.setViewportSize({ width, height: 900 })
     await p.waitForFunction((narrow) => document.querySelector('#api-nav').inert === narrow, width < 896)
-    note(await heading.evaluate((element) => document.activeElement === element),
-      `${path}: resizing to ${width}px preserves focus in the content`)
+    note(
+      await heading.evaluate((element) => document.activeElement === element),
+      `${path}: resizing to ${width}px preserves focus in the content`,
+    )
   }
   await p.close()
 }
@@ -188,8 +232,10 @@ for (const width of [390, 1440]) {
   await results.locator('a').first().waitFor()
   const box = await results.boundingBox()
   const dialog = await p.locator('#search-modal').boundingBox()
-  note(box && dialog && box.y + box.height <= dialog.y + dialog.height,
-    `search results fit inside the dialog at ${width}px`)
+  note(
+    box && dialog && box.y + box.height <= dialog.y + dialog.height,
+    `search results fit inside the dialog at ${width}px`,
+  )
   if (box) {
     await p.mouse.move(box.x + box.width / 2, box.y + Math.min(50, box.height / 2))
     await p.mouse.wheel(0, 500)
diff --git a/site/scripts/check-native-layout.mjs b/site/scripts/check-native-layout.mjs
index ab7da1e72..bdbfd3542 100644
--- a/site/scripts/check-native-layout.mjs
+++ b/site/scripts/check-native-layout.mjs
@@ -5,16 +5,19 @@ export async function checkNativeHeader(page) {
   assert.equal(await page.locator('[data-lt-shell]').count(), 0)
   assert.equal(await page.locator('[data-page-port-switcher]').count(), 1)
   const controls = await page.locator('.site-header').evaluate((container) => {
-    const links = [...container.querySelectorAll('summary, a, button')]
-      .filter((link) => link.checkVisibility({ visibilityProperty: true }))
+    const links = [...container.querySelectorAll('summary, a, button')].filter((link) =>
+      link.checkVisibility({ visibilityProperty: true }),
+    )
     const bounds = links.map((link) => link.getBoundingClientRect())
     return {
       count: links.length,
       visible: bounds.every((rect) => rect.width > 0 && rect.height > 0 && rect.left >= 0 && rect.right <= innerWidth),
-      covered: links.filter((link, i) => {
-        const rect = bounds[i]
-        return !link.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2))
-      }).map((link) => link.getAttribute('aria-label') ?? link.textContent.trim()),
+      covered: links
+        .filter((link, i) => {
+          const rect = bounds[i]
+          return !link.contains(document.elementFromPoint(rect.x + rect.width / 2, rect.y + rect.height / 2))
+        })
+        .map((link) => link.getAttribute('aria-label') ?? link.textContent.trim()),
     }
   })
   assert(controls.count >= 3, 'Native page, search and menu controls remain available')
@@ -25,7 +28,9 @@ export async function checkNativeHeader(page) {
 /** Delay enhancement until the initial article and navigation can be inspected. */
 export async function checkNativeFirstPaint(page, url) {
   let release
-  const delayedScript = new Promise((resolve) => { release = resolve })
+  const delayedScript = new Promise((resolve) => {
+    release = resolve
+  })
   const pendingRoutes = []
   const routeScript = (route) => {
     const pending = delayedScript.then(() => route.continue())
@@ -37,17 +42,31 @@ export async function checkNativeFirstPaint(page, url) {
     const response = await page.goto(url, { waitUntil: 'commit' })
     assert(response?.ok(), `Native page: HTTP ${response?.status()}`)
     await page.locator('article h1').waitFor({ state: 'visible' })
-    assert(await page.locator('.site-header').isVisible(), 'Compiled native header is visible before enhancement arrives')
-    assert.equal(await page.locator('[data-page-port-switcher]').getAttribute('data-enhanced'), null,
-      'Native navigation is visible before enhancement')
+    assert(
+      await page.locator('.site-header').isVisible(),
+      'Compiled native header is visible before enhancement arrives',
+    )
+    assert.equal(
+      await page.locator('[data-page-port-switcher]').getAttribute('data-enhanced'),
+      null,
+      'Native navigation is visible before enhancement',
+    )
     await checkNativeHeader(page)
     const initial = await page.locator('article h1').boundingBox()
-    await page.evaluate(() => { window.__initialNativeHeader = document.querySelector('.site-header') })
+    await page.evaluate(() => {
+      window.__initialNativeHeader = document.querySelector('.site-header')
+    })
     release()
     await page.waitForLoadState('networkidle')
-    assert.deepEqual(await page.locator('article h1').boundingBox(), initial, `Native first paint stays still at ${page.viewportSize().width}px`)
-    assert(await page.evaluate(() => window.__initialNativeHeader === document.querySelector('.site-header')),
-      'Enhancement preserves the initial header')
+    assert.deepEqual(
+      await page.locator('article h1').boundingBox(),
+      initial,
+      `Native first paint stays still at ${page.viewportSize().width}px`,
+    )
+    assert(
+      await page.evaluate(() => window.__initialNativeHeader === document.querySelector('.site-header')),
+      'Enhancement preserves the initial header',
+    )
     assert.equal(await page.locator('.site-header').count(), 1)
   } finally {
     release()
diff --git a/site/scripts/check-native-navigation.mjs b/site/scripts/check-native-navigation.mjs
index f1b11371d..ab9fb676b 100644
--- a/site/scripts/check-native-navigation.mjs
+++ b/site/scripts/check-native-navigation.mjs
@@ -9,9 +9,12 @@ const browser = await chromium.launch({ channel: process.env.LIBTMUX_DOCS_BROWSE
 
 async function openNativeLink(page, suffix) {
   const opener = page.locator('#mobile-sidebar-toggle')
-  if (await opener.isVisible() && !await page.locator('#__navigation').isChecked()) await opener.click()
+  if ((await opener.isVisible()) && !(await page.locator('#__navigation').isChecked())) await opener.click()
   const links = page.locator('.sidebar-tree a[href]')
-  const index = await links.evaluateAll((links, suffix) => links.findIndex((link) => link.pathname.endsWith(suffix)), suffix)
+  const index = await links.evaluateAll(
+    (links, suffix) => links.findIndex((link) => link.pathname.endsWith(suffix)),
+    suffix,
+  )
   assert(index >= 0, `No native sidebar destination: ${suffix}`)
   const link = links.nth(index)
   await link.evaluate((link) => {
@@ -36,7 +39,9 @@ async function checkMetadata(page) {
       title: doc.title,
       canonical: doc.querySelector('link[rel=canonical]')?.getAttribute('href'),
       ports: doc.querySelector('[data-native-page-ports]')?.textContent,
-      markdown: [...doc.querySelectorAll('footer a[href]')].find((link) => link.textContent.trim() === 'Markdown')?.getAttribute('href'),
+      markdown: [...doc.querySelectorAll('footer a[href]')]
+        .find((link) => link.textContent.trim() === 'Markdown')
+        ?.getAttribute('href'),
       source: doc.querySelector('footer code')?.textContent,
     })
     return { actual: read(document), expected: read(fresh) }
@@ -47,13 +52,24 @@ async function checkMetadata(page) {
 }
 
 try {
-  for (const [width, colorScheme, reducedMotion] of [[1027, 'light', 'no-preference'], [390, 'dark', 'reduce']]) {
-    const context = await browser.newContext({ viewport: { width, height: 900 }, colorScheme, reducedMotion, permissions: ['clipboard-read', 'clipboard-write'] })
+  for (const [width, colorScheme, reducedMotion] of [
+    [1027, 'light', 'no-preference'],
+    [390, 'dark', 'reduce'],
+  ]) {
+    const context = await browser.newContext({
+      viewport: { width, height: 900 },
+      colorScheme,
+      reducedMotion,
+      permissions: ['clipboard-read', 'clipboard-write'],
+    })
     try {
       const page = await context.newPage()
-      const errors = [], documents = []
+      const errors = [],
+        documents = []
       page.on('pageerror', (error) => errors.push(String(error)))
-      page.on('request', (request) => { if (request.isNavigationRequest()) documents.push(request.url()) })
+      page.on('request', (request) => {
+        if (request.isNavigationRequest()) documents.push(request.url())
+      })
       await page.goto(root)
       await page.evaluate(() => document.fonts.ready)
       const identity = await page.evaluate(() => {
@@ -64,11 +80,18 @@ try {
         return window.nativeNavigationIdentity
       })
       await openNativeLink(page, 'internals/api/libtmux._internal.constants/')
-      assert.equal(await page.evaluate(() => window.nativeNavigationIdentity), identity, 'Native link reloaded the document')
+      assert.equal(
+        await page.evaluate(() => window.nativeNavigationIdentity),
+        identity,
+        'Native link reloaded the document',
+      )
       await checkMetadata(page)
       const scroll = await page.evaluate(() => {
         const sidebar = document.querySelector('.sidebar-scroll')
-        return { actual: sidebar.scrollTop, expected: Math.min(window.nativeSidebarScroll, sidebar.scrollHeight - sidebar.clientHeight) }
+        return {
+          actual: sidebar.scrollTop,
+          expected: Math.min(window.nativeSidebarScroll, sidebar.scrollHeight - sidebar.clientHeight),
+        }
       })
       assert(Math.abs(scroll.actual - scroll.expected) <= 1, `Sidebar position changed: ${JSON.stringify(scroll)}`)
       assert.equal(await page.locator('#__navigation').isChecked(), false, 'A page navigation left the drawer open')
@@ -76,7 +99,9 @@ try {
       await checkMetadata(page)
       await page.locator('dt[id="libtmux._internal.query_list.QueryList"]').hover()
       await page.locator('a.headerlink[href="#libtmux._internal.query_list.QueryList"]:visible').click()
-      await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[aria-current]')?.hash === location.hash)
+      await page.waitForFunction(
+        () => document.querySelector('[data-page-port-switcher] a[aria-current]')?.hash === location.hash,
+      )
       const target = await page.locator('dt[id="libtmux._internal.query_list.QueryList"]').boundingBox()
       const header = await page.locator('.site-header').boundingBox()
       assert(target.y >= header.y + header.height - 1 && target.y < 900, 'Client fragment arrival is hidden')
@@ -87,16 +112,26 @@ try {
       await page.goBack()
       await page.waitForURL(root)
       await checkMetadata(page)
-      await page.waitForFunction(() => document.querySelectorAll('.copybtn').length === document.querySelectorAll('div.highlight pre').length)
+      await page.waitForFunction(
+        () => document.querySelectorAll('.copybtn').length === document.querySelectorAll('div.highlight pre').length,
+      )
       const copy = page.locator('div.highlight .copybtn').first()
       const expected = (await page.locator('div.highlight pre').first().innerText()).replace(/^\$ /, '').trimEnd()
       await copy.click()
-      assert.equal(await page.evaluate(() => navigator.clipboard.readText()), expected, 'Native copy changed after Back navigation')
+      assert.equal(
+        await page.evaluate(() => navigator.clipboard.readText()),
+        expected,
+        'Native copy changed after Back navigation',
+      )
       assert.equal(await copy.getAttribute('data-tooltip'), 'Copied!')
       await page.goForward()
       await page.waitForURL(`${root}internals/api/libtmux._internal.constants/`)
       await checkMetadata(page)
-      assert.equal(await page.evaluate(() => window.nativeNavigationIdentity), identity, 'History reloaded the document')
+      assert.equal(
+        await page.evaluate(() => window.nativeNavigationIdentity),
+        identity,
+        'History reloaded the document',
+      )
       assert.deepEqual(documents, [root], 'A native transition made a document navigation request')
       assert.deepEqual(errors, [], 'Native transitions threw browser errors')
       assert.equal(await page.evaluate(() => document.body.dataset.theme), colorScheme)
@@ -104,25 +139,48 @@ try {
       await page.locator('[data-surface-picker] > summary').click()
       await page.locator(`[data-surface-picker] a[href="${new URL(base).pathname}/py/${version}/reference/"]`).click()
       await page.waitForURL(`${base}/py/${version}/reference/`)
-      assert.equal(await page.evaluate(() => window.nativeNavigationIdentity), undefined, 'A different shell reused native global scripts')
-      console.log(`Native navigation: ${width}px ${colorScheme} ${reducedMotion}, client links, metadata, anchors, history, copy, theme, and boundary PASS`)
-    } finally { await context.close() }
+      assert.equal(
+        await page.evaluate(() => window.nativeNavigationIdentity),
+        undefined,
+        'A different shell reused native global scripts',
+      )
+      console.log(
+        `Native navigation: ${width}px ${colorScheme} ${reducedMotion}, client links, metadata, anchors, history, copy, theme, and boundary PASS`,
+      )
+    } finally {
+      await context.close()
+    }
   }
   for (const javaScriptEnabled of [false, true]) {
-    const context = await browser.newContext({ javaScriptEnabled, viewport: { width: 1027, height: 1450 }, reducedMotion: 'reduce' })
+    const context = await browser.newContext({
+      javaScriptEnabled,
+      viewport: { width: 1027, height: 1450 },
+      reducedMotion: 'reduce',
+    })
     try {
       const page = await context.newPage()
       await page.goto(root)
       await page.locator('#mobile-toc-toggle').click()
       const links = page.locator('#native-toc a[href^="#"]').filter({ hasNotText: /^libtmux$/ })
-      assert.deepEqual((await links.allTextContents()).map((text) => text.trim()), ['Install', 'At a glance', 'Know where you’re running', 'Testing'])
+      assert.deepEqual(
+        (await links.allTextContents()).map((text) => text.trim()),
+        ['Install', 'At a glance', 'Know where you’re running', 'Testing'],
+      )
       await links.first().click({ trial: true })
       await page.goto(`${root}genindex/`)
       assert.equal(await page.locator('#mobile-toc-toggle').count(), 0, 'An empty native index offers Contents')
       assert.equal(await page.locator('#native-toc').isVisible(), false)
       await page.locator('#__navigation').focus()
       await page.keyboard.press('Tab')
-      assert.notEqual(await page.evaluate(() => document.activeElement.id), '__toc', 'Empty Contents remains a keyboard stop')
-    } finally { await context.close() }
+      assert.notEqual(
+        await page.evaluate(() => document.activeElement.id),
+        '__toc',
+        'Empty Contents remains a keyboard stop',
+      )
+    } finally {
+      await context.close()
+    }
   }
-} finally { await browser.close() }
+} finally {
+  await browser.close()
+}
diff --git a/site/scripts/check-native-shell.mjs b/site/scripts/check-native-shell.mjs
index 7f1a9fdb3..972aed555 100644
--- a/site/scripts/check-native-shell.mjs
+++ b/site/scripts/check-native-shell.mjs
@@ -8,18 +8,37 @@ const version = process.argv.find((arg) => arg.startsWith('--version='))?.slice(
 const browser = await chromium.launch({ channel: process.env.LIBTMUX_DOCS_BROWSER_CHANNEL })
 try {
   for (const javaScriptEnabled of [true, false]) {
-    const context = await browser.newContext({ javaScriptEnabled, reducedMotion: 'reduce', viewport: { width: 390, height: 900 } })
+    const context = await browser.newContext({
+      javaScriptEnabled,
+      reducedMotion: 'reduce',
+      viewport: { width: 390, height: 900 },
+    })
     try {
       const page = await context.newPage()
       const id = 'libtmux._internal.query_list.QueryList'
-      await page.goto(`${base}/py/${version}/api/internals/api/libtmux._internal.query_list/#${id}`, { waitUntil: 'load' })
+      await page.goto(`${base}/py/${version}/api/internals/api/libtmux._internal.query_list/#${id}`, {
+        waitUntil: 'load',
+      })
       await page.evaluate(() => document.fonts.ready)
       const motion = await page.evaluate((id) => {
         const target = document.getElementById(id).getBoundingClientRect()
-        return { behavior: getComputedStyle(document.documentElement).scrollBehavior, top: target.top, bottom: target.bottom, header: document.querySelector('.site-header').getBoundingClientRect().bottom, viewport: innerHeight }
+        return {
+          behavior: getComputedStyle(document.documentElement).scrollBehavior,
+          top: target.top,
+          bottom: target.bottom,
+          header: document.querySelector('.site-header').getBoundingClientRect().bottom,
+          viewport: innerHeight,
+        }
       }, id)
-      assert.equal(motion.behavior, 'auto', `Reduced motion with JavaScript ${javaScriptEnabled}: native fragment navigation animates`)
-      assert(motion.top >= motion.header - 1 && motion.bottom <= motion.viewport, `Reduced motion with JavaScript ${javaScriptEnabled}: the deep-link destination is not visible below the header`)
+      assert.equal(
+        motion.behavior,
+        'auto',
+        `Reduced motion with JavaScript ${javaScriptEnabled}: native fragment navigation animates`,
+      )
+      assert(
+        motion.top >= motion.header - 1 && motion.bottom <= motion.viewport,
+        `Reduced motion with JavaScript ${javaScriptEnabled}: the deep-link destination is not visible below the header`,
+      )
     } finally {
       await context.close()
     }
@@ -41,78 +60,151 @@ try {
       await page.evaluate(() => scrollTo(0, 0))
       const menu = page.locator('[data-page-port-switcher]')
       await menu.waitFor()
-      await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'))
-      assert([...loaded].some((url) => url.includes(`/${version}/_astro/`) && url.endsWith('.css')), 'Compiled native CSS did not load')
-      assert([...loaded].some((url) => url.includes(`/${version}/_astro/DocumentationScript.`)), 'Compiled shared navigation did not load')
-      assert(![...loaded].some((url) => /(?:\/_shell\/shell\.js|\/spa-nav\.js|\/scripts\/furo\.js)/.test(url)), 'A competing native shell/router loaded')
-      assert(await page.locator('meta[name="astro-view-transitions-enabled"]').count(), 'Native pages have no shared client router')
-      assert.equal(await page.locator('[data-surface-picker] .surface-current small').textContent(), 'Upstream reference')
-      assert.deepEqual((await page.locator('[data-surface-picker] a[aria-current]').allTextContents()).map((text) => text.replaceAll(/\s|✓/g, '')), ['Upstreamreference'])
+      await page.waitForFunction(() =>
+        document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'),
+      )
+      assert(
+        [...loaded].some((url) => url.includes(`/${version}/_astro/`) && url.endsWith('.css')),
+        'Compiled native CSS did not load',
+      )
+      assert(
+        [...loaded].some((url) => url.includes(`/${version}/_astro/DocumentationScript.`)),
+        'Compiled shared navigation did not load',
+      )
+      assert(
+        ![...loaded].some((url) => /(?:\/_shell\/shell\.js|\/spa-nav\.js|\/scripts\/furo\.js)/.test(url)),
+        'A competing native shell/router loaded',
+      )
+      assert(
+        await page.locator('meta[name="astro-view-transitions-enabled"]').count(),
+        'Native pages have no shared client router',
+      )
+      assert.equal(
+        await page.locator('[data-surface-picker] .surface-current small').textContent(),
+        'Upstream reference',
+      )
+      assert.deepEqual(
+        (await page.locator('[data-surface-picker] a[aria-current]').allTextContents()).map((text) =>
+          text.replaceAll(/\s|✓/g, ''),
+        ),
+        ['Upstreamreference'],
+      )
       await menu.locator('summary').focus()
       await page.keyboard.press('Enter')
       const bounds = await menu.evaluate((details) => {
         const current = details.querySelector('summary').getBoundingClientRect()
         const panel = details.querySelector('[data-picker-panel]')
         const rect = panel.getBoundingClientRect()
-        const covered = [...panel.querySelectorAll('[data-picker-option]')].filter((item) => {
-          if (!item.checkVisibility()) return false
-          const row = item.getBoundingClientRect()
-          const y = row.top + row.height / 2
-          if (y <= rect.top || y >= rect.bottom) return false
-          return !item.contains(document.elementFromPoint(row.left + row.width / 2, y))
-        }).map((item) => item.textContent.trim())
-        return { open: details.open, controlHeight: current.height, left: rect.left, right: rect.right, viewport: innerWidth, covered }
+        const covered = [...panel.querySelectorAll('[data-picker-option]')]
+          .filter((item) => {
+            if (!item.checkVisibility()) return false
+            const row = item.getBoundingClientRect()
+            const y = row.top + row.height / 2
+            if (y <= rect.top || y >= rect.bottom) return false
+            return !item.contains(document.elementFromPoint(row.left + row.width / 2, y))
+          })
+          .map((item) => item.textContent.trim())
+        return {
+          open: details.open,
+          controlHeight: current.height,
+          left: rect.left,
+          right: rect.right,
+          viewport: innerWidth,
+          covered,
+        }
       })
       const context = `${width}px ${colorScheme}`
       assert(bounds.open, `${context}: keyboard did not open the port dropdown`)
-      assert(bounds.controlHeight === 36 && bounds.left >= 0 && bounds.right <= bounds.viewport, `${context}: native dropdown has the wrong size or leaves the viewport`)
+      assert(
+        bounds.controlHeight === 36 && bounds.left >= 0 && bounds.right <= bounds.viewport,
+        `${context}: native dropdown has the wrong size or leaves the viewport`,
+      )
       assert.deepEqual(bounds.covered, [], `${context}: native content covers port menu entries`)
       await page.keyboard.press('Escape')
-      assert.equal(await menu.evaluate((details) => details.open), false, `${context}: keyboard did not close the port dropdown`)
+      assert.equal(
+        await menu.evaluate((details) => details.open),
+        false,
+        `${context}: keyboard did not close the port dropdown`,
+      )
     }
   }
-  await page.evaluate(() => { location.hash = 'sessions' })
-  await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'))
+  await page.evaluate(() => {
+    location.hash = 'sessions'
+  })
+  await page.waitForFunction(() =>
+    document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session/"]'),
+  )
   const picker = page.locator('[data-page-port-switcher]')
   await picker.locator('summary').click()
   await picker.locator('[data-picker-search]').fill('TypeScript')
-  await page.evaluate(() => { location.hash = 'libtmux.Session.windows' })
-  await page.waitForFunction(() => document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session-windows/"]'))
-  assert.deepEqual(await picker.locator('[data-picker-option]').evaluateAll((options) => options
-    .filter((option) => option.checkVisibility({ visibilityProperty: true }))
-    .map((option) => option.dataset.port)), ['ts'], 'Fragment navigation preserves the active language filter')
+  await page.evaluate(() => {
+    location.hash = 'libtmux.Session.windows'
+  })
+  await page.waitForFunction(() =>
+    document.querySelector('[data-page-port-switcher] a[href$="/ts/latest/reference/session-session-windows/"]'),
+  )
+  assert.deepEqual(
+    await picker
+      .locator('[data-picker-option]')
+      .evaluateAll((options) =>
+        options
+          .filter((option) => option.checkVisibility({ visibilityProperty: true }))
+          .map((option) => option.dataset.port),
+      ),
+    ['ts'],
+    'Fragment navigation preserves the active language filter',
+  )
   await page.keyboard.press('Escape')
   await page.evaluate(() => scrollTo(0, 0))
-  for (const [input, button] of [['__navigation', 'mobile-sidebar-toggle'], ['__toc', 'mobile-toc-toggle']]) {
+  for (const [input, button] of [
+    ['__navigation', 'mobile-sidebar-toggle'],
+    ['__toc', 'mobile-toc-toggle'],
+  ]) {
     await page.setViewportSize({ width: 641, height: 900 })
     const opener = page.locator(`#${button}`)
     await opener.focus()
     await page.keyboard.press('Enter')
     assert(await page.locator(`#${input}`).isChecked(), `${button}: keyboard opens the drawer`)
-    assert(await page.evaluate((id) => document.getElementById(id).contains(document.activeElement),
-      input === '__navigation' ? 'native-navigation' : 'native-toc'), `${button}: focus moves into the drawer`)
-    await page.waitForFunction((id) => {
-      const drawer = document.getElementById(id)
-      const rect = drawer.getBoundingClientRect()
-      if (rect.left < 0 || rect.right > innerWidth) return false
-      const link = [...drawer.querySelectorAll('a[href]')].find((link) => link.checkVisibility())
-      if (!link) return false
-      const bounds = link.getBoundingClientRect()
-      return link.contains(document.elementFromPoint(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2))
-    }, input === '__navigation' ? 'native-navigation' : 'native-toc')
+    assert(
+      await page.evaluate(
+        (id) => document.getElementById(id).contains(document.activeElement),
+        input === '__navigation' ? 'native-navigation' : 'native-toc',
+      ),
+      `${button}: focus moves into the drawer`,
+    )
+    await page.waitForFunction(
+      (id) => {
+        const drawer = document.getElementById(id)
+        const rect = drawer.getBoundingClientRect()
+        if (rect.left < 0 || rect.right > innerWidth) return false
+        const link = [...drawer.querySelectorAll('a[href]')].find((link) => link.checkVisibility())
+        if (!link) return false
+        const bounds = link.getBoundingClientRect()
+        return link.contains(document.elementFromPoint(bounds.x + bounds.width / 2, bounds.y + bounds.height / 2))
+      },
+      input === '__navigation' ? 'native-navigation' : 'native-toc',
+    )
     await page.keyboard.press('Control+k')
     await page.locator('dialog[open]').waitFor()
     await page.keyboard.press('Escape')
     await page.waitForFunction(() => !document.querySelector('dialog[open]'))
     assert(await page.locator(`#${input}`).isChecked(), `${button}: dismissing search preserves the underlying drawer`)
     await page.setViewportSize({ width: 380, height: 900 })
-    await page.waitForFunction(() => document.querySelector('[data-documentation-context]').hasAttribute('data-settings-open'))
+    await page.waitForFunction(() =>
+      document.querySelector('[data-documentation-context]').hasAttribute('data-settings-open'),
+    )
     assert(await opener.isVisible(), `${button}: resizing keeps the drawer opener visible`)
     await page.keyboard.press('Escape')
     assert.equal(await page.locator(`#${input}`).isChecked(), false, `${button}: Escape closes the drawer`)
-    assert.equal(await page.evaluate(() => document.activeElement?.id), button, `${button}: Escape returns focus to the visible opener`)
+    assert.equal(
+      await page.evaluate(() => document.activeElement?.id),
+      button,
+      `${button}: Escape returns focus to the visible opener`,
+    )
   }
-  console.log('Native shell: reduced-motion deep links with and without JavaScript, stable first paint, reachable scrolled header, assets, keyboard, unobscured dropdowns at 1440/1062/768/688/641/390px in light/dark, filtered class/member equivalents, and drawer focus across resizing passed')
+  console.log(
+    'Native shell: reduced-motion deep links with and without JavaScript, stable first paint, reachable scrolled header, assets, keyboard, unobscured dropdowns at 1440/1062/768/688/641/390px in light/dark, filtered class/member equivalents, and drawer focus across resizing passed',
+  )
 } finally {
   await browser.close()
 }
diff --git a/site/scripts/check-navigation.mjs b/site/scripts/check-navigation.mjs
index adf3e18f0..d99a42271 100644
--- a/site/scripts/check-navigation.mjs
+++ b/site/scripts/check-navigation.mjs
@@ -12,7 +12,9 @@ export async function checkNavigationBeforeAnalytics(browser, base) {
   const url = `${base}/tmux/concepts/server-session-window-pane/`
   const analytics = `${base}/pending-analytics.js`
   let release
-  const pending = new Promise((resolve) => { release = resolve })
+  const pending = new Promise((resolve) => {
+    release = resolve
+  })
   let requested = false
   let completed = false
   await page.route(analytics, async (route) => {
@@ -25,8 +27,10 @@ export async function checkNavigationBeforeAnalytics(browser, base) {
     const response = await route.fetch()
     const body = await response.text()
     assert(body.includes('</body>'), 'The real documentation page has a body')
-    await route.fulfill({ response, body: body.replace('</body>',
-      `<script type="module" src="${analytics}"></script></body>`) })
+    await route.fulfill({
+      response,
+      body: body.replace('</body>', `<script type="module" src="${analytics}"></script></body>`),
+    })
   })
   try {
     await page.goto(url, { waitUntil: 'commit' })
@@ -47,11 +51,17 @@ export async function checkNavigationBeforeAnalytics(browser, base) {
           observer.observe(root, { attributes: true, attributeFilter: ['class'] })
         })
       }
-      return { visibility: getComputedStyle(document.body).visibility,
-        suppressed: root.classList.contains('link-hints-suppressed') }
+      return {
+        visibility: getComputedStyle(document.body).visibility,
+        suppressed: root.classList.contains('link-hints-suppressed'),
+      }
     })
     assert.equal(readiness.suppressed, false, 'Actual icon readiness succeeds without the frozen fallback timer')
-    assert.equal(readiness.visibility, 'visible', 'Loaded fonts and icons reveal the page while analytics and the fallback timer are still pending')
+    assert.equal(
+      readiness.visibility,
+      'visible',
+      'Loaded fonts and icons reveal the page while analytics and the fallback timer are still pending',
+    )
     await page.clock.resume()
     const picker = page.locator('[data-surface-picker][data-enhanced]')
     await picker.waitFor({ state: 'visible' })
@@ -62,7 +72,10 @@ export async function checkNavigationBeforeAnalytics(browser, base) {
     assert(await search.evaluate((input) => input === document.activeElement), 'Picker search receives keyboard focus')
     await page.keyboard.press('Escape')
     assert.equal(await picker.getAttribute('open'), null, 'Escape closes the picker')
-    assert(await picker.locator(':scope > summary').evaluate((node) => node === document.activeElement), 'Picker returns focus')
+    assert(
+      await picker.locator(':scope > summary').evaluate((node) => node === document.activeElement),
+      'Picker returns focus',
+    )
     const drawer = page.locator('#mobile-sidebar-toggle')
     await drawer.click()
     assert.equal(await drawer.getAttribute('aria-expanded'), 'true', 'Mobile navigation opens')
@@ -70,7 +83,11 @@ export async function checkNavigationBeforeAnalytics(browser, base) {
     assert.equal(await drawer.getAttribute('aria-expanded'), 'false', 'Escape closes mobile navigation')
     assert(await drawer.evaluate((node) => node === document.activeElement), 'Mobile navigation returns focus')
     assert(requested && !completed, 'Navigation works while the injected analytics module is still pending')
-    assert.equal(await page.evaluate(() => document.readyState), 'interactive', 'Navigation does not await document load')
+    assert.equal(
+      await page.evaluate(() => document.readyState),
+      'interactive',
+      'Navigation does not await document load',
+    )
     console.log('Navigation: picker and mobile drawer work before pending analytics completes')
   } finally {
     release()
@@ -83,16 +100,25 @@ async function checkNoticeAlignment(page, centered = false) {
   const { noticeLeft, contentLeft, artworkLeft } = await page.evaluate((landing) => {
     const badge = document.querySelector('.prerelease-notice__badge')
     const content = document.querySelector(landing ? 'main' : '.site-header__mark')
-    const artwork = document.querySelector('[data-documentation-context] [data-surface-picker] > summary .surface-artwork')
+    const artwork = document.querySelector(
+      '[data-documentation-context] [data-surface-picker] > summary .surface-artwork',
+    )
     return {
       noticeLeft: badge.getBoundingClientRect().left,
-      contentLeft: content.getBoundingClientRect().left + (landing ? parseFloat(getComputedStyle(content).paddingLeft) : 0),
+      contentLeft:
+        content.getBoundingClientRect().left + (landing ? parseFloat(getComputedStyle(content).paddingLeft) : 0),
       artworkLeft: artwork?.getBoundingClientRect().left,
     }
   }, centered)
-  assert(Math.abs(noticeLeft - contentLeft) <= 1, `${page.url()}: notice at ${noticeLeft}px aligns with ${centered ? 'landing content' : 'documentation header'} at ${contentLeft}px`)
+  assert(
+    Math.abs(noticeLeft - contentLeft) <= 1,
+    `${page.url()}: notice at ${noticeLeft}px aligns with ${centered ? 'landing content' : 'documentation header'} at ${contentLeft}px`,
+  )
   if (artworkLeft !== undefined) {
-    assert(Math.abs(noticeLeft - artworkLeft) <= 1, `${page.url()}: notice at ${noticeLeft}px aligns with documentation artwork at ${artworkLeft}px`)
+    assert(
+      Math.abs(noticeLeft - artworkLeft) <= 1,
+      `${page.url()}: notice at ${noticeLeft}px aligns with documentation artwork at ${artworkLeft}px`,
+    )
   }
 }
 
@@ -101,18 +127,31 @@ async function checkContextControls(page) {
   await page.waitForFunction(() => !document.documentElement.hasAttribute('data-astro-transition'))
   const layout = await page.evaluate(() => {
     const bar = document.querySelector('[data-documentation-context]')
-    const controls = [...bar.querySelectorAll('.doc-picker > summary, .documentation-context-navigation > button, [data-context-settings-toggle], [data-context-settings-back]')]
+    const controls = [
+      ...bar.querySelectorAll(
+        '.doc-picker > summary, .documentation-context-navigation > button, [data-context-settings-toggle], [data-context-settings-back]',
+      ),
+    ]
       .map((element) => {
         const { x, y, width, height } = element.getBoundingClientRect()
         const hit = document.elementFromPoint(x + width / 2, y + height / 2)
-        return { name: element.getAttribute('aria-label') ?? element.textContent.trim(), x, y, width, height,
+        return {
+          name: element.getAttribute('aria-label') ?? element.textContent.trim(),
+          x,
+          y,
+          width,
+          height,
           selector: element.matches('.documentation-context-selectors .doc-picker > summary'),
-          reachable: element.contains(hit), coveredBy: hit?.outerHTML.slice(0, 180) }
-      }).filter(({ width, height }) => width > 0 && height > 0)
+          reachable: element.contains(hit),
+          coveredBy: hit?.outerHTML.slice(0, 180),
+        }
+      })
+      .filter(({ width, height }) => width > 0 && height > 0)
     return { height: bar.getBoundingClientRect().height, controls }
   })
   for (const [index, control] of layout.controls.entries()) {
-    if (control.selector) assert.equal(control.height, 36, `${page.url()}: ${control.name} matches the homepage's 36px controls`)
+    if (control.selector)
+      assert.equal(control.height, 36, `${page.url()}: ${control.name} matches the homepage's 36px controls`)
     assert(control.reachable, `${page.url()}: context control is reachable: ${JSON.stringify(control)}`)
     for (const other of layout.controls.slice(index + 1)) {
       const overlap = Math.min(control.x + control.width, other.x + other.width) - Math.max(control.x, other.x)
@@ -131,19 +170,26 @@ export async function checkContextSettings(page, javaScriptEnabled = true) {
   const navigation = context.locator('.documentation-context-navigation > button')
   const compact = await page.evaluate(() => matchMedia('(max-width: 24rem)').matches)
   assert.equal(await toggle.isVisible(), javaScriptEnabled && compact, 'The cog appears on enhanced narrow screens')
-  if (!await toggle.isVisible()) {
+  if (!(await toggle.isVisible())) {
     assert(await settings.isVisible(), 'Version and locale remain directly available without compact enhancement')
     return
   }
-  for (const button of await navigation.all()) assert(!await button.isVisible(), 'Narrow navigation controls live in the cog view')
+  for (const button of await navigation.all())
+    assert(!(await button.isVisible()), 'Narrow navigation controls live in the cog view')
   const before = await context.boundingBox()
   await toggle.focus()
   await page.keyboard.press('Enter')
   assert(await settings.isVisible(), 'Cog opens version and locale in the bar')
-  assert(!await context.locator('[data-surface-picker] > summary').isVisible(), 'Settings replace the primary controls')
+  assert(
+    !(await context.locator('[data-surface-picker] > summary').isVisible()),
+    'Settings replace the primary controls',
+  )
   assert(await back.evaluate((button) => button === document.activeElement), 'Settings focus Back')
   const after = await context.boundingBox()
-  assert(Math.abs(before.height - after.height) <= 1 && before.width === after.width, 'Settings stay within the same container')
+  assert(
+    Math.abs(before.height - after.height) <= 1 && before.width === after.width,
+    'Settings stay within the same container',
+  )
   await checkContextControls(page)
   for (const button of await navigation.all()) {
     assert(await button.isVisible(), 'The cog view exposes navigation controls')
@@ -152,7 +198,10 @@ export async function checkContextSettings(page, javaScriptEnabled = true) {
     await page.keyboard.press('Escape')
     assert.equal(await button.getAttribute('aria-expanded'), 'false', 'Escape closes navigation')
     assert(await settings.isVisible(), 'Closing navigation returns to the cog view')
-    assert(await button.evaluate((control) => control === document.activeElement), 'Closing navigation restores its control focus')
+    assert(
+      await button.evaluate((control) => control === document.activeElement),
+      'Closing navigation restores its control focus',
+    )
   }
   const version = settings.locator('[data-version-picker]')
   await version.locator(':scope > summary').click()
@@ -160,12 +209,15 @@ export async function checkContextSettings(page, javaScriptEnabled = true) {
   await page.keyboard.press('Escape')
   assert(await settings.isVisible(), 'First Escape dismisses the picker without leaving settings')
   await page.keyboard.press('Escape')
-  assert(!await settings.isVisible(), 'Second Escape returns to the primary view')
+  assert(!(await settings.isVisible()), 'Second Escape returns to the primary view')
   assert(await toggle.evaluate((button) => button === document.activeElement), 'Returning restores focus to the cog')
   await toggle.click()
   await back.click()
-  assert(!await settings.isVisible(), 'Back returns to the primary view')
-  assert(await page.locator('.site-header-language [data-page-port-switcher] > summary').isVisible(), 'The language picker remains available in the top bar')
+  assert(!(await settings.isVisible()), 'Back returns to the primary view')
+  assert(
+    await page.locator('.site-header-language [data-page-port-switcher] > summary').isVisible(),
+    'The language picker remains available in the top bar',
+  )
   const drawerButton = (await navigation.all())[0]
   if (drawerButton) {
     const viewport = page.viewportSize()
@@ -176,7 +228,10 @@ export async function checkContextSettings(page, javaScriptEnabled = true) {
     await page.keyboard.press('Escape')
     await page.evaluate(() => new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))))
     assert(await drawerButton.isVisible(), 'Resizing an open drawer keeps its return control visible')
-    assert(await drawerButton.evaluate((button) => button === document.activeElement), 'Drawer return focus survives a resize into compact mode')
+    assert(
+      await drawerButton.evaluate((button) => button === document.activeElement),
+      'Drawer return focus survives a resize into compact mode',
+    )
     await back.click()
   }
 }
@@ -190,15 +245,19 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
   page.setDefaultTimeout(process.env.CI ? 20000 : 10000)
   await observeInitialPageLoad(page)
   const desktopPicker = (reader) => reader.locator('[data-documentation-context] [data-surface-picker]')
-  const group = (picker, label) => picker.locator('[data-surface-group]').filter({
-    has: picker.page().locator('summary strong', { hasText: new RegExp(`^${label}$`) }),
-  })
+  const group = (picker, label) =>
+    picker.locator('[data-surface-group]').filter({
+      has: picker.page().locator('summary strong', { hasText: new RegExp(`^${label}$`) }),
+    })
   const openPicker = async (picker, enhanced = true) => {
     await picker.locator(':scope > summary').click()
     if (enhanced) {
       const search = picker.locator('[data-surface-search]')
       await search.waitFor({ state: 'visible' })
-      assert(await search.evaluate((element) => element === document.activeElement), 'Opening the picker focuses search')
+      assert(
+        await search.evaluate((element) => element === document.activeElement),
+        'Opening the picker focuses search',
+      )
     }
   }
   try {
@@ -210,40 +269,72 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
       const response = await page.goto(`${base}/${slug}/latest/`, { waitUntil: 'load' })
       assert(response?.ok(), `${slug}: documentation home responds`)
       await checkNoticeAlignment(page)
-      assert.equal(await page.locator('[data-page-toolbar]').count(), 0, `${slug}: home has no redundant breadcrumb/action row`)
+      assert.equal(
+        await page.locator('[data-page-toolbar]').count(),
+        0,
+        `${slug}: home has no redundant breadcrumb/action row`,
+      )
       assert.equal(await page.locator('.port-hero h1').count(), 1, `${slug}: one port heading`)
       const picker = desktopPicker(page)
       await picker.locator(':scope > summary').waitFor({ state: 'visible' })
-      assert.equal((await picker.locator('.surface-current').innerText()).replace(/\s+/g, ' ').trim(), 'Core Library Home')
+      assert.equal(
+        (await picker.locator('.surface-current').innerText()).replace(/\s+/g, ' ').trim(),
+        'Core Library Home',
+      )
       await openPicker(picker)
       const core = group(picker, 'Core Library')
       const sections = await core.locator('.surface-options a').evaluateAll((links) =>
-        links.map((link) => ({ label: link.textContent.trim().replace(/\s*✓$/, ''), href: link.getAttribute('href') })))
+        links.map((link) => ({
+          label: link.textContent.trim().replace(/\s*✓$/, ''),
+          href: link.getAttribute('href'),
+        })),
+      )
       for (const label of ['Home', 'Guides', 'Concepts', 'Examples', 'API Reference']) {
-        assert.equal(sections.filter((section) => section.label === label).length, 1,
-          `${slug}: ${label} has one real destination`)
+        assert.equal(
+          sections.filter((section) => section.label === label).length,
+          1,
+          `${slug}: ${label} has one real destination`,
+        )
       }
-      assert(sections.every(({ href }) => href.startsWith(`${new URL(base).pathname}/${slug}/latest/`)),
-        `${slug}: sections retain the selected port and version`)
+      assert(
+        sections.every(({ href }) => href.startsWith(`${new URL(base).pathname}/${slug}/latest/`)),
+        `${slug}: sections retain the selected port and version`,
+      )
       const names = await picker.locator('[data-surface-group] > summary strong').allTextContents()
       assert.equal(names[0], 'Core Library', `${slug}: the library is the default surface`)
-      const appNames = parentLibrary ? [] : [
-        ...(productAvailable(port, 'mcp') ? ['MCP'] : []),
-        ...(productAvailable(port, 'workspace') ? ['Workspace Manager'] : []),
-      ]
+      const appNames = parentLibrary
+        ? []
+        : [
+            ...(productAvailable(port, 'mcp') ? ['MCP'] : []),
+            ...(productAvailable(port, 'workspace') ? ['Workspace Manager'] : []),
+          ]
       assert.deepEqual(names.slice(1).sort(), appNames, `${slug}: only available applications appear`)
       const catalog = appNames.includes('MCP') ? mcpCatalogs.ports[slug] : undefined
-      const emptySections = catalog ? [
-        ...(catalog.registrations.length ? [] : ['Tools']),
-        ...(catalog.protocol.prompts.length ? [] : ['Prompts']),
-        ...(catalog.protocol.resources.length || catalog.protocol.resourceTemplates.length ? [] : ['Resources']),
-      ] : []
+      const emptySections = catalog
+        ? [
+            ...(catalog.registrations.length ? [] : ['Tools']),
+            ...(catalog.protocol.prompts.length ? [] : ['Prompts']),
+            ...(catalog.protocol.resources.length || catalog.protocol.resourceTemplates.length ? [] : ['Resources']),
+          ]
+        : []
       const disabled = await picker.locator('[data-surface-option]:not(a[href])').evaluateAll((items) =>
-        items.map((item) => ({ label: item.textContent.trim(), role: item.getAttribute('role'),
-          disabled: item.getAttribute('aria-disabled'), title: item.getAttribute('title') })))
-      assert.deepEqual(disabled, emptySections.map((label) => ({ label, role: 'link', disabled: 'true',
-        title: `No ${label.toLowerCase()} advertised in the reference configuration` })),
-      `${slug}: only empty protocol catalogs are disabled`)
+        items.map((item) => ({
+          label: item.textContent.trim(),
+          role: item.getAttribute('role'),
+          disabled: item.getAttribute('aria-disabled'),
+          title: item.getAttribute('title'),
+        })),
+      )
+      assert.deepEqual(
+        disabled,
+        emptySections.map((label) => ({
+          label,
+          role: 'link',
+          disabled: 'true',
+          title: `No ${label.toLowerCase()} advertised in the reference configuration`,
+        })),
+        `${slug}: only empty protocol catalogs are disabled`,
+      )
       assert.equal(await picker.getByText('Navigation preview').count(), 0, `${slug}: no empty section placeholders`)
       await page.keyboard.press('Escape')
       assert.equal(await picker.getAttribute('open'), null)
@@ -252,10 +343,16 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
       await page.goto(`${base}/${slug}/latest/guides/`, { waitUntil: 'load' })
       assert.equal((await page.locator('main h1').textContent()).trim(), 'Guides')
       const nav = page.locator('.sidebar-nav:visible')
-      assert.equal(await nav.getByRole('link', { name: 'Overview', exact: true }).getAttribute('href'), `${new URL(base).pathname}/${slug}/latest/guides/`)
+      assert.equal(
+        await nav.getByRole('link', { name: 'Overview', exact: true }).getAttribute('href'),
+        `${new URL(base).pathname}/${slug}/latest/guides/`,
+      )
       const guideLinks = nav.locator('a').filter({ hasNotText: /^\s*Overview\s*$/ })
-      assert.deepEqual((await guideLinks.allTextContents()).slice(0, 2).map((label) => label.trim()),
-        ['Getting started', 'Attaching to tmux'], `${slug}: setup leads the guides`)
+      assert.deepEqual(
+        (await guideLinks.allTextContents()).slice(0, 2).map((label) => label.trim()),
+        ['Getting started', 'Attaching to tmux'],
+        `${slug}: setup leads the guides`,
+      )
       assert.equal(await nav.locator('a[href*="api-overview"]').count(), 0, `${slug}: no duplicate API guide`)
       assert.equal((await page.locator('main .doc-card').first().locator('h3').textContent()).trim(), 'Getting started')
       await guideLinks.first().click()
@@ -269,8 +366,11 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
       await group(picker, 'Core Library').getByRole('link', { name: browse, exact: true }).click()
       await page.waitForURL(`${base}/${slug}/latest/${browse.toLowerCase()}/`)
       assert.equal((await page.locator('main h1').textContent()).trim(), browse)
-      assert.equal(await page.locator('main .doc-card').count(), slug === 'fsharp' ? 4 : 2,
-        `${slug}: browse pages use the shared cards`)
+      assert.equal(
+        await page.locator('main .doc-card').count(),
+        slug === 'fsharp' ? 4 : 2,
+        `${slug}: browse pages use the shared cards`,
+      )
     }
     await page.goto(`${base}/fsharp/latest/guides/api-overview/?from=bookmark`, { waitUntil: 'load' })
     await page.waitForURL(`${base}/fsharp/latest/reference/?from=bookmark`)
@@ -278,7 +378,9 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
     assert.equal(await page.title(), 'F# API reference | libtmux-fsharp')
     await page.goto(`${base}/ruby/latest/guides/overview/`, { waitUntil: 'load' })
     await page.waitForURL(`${base}/ruby/latest/guides/getting-started/`)
-    console.log(`Documentation surfaces: ${ports.length} ports retain real section links; Ruby/F# setup, cards and legacy links pass`)
+    console.log(
+      `Documentation surfaces: ${ports.length} ports retain real section links; Ruby/F# setup, cards and legacy links pass`,
+    )
   } finally {
     await page.close()
   }
@@ -290,7 +392,8 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
       const reader = await context.newPage()
       reader.setDefaultTimeout(process.env.CI ? 20000 : 10000)
       try {
-        if (javaScriptEnabled) await reader.addInitScript((scheme) => localStorage.setItem('color-scheme', scheme), colorScheme)
+        if (javaScriptEnabled)
+          await reader.addInitScript((scheme) => localStorage.setItem('color-scheme', scheme), colorScheme)
         for (const width of [320, 390, 641, 768, 1440, 1920]) {
           await reader.setViewportSize({ width, height: 900 })
           await reader.goto(`${base}/go/latest/workspace/`, { waitUntil: 'load' })
@@ -304,16 +407,33 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
               const { top, bottom, height, width } = visible.getBoundingClientRect()
               return { top, bottom, height, width }
             }
-            return { bar: bounds('[data-documentation-context]'), surface: bounds('[data-surface-picker] > summary'),
-              port: bounds('[data-page-port-switcher] > summary'), header: ['.site-header__search', '.scheme-switch, .scheme-cycle', '.site-header__menu-button'].map(bounds) }
+            return {
+              bar: bounds('[data-documentation-context]'),
+              surface: bounds('[data-surface-picker] > summary'),
+              port: bounds('[data-page-port-switcher] > summary'),
+              header: ['.site-header__search', '.scheme-switch, .scheme-cycle', '.site-header__menu-button'].map(
+                bounds,
+              ),
+            }
           })
           assert(layout.bar.height <= 58, `${width}: context remains a single compact row`)
-          assert(Math.abs((layout.surface.top + layout.surface.bottom) - (layout.port.top + layout.port.bottom)) <= 1,
-            `${width}: surface and context controls are vertically centered`)
+          assert(
+            Math.abs(layout.surface.top + layout.surface.bottom - (layout.port.top + layout.port.bottom)) <= 1,
+            `${width}: surface and context controls are vertically centered`,
+          )
           assert(layout.surface.width >= 60, `${width}: the surface trigger remains usable`)
-          assert(layout.header.every((item) => Math.abs(item.height - layout.header[0].height) < .1
-            && Math.abs(item.top - layout.header[0].top) < .1), `${width}: Search, scheme and menu have equal heights`)
-          assert.equal((await picker.locator('.surface-current').innerText()).replace(/\s+/g, ' ').trim(), 'Workspace Manager Home')
+          assert(
+            layout.header.every(
+              (item) =>
+                Math.abs(item.height - layout.header[0].height) < 0.1 &&
+                Math.abs(item.top - layout.header[0].top) < 0.1,
+            ),
+            `${width}: Search, scheme and menu have equal heights`,
+          )
+          assert.equal(
+            (await picker.locator('.surface-current').innerText()).replace(/\s+/g, ' ').trim(),
+            'Workspace Manager Home',
+          )
           await openPicker(picker, javaScriptEnabled)
           if (javaScriptEnabled) {
             const search = picker.locator('[data-surface-search]')
@@ -324,7 +444,10 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
             assert.equal(await links.count(), 1, 'Search matches both the surface and section')
             assert.equal(await links.first().getAttribute('href'), `${new URL(base).pathname}/go/latest/mcp/guides/`)
             await search.press('ArrowDown')
-            assert(await links.first().evaluate((link) => link === document.activeElement), 'ArrowDown reaches a result')
+            assert(
+              await links.first().evaluate((link) => link === document.activeElement),
+              'ArrowDown reaches a result',
+            )
             await reader.keyboard.press('Escape')
             assert.equal(await picker.getAttribute('open'), null, 'Escape closes the picker')
             await openPicker(picker)
@@ -332,16 +455,31 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
           }
           const panel = await picker.locator('[data-surface-panel]').boundingBox()
           const usableWidth = await reader.evaluate(() => document.documentElement.clientWidth)
-          assert(panel.x >= 0 && panel.x + panel.width <= usableWidth + 1, `${width}/${colorScheme}: picker fits beside the scrollbar`)
-          if (javaScriptEnabled) assert(panel.y >= 0 && panel.y + panel.height <= 901, `${width}: floating picker fits vertically`)
+          assert(
+            panel.x >= 0 && panel.x + panel.width <= usableWidth + 1,
+            `${width}/${colorScheme}: picker fits beside the scrollbar`,
+          )
+          if (javaScriptEnabled)
+            assert(panel.y >= 0 && panel.y + panel.height <= 901, `${width}: floating picker fits vertically`)
           const target = group(picker, 'Workspace Manager').getByRole('link', { name: 'Guides', exact: true })
           if (javaScriptEnabled) await picker.locator('[data-surface-search]').press('Enter')
-          else { await target.focus(); await reader.keyboard.press('Enter') }
+          else {
+            await target.focus()
+            await reader.keyboard.press('Enter')
+          }
           await reader.waitForURL(`${base}/go/latest/workspace/guides/`)
-          assert.equal((await reader.locator('main h1').textContent()).trim(), 'Guides', 'Guides has a real browse page')
-          assert(await reader.locator('main .doc-card').count() >= 5, 'Workspace guides show task cards')
-          if (width < 1024 && javaScriptEnabled) assert.equal(await reader.locator('#mobile-sidebar-toggle').getAttribute('aria-expanded'), 'false',
-            'Changing sections closes the mobile drawer')
+          assert.equal(
+            (await reader.locator('main h1').textContent()).trim(),
+            'Guides',
+            'Guides has a real browse page',
+          )
+          assert((await reader.locator('main .doc-card').count()) >= 5, 'Workspace guides show task cards')
+          if (width < 1024 && javaScriptEnabled)
+            assert.equal(
+              await reader.locator('#mobile-sidebar-toggle').getAttribute('aria-expanded'),
+              'false',
+              'Changing sections closes the mobile drawer',
+            )
           if (javaScriptEnabled) {
             if (width < 1024) {
               const settings = reader.locator('[data-context-settings-toggle]')
@@ -354,15 +492,26 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
             assert.equal(await links.count(), 1, 'Section search filters its own pages')
             assert((await links.first().getAttribute('href')).endsWith('/workspace/guides/troubleshooting/'))
             await search.fill('')
-            assert(await links.count() > 1, 'Clearing search restores the page list')
+            assert((await links.count()) > 1, 'Clearing search restores the page list')
           }
           await reader.goBack()
           await reader.waitForURL(`${base}/go/latest/workspace/`)
           await reader.goForward()
           await reader.waitForURL(`${base}/go/latest/workspace/guides/`)
-          assert(await reader.locator('[data-surface-picker] > summary').first().getAttribute('aria-label').then((label) => label.endsWith('Workspace Manager, Guides')),
-            'History restores the selected surface and section')
-          assert(await reader.evaluate(() => document.documentElement.scrollWidth <= document.documentElement.clientWidth + 1), `${width}: page has no horizontal overflow`)
+          assert(
+            await reader
+              .locator('[data-surface-picker] > summary')
+              .first()
+              .getAttribute('aria-label')
+              .then((label) => label.endsWith('Workspace Manager, Guides')),
+            'History restores the selected surface and section',
+          )
+          assert(
+            await reader.evaluate(
+              () => document.documentElement.scrollWidth <= document.documentElement.clientWidth + 1,
+            ),
+            `${width}: page has no horizontal overflow`,
+          )
           await openPicker(picker, javaScriptEnabled)
           if (javaScriptEnabled) await picker.locator('[data-surface-search]').fill('')
           const core = group(picker, 'Core Library')
@@ -371,7 +520,12 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
           await reader.waitForURL(`${base}/go/latest/reference/`)
           await checkNoticeAlignment(reader)
           await checkContextControls(reader)
-          assert(await reader.evaluate(() => document.documentElement.scrollWidth <= document.documentElement.clientWidth + 1), `${width}: reference has no horizontal overflow`)
+          assert(
+            await reader.evaluate(
+              () => document.documentElement.scrollWidth <= document.documentElement.clientWidth + 1,
+            ),
+            `${width}: reference has no horizontal overflow`,
+          )
           if (width === 320 || width === 1920) {
             await reader.goto(`${base}/`, { waitUntil: 'load' })
             await checkNoticeAlignment(reader, true)
@@ -382,14 +536,22 @@ export async function checkDocumentationNavigation(browser, base, complete = fal
       }
     }
   }
-  console.log('Surface picker: search, keyboard, history and scoped page lists pass on phone/tablet/desktop, both themes and without JavaScript')
+  console.log(
+    'Surface picker: search, keyboard, history and scoped page lists pass on phone/tablet/desktop, both themes and without JavaScript',
+  )
 }
 
 /** Browser load can precede the router's initial page-load event in development. */
 async function observeInitialPageLoad(page) {
   await page.addInitScript(() => {
     window.__docsPageLoaded = false
-    document.addEventListener('astro:page-load', () => { window.__docsPageLoaded = true }, { once: true })
+    document.addEventListener(
+      'astro:page-load',
+      () => {
+        window.__docsPageLoaded = true
+      },
+      { once: true },
+    )
   })
 }
 
@@ -411,8 +573,10 @@ export async function checkApiNavigation(page, base) {
     await page.waitForURL(snapshot)
     await page.waitForFunction(() => window.__apiNavigationProbe?.loads === 1)
     assert(await page.evaluate(() => window.__apiNavigationProbe), 'API navigation retains the document')
-    assert(await page.locator('html').evaluate((el) => el.hasAttribute('data-api-nav')),
-      `API navigation restores the drawer styles at ${width}px`)
+    assert(
+      await page.locator('html').evaluate((el) => el.hasAttribute('data-api-nav')),
+      `API navigation restores the drawer styles at ${width}px`,
+    )
     const nav = page.locator('#api-nav')
     const toggle = page.locator('[data-api-nav-toggle]')
     await nav.waitFor({ state: 'hidden' })
@@ -424,7 +588,9 @@ export async function checkApiNavigation(page, base) {
     }
     for (const close of ['button', 'Escape', 'overlay']) {
       await open()
-      await nav.locator('[role="tree"]').evaluate((el) => { el.scrollTop = el.scrollHeight })
+      await nav.locator('[role="tree"]').evaluate((el) => {
+        el.scrollTop = el.scrollHeight
+      })
       if (close === 'button') await nav.locator('[data-api-nav-close]').click()
       else if (close === 'Escape') await page.keyboard.press('Escape')
       else {
@@ -441,7 +607,10 @@ export async function checkApiNavigation(page, base) {
     await page.waitForURL(server)
     await page.waitForFunction(() => window.__apiNavigationProbe?.loads === 2)
     const menu = page.locator('[data-documentation-context] [data-surface-picker]')
-    assert(await menu.locator(':scope > summary').isVisible(), 'Documentation context is available above the closed API drawer')
+    assert(
+      await menu.locator(':scope > summary').isVisible(),
+      'Documentation context is available above the closed API drawer',
+    )
     await menu.locator(':scope > summary').click()
     assert.equal(await menu.evaluate((el) => el.open), true)
     await page.keyboard.press('Escape')
@@ -459,7 +628,10 @@ export async function checkApiNavigation(page, base) {
     await page.waitForURL(server)
     // URL arrival precedes the link-hint reveal gate on a client navigation.
     await page.locator('[data-api-nav-toggle]').waitFor({ state: 'visible' })
-    assert(await page.locator('[data-api-nav-toggle]').isVisible(), `${path || 'Port home'} to API keeps the drawer toggle`)
+    assert(
+      await page.locator('[data-api-nav-toggle]').isVisible(),
+      `${path || 'Port home'} to API keeps the drawer toggle`,
+    )
     await page.locator('[data-api-nav-toggle]').click()
     await page.locator('[data-api-nav-close]').click()
     await page.locator('#api-nav').waitFor({ state: 'hidden' })
@@ -483,11 +655,26 @@ export async function checkApiNavigation(page, base) {
   await results.locator('a[href$="libtmux-server-snapshot/"]').waitFor()
   await search.focus()
   await page.keyboard.press('ArrowDown')
-  assert(await results.locator('a').first().evaluate((link) => link === document.activeElement))
+  assert(
+    await results
+      .locator('a')
+      .first()
+      .evaluate((link) => link === document.activeElement),
+  )
   await page.keyboard.press('End')
-  assert(await results.locator('a').last().evaluate((link) => link === document.activeElement))
+  assert(
+    await results
+      .locator('a')
+      .last()
+      .evaluate((link) => link === document.activeElement),
+  )
   await page.keyboard.press('Home')
-  assert(await results.locator('a').first().evaluate((link) => link === document.activeElement))
+  assert(
+    await results
+      .locator('a')
+      .first()
+      .evaluate((link) => link === document.activeElement),
+  )
   await page.keyboard.press('Escape')
   assert(await search.evaluate((input) => input === document.activeElement))
   await page.keyboard.press('Escape')
@@ -503,11 +690,15 @@ export async function checkApiNavigation(page, base) {
   await page.reload()
   await page.locator('[data-api-nav-toggle]').click()
   await search.fill('Server:snapshot')
-  await page.waitForFunction(() => document.querySelector('[data-api-search-status]').textContent.includes('could not load'))
+  await page.waitForFunction(() =>
+    document.querySelector('[data-api-search-status]').textContent.includes('could not load'),
+  )
   await page.unroute('**/tree.json')
   await page.getByRole('button', { name: 'Retry search' }).click()
   await results.locator('a[href$="libtmux-server-snapshot/"]').waitFor()
-  console.log('API search: full member names, category filters, keyboard focus, phone layout and visible retryable failures pass')
+  console.log(
+    'API search: full member names, category filters, keyboard focus, phone layout and visible retryable failures pass',
+  )
 }
 
 /** Public symbol fragments and earlier declaration links reach the same bar. */
@@ -525,11 +716,17 @@ export async function checkApiAnchorArrival(browser, base) {
     await catalog.close()
   }
   for (const [width, colorScheme, javaScriptEnabled] of [
-    [390, 'light', true], [1280, 'dark', true],
-    [390, 'dark', false], [1280, 'light', false],
+    [390, 'light', true],
+    [1280, 'dark', true],
+    [390, 'dark', false],
+    [1280, 'light', false],
   ]) {
-    const context = await browser.newContext({ viewport: { width, height: 1000 }, colorScheme,
-      javaScriptEnabled, reducedMotion: 'reduce' })
+    const context = await browser.newContext({
+      viewport: { width, height: 1000 },
+      colorScheme,
+      javaScriptEnabled,
+      reducedMotion: 'reduce',
+    })
     const page = await context.newPage()
     page.setDefaultTimeout(process.env.CI ? 20000 : 10000)
     try {
@@ -544,28 +741,41 @@ export async function checkApiAnchorArrival(browser, base) {
         for (const fragment of [identity, `${identity}.declaration`]) {
           await page.goto(`${path}#${encodeURIComponent(fragment)}`, { waitUntil: 'load' })
           await page.evaluate(() => document.fonts.ready)
-          if (javaScriptEnabled) await page.waitForFunction((id) =>
-            document.getElementById(id)?.hasAttribute('data-anchor-arrival'), identity)
+          if (javaScriptEnabled)
+            await page.waitForFunction(
+              (id) => document.getElementById(id)?.hasAttribute('data-anchor-arrival'),
+              identity,
+            )
           const arrival = await declaration.evaluate((element, fragment) => {
             const rect = element.getBoundingClientRect()
-            return { ownsFragment: element.contains(document.getElementById(fragment)),
+            return {
+              ownsFragment: element.contains(document.getElementById(fragment)),
               target: element.matches(':target, :has(> .section-anchor-alias:target)'),
-              color: getComputedStyle(element).backgroundColor, top: rect.top,
+              color: getComputedStyle(element).backgroundColor,
+              top: rect.top,
               header: document.querySelector('.site-header').getBoundingClientRect().bottom,
-              viewport: innerHeight, overflow: document.documentElement.scrollWidth - innerWidth }
+              viewport: innerHeight,
+              overflow: document.documentElement.scrollWidth - innerWidth,
+            }
           }, fragment)
           assert(arrival.ownsFragment && arrival.target, `${path}: ${fragment} targets the declaration`)
-          assert(arrival.color !== idleColor && arrival.color !== 'rgba(0, 0, 0, 0)' && arrival.color !== 'transparent',
-            `${path}#${fragment}: arrival changes the declaration background`)
-          assert(arrival.top >= arrival.header - 1 && arrival.top < arrival.viewport && arrival.overflow <= 1,
-            `${path}#${fragment} at ${width}px (JavaScript ${javaScriptEnabled}): the declaration is visible below the header without overflow: ${JSON.stringify(arrival)}`)
+          assert(
+            arrival.color !== idleColor && arrival.color !== 'rgba(0, 0, 0, 0)' && arrival.color !== 'transparent',
+            `${path}#${fragment}: arrival changes the declaration background`,
+          )
+          assert(
+            arrival.top >= arrival.header - 1 && arrival.top < arrival.viewport && arrival.overflow <= 1,
+            `${path}#${fragment} at ${width}px (JavaScript ${javaScriptEnabled}): the declaration is visible below the header without overflow: ${JSON.stringify(arrival)}`,
+          )
         }
       }
     } finally {
       await context.close()
     }
   }
-  console.log(`API anchors: ${paths.size} declarations across ${PORTS.length} ports, primary and retained fragments, phone/desktop, both themes and no-JavaScript navigation pass`)
+  console.log(
+    `API anchors: ${paths.size} declarations across ${PORTS.length} ports, primary and retained fragments, phone/desktop, both themes and no-JavaScript navigation pass`,
+  )
 }
 
 /** Check the controls attached to a document after its content is replaced. */
@@ -584,12 +794,18 @@ export async function checkNavigation(page, base) {
       window.__navigationProbe.wrongTheme ||= document.documentElement.dataset.themeMode !== 'dark'
     })
   })
-  await page.getByRole('navigation', { name: 'Breadcrumb', exact: true }).getByRole('link', { name: 'Examples', exact: true }).click()
+  await page
+    .getByRole('navigation', { name: 'Breadcrumb', exact: true })
+    .getByRole('link', { name: 'Examples', exact: true })
+    .click()
   await page.waitForFunction(() => window.__navigationProbe?.loads === 1)
   assert.match(page.url(), /\/examples\/$/)
-  const example = page.locator('main').getByRole('link').filter({
-    has: page.getByRole('heading', { name: 'Attach and send keys', exact: true }),
-  })
+  const example = page
+    .locator('main')
+    .getByRole('link')
+    .filter({
+      has: page.getByRole('heading', { name: 'Attach and send keys', exact: true }),
+    })
   await example.click()
   await page.waitForFunction(() => window.__navigationProbe?.loads === 2)
   assert.match(page.url(), /\/examples\/attach-and-send-keys\/$/)
@@ -612,19 +828,29 @@ export async function checkNavigation(page, base) {
   assert.equal(await page.locator('html').getAttribute('data-mcp-install-cooldown-enabled'), '1')
   console.log('Navigation: document retained, Back, search, code tabs, menu and saved theme/cooldown pass')
 
-  for (const [port, version] of [['ts', 'latest'], ['py', 'stable']]) {
+  for (const [port, version] of [
+    ['ts', 'latest'],
+    ['py', 'stable'],
+  ]) {
     const prefix = new URL(`${base}/${port}/${version}/`).pathname
     for (const width of [1440, 390]) {
       await page.setViewportSize({ width, height: 900 })
-      const response = await page.goto(`${base}/${port}/${version}/examples/capture-pane-output/`, { waitUntil: 'load' })
+      const response = await page.goto(`${base}/${port}/${version}/examples/capture-pane-output/`, {
+        waitUntil: 'load',
+      })
       assert(response?.ok(), `${port}: owned example exists in the root build`)
       const sidebars = page.locator('nav.sidebar-nav')
       assert.equal(await sidebars.count(), 2, 'Desktop and mobile both have navigation')
       for (const sidebar of await sidebars.all()) {
         const current = sidebar.locator('a[aria-current="page"]')
-        assert.equal(await current.getAttribute('href'), `${prefix}examples/capture-pane-output/`,
-          `${port} ${version} at ${width}px: the section menu identifies the current example`)
-        const links = await sidebar.locator('a[href^="/"]').evaluateAll((items) => items.map((a) => a.getAttribute('href')))
+        assert.equal(
+          await current.getAttribute('href'),
+          `${prefix}examples/capture-pane-output/`,
+          `${port} ${version} at ${width}px: the section menu identifies the current example`,
+        )
+        const links = await sidebar
+          .locator('a[href^="/"]')
+          .evaluateAll((items) => items.map((a) => a.getAttribute('href')))
         for (const href of links) assert(href.startsWith(prefix), `${port} sidebar leaves ${prefix}: ${href}`)
       }
     }
@@ -651,13 +877,19 @@ export async function checkNavigation(page, base) {
 /** Port references keep examples in the selected language. */
 export async function checkApiExampleOwnership(page, base, path = 'ts/latest/reference/pane-pane-capture/') {
   await page.goto(`${base}/${path}`, { waitUntil: 'load' })
-  const languages = await page.locator('main pre[data-language]').evaluateAll((blocks) =>
-    blocks.map((block) => block.getAttribute('data-language')))
+  const languages = await page
+    .locator('main pre[data-language]')
+    .evaluateAll((blocks) => blocks.map((block) => block.getAttribute('data-language')))
   assert(languages.length > 0, 'The capture reference keeps its own example')
-  assert(languages.every((language) => language === 'typescript' || language === 'ts'),
-    `TypeScript reference contains another language: ${languages.join(', ')}`)
+  assert(
+    languages.every((language) => language === 'typescript' || language === 'ts'),
+    `TypeScript reference contains another language: ${languages.join(', ')}`,
+  )
   assert.equal(await page.locator('main .api-example-tabs').count(), 0)
-  assert.equal(await page.locator('[data-page-port-switcher]').count(), 1,
-    'Readers can still switch ports from the documentation context')
+  assert.equal(
+    await page.locator('[data-page-port-switcher]').count(),
+    1,
+    'Readers can still switch ports from the documentation context',
+  )
   console.log('Reference examples: TypeScript examples stay visible without other languages')
 }
diff --git a/site/scripts/check-picker-filters.mjs b/site/scripts/check-picker-filters.mjs
index 3aa0c47bb..e547c4a88 100644
--- a/site/scripts/check-picker-filters.mjs
+++ b/site/scripts/check-picker-filters.mjs
@@ -3,8 +3,14 @@ import assert from 'node:assert/strict'
 async function bounds(page, panel) {
   const box = await panel.boundingBox()
   const viewport = await page.evaluate(() => ({ width: document.documentElement.clientWidth, height: innerHeight }))
-  assert(box && box.x >= 7 && box.y >= 7 && box.x + box.width <= viewport.width - 7
-    && box.y + box.height <= viewport.height - 7, `Picker stays within the viewport: ${JSON.stringify({ box, viewport })}`)
+  assert(
+    box &&
+      box.x >= 7 &&
+      box.y >= 7 &&
+      box.x + box.width <= viewport.width - 7 &&
+      box.y + box.height <= viewport.height - 7,
+    `Picker stays within the viewport: ${JSON.stringify({ box, viewport })}`,
+  )
 }
 
 async function exercise(page, selector, query, count) {
@@ -22,7 +28,10 @@ async function exercise(page, selector, query, count) {
   const before = await page.evaluate(() => scrollY)
   await panel.hover()
   await page.mouse.wheel(0, 400)
-  await page.waitForFunction((selector) => document.querySelector(selector).querySelector('[data-picker-panel]').scrollTop > 0, selector)
+  await page.waitForFunction(
+    (selector) => document.querySelector(selector).querySelector('[data-picker-panel]').scrollTop > 0,
+    selector,
+  )
   assert.equal(await page.evaluate(() => scrollY), before, 'Scrolling stays inside the menu')
   await search.fill(query)
   assert.equal(await picker.locator('[data-picker-option]:visible').count(), 1, 'Search filters the options')
@@ -39,7 +48,10 @@ async function exercise(page, selector, query, count) {
   assert(await options.last().evaluate((node) => node === document.activeElement), 'End reaches the final option')
   const last = await options.last().boundingBox()
   const box = await panel.boundingBox()
-  assert(last.y >= box.y && last.y + last.height <= box.y + box.height, 'Keyboard navigation scrolls the final option into view')
+  assert(
+    last.y >= box.y && last.y + last.height <= box.y + box.height,
+    'Keyboard navigation scrolls the final option into view',
+  )
   await page.keyboard.press('Escape')
   assert.equal(await picker.getAttribute('open'), null)
   assert(await trigger.evaluate((node) => node === document.activeElement), 'Escape returns focus')
@@ -48,18 +60,30 @@ async function exercise(page, selector, query, count) {
   await search.waitFor({ state: 'visible' })
   const input = await search.boundingBox()
   const reopened = await panel.boundingBox()
-  assert(input && reopened && input.y >= reopened.y && input.y + input.height <= reopened.y + reopened.height,
-    'Reopening brings the focused search back into the menu viewport')
+  assert(
+    input && reopened && input.y >= reopened.y && input.y + input.height <= reopened.y + reopened.height,
+    'Reopening brings the focused search back into the menu viewport',
+  )
   assert(await search.evaluate((node) => node === document.activeElement), 'Reopening focuses search')
   assert.equal(await page.evaluate(() => scrollY), documentScroll, 'Reopening preserves document scroll')
   await page.keyboard.press('Escape')
-  assert(await picker.locator('a[href^="#"]').evaluateAll((links) => links.every((link) =>
-    document.getElementById(decodeURIComponent(link.hash.slice(1))))), 'Every sample link has an existing destination')
+  assert(
+    await picker
+      .locator('a[href^="#"]')
+      .evaluateAll((links) => links.every((link) => document.getElementById(decodeURIComponent(link.hash.slice(1))))),
+    'Every sample link has an existing destination',
+  )
 }
 
 /** Real widgets, dense lists, and delayed manifest updates share filtering. */
 export async function checkPickerFilters(browser, base, complete = false) {
-  const sizes = complete ? [{ width: 853, height: 789 }, { width: 320, height: 360 }, { width: 280, height: 320 }] : [{ width: 320, height: 360 }]
+  const sizes = complete
+    ? [
+        { width: 853, height: 789 },
+        { width: 320, height: 360 },
+        { width: 280, height: 320 },
+      ]
+    : [{ width: 320, height: 360 }]
   for (const colorScheme of complete ? ['light', 'dark'] : ['light']) {
     const context = await browser.newContext({ colorScheme, reducedMotion: 'reduce' })
     const page = await context.newPage()
@@ -73,20 +97,32 @@ export async function checkPickerFilters(browser, base, complete = false) {
         await exercise(page, '[data-demo-versions] [data-version-picker]', '1.12.0', 41)
         await exercise(page, '[data-demo-locales] [data-locale-picker]', 'sample language 12', 43)
       }
-    } finally { await context.close() }
+    } finally {
+      await context.close()
+    }
   }
   if (!complete) return
 
   const context = await browser.newContext({ viewport: { width: 853, height: 789 }, reducedMotion: 'reduce' })
   let release
-  const pending = new Promise((resolve) => { release = resolve })
+  const pending = new Promise((resolve) => {
+    release = resolve
+  })
   await context.route('**/versions.json', async (route) => {
     await pending
-    await route.fulfill({ contentType: 'application/json', body: JSON.stringify({ schema: 1, ports: { kotlin: [
-      { slug: 'latest', label: 'latest', kind: 'trunk', supported: true },
-      { slug: 'v1.12.0', label: 'v1.12.0', kind: 'release', supported: true },
-      { slug: 'v1.13.0-alpha.1', label: 'v1.13.0-alpha.1', kind: 'release', supported: true },
-    ] } }) })
+    await route.fulfill({
+      contentType: 'application/json',
+      body: JSON.stringify({
+        schema: 1,
+        ports: {
+          kotlin: [
+            { slug: 'latest', label: 'latest', kind: 'trunk', supported: true },
+            { slug: 'v1.12.0', label: 'v1.12.0', kind: 'release', supported: true },
+            { slug: 'v1.13.0-alpha.1', label: 'v1.13.0-alpha.1', kind: 'release', supported: true },
+          ],
+        },
+      }),
+    })
   })
   try {
     const page = await context.newPage()
@@ -98,11 +134,19 @@ export async function checkPickerFilters(browser, base, complete = false) {
     assert(await picker.locator('[data-picker-empty]').isVisible())
     release()
     await picker.getByRole('link', { name: 'v1.12.0', exact: true }).waitFor()
-    assert.equal(await picker.locator('[data-picker-option]:visible').count(), 1, 'A delayed manifest respects the active query')
-    assert.deepEqual(await picker.locator('[data-picker-group]:visible .doc-picker-title').allTextContents(), ['Releases'])
+    assert.equal(
+      await picker.locator('[data-picker-option]:visible').count(),
+      1,
+      'A delayed manifest respects the active query',
+    )
+    assert.deepEqual(await picker.locator('[data-picker-group]:visible .doc-picker-title').allTextContents(), [
+      'Releases',
+    ])
     await search.fill('prereleases')
     assert.equal(await picker.locator('[data-picker-option]:visible').count(), 1)
-    assert.deepEqual(await picker.locator('[data-picker-group]:visible .doc-picker-title').allTextContents(), ['Prereleases'])
+    assert.deepEqual(await picker.locator('[data-picker-group]:visible .doc-picker-title').allTextContents(), [
+      'Prereleases',
+    ])
     await search.fill('')
     assert.equal(await picker.locator('[data-picker-option]:visible').count(), 3)
     await bounds(page, picker.locator('[data-picker-panel]'))
@@ -117,8 +161,16 @@ export async function checkPickerFilters(browser, base, complete = false) {
     await versions.locator(':scope > summary').click()
     await versions.locator('[data-picker-search]').fill('1.12.0')
     await versions.getByRole('link', { name: 'v1.12.0', exact: true }).click()
-    assert.equal(new URL(page.url()).hash, '#demo-versions', 'Sample versions use their own destination after choosing a sample language')
-  } finally { release(); await context.unrouteAll({ behavior: 'wait' }); await context.close() }
+    assert.equal(
+      new URL(page.url()).hash,
+      '#demo-versions',
+      'Sample versions use their own destination after choosing a sample language',
+    )
+  } finally {
+    release()
+    await context.unrouteAll({ behavior: 'wait' })
+    await context.close()
+  }
 
   const noScript = await browser.newContext({ javaScriptEnabled: false, viewport: { width: 853, height: 789 } })
   try {
@@ -126,13 +178,24 @@ export async function checkPickerFilters(browser, base, complete = false) {
     await page.goto(`${base}/demo/widgets/pickers/`)
     const picker = page.locator('[data-demo-versions] [data-version-picker]')
     await picker.locator(':scope > summary').click()
-    assert(!await picker.locator('[data-picker-search]').isVisible(), 'No inactive search is exposed without JavaScript')
+    assert(
+      !(await picker.locator('[data-picker-search]').isVisible()),
+      'No inactive search is exposed without JavaScript',
+    )
     assert.equal(await picker.locator('a').count(), 41)
     const panel = picker.locator('[data-picker-panel]')
-    assert(await panel.evaluate((node) => node.scrollHeight > node.clientHeight && getComputedStyle(node).overflowY === 'auto'))
+    assert(
+      await panel.evaluate(
+        (node) => node.scrollHeight > node.clientHeight && getComputedStyle(node).overflowY === 'auto',
+      ),
+    )
     await picker.locator('a').last().click()
     assert.equal(new URL(page.url()).hash, '#demo-versions', 'No-JavaScript version links remain usable')
     assert.equal(await page.locator(new URL(page.url()).hash).count(), 1, 'The sample destination exists')
-  } finally { await noScript.close() }
-  console.log('Picker filters: both themes, 280–853px, short viewports, wheel/keyboard scrolling, reopening, delayed versions, and no JavaScript PASS')
+  } finally {
+    await noScript.close()
+  }
+  console.log(
+    'Picker filters: both themes, 280–853px, short viewports, wheel/keyboard scrolling, reopening, delayed versions, and no JavaScript PASS',
+  )
 }
diff --git a/site/scripts/check-reference-preferences.mjs b/site/scripts/check-reference-preferences.mjs
index 8884e3e69..b0eebca99 100644
--- a/site/scripts/check-reference-preferences.mjs
+++ b/site/scripts/check-reference-preferences.mjs
@@ -18,15 +18,20 @@ export async function checkReferencePreferences(browser, base) {
     }
     requestAnimationFrame(observe)
     window.__docsPageLoaded = false
-    document.addEventListener('astro:page-load', () => { window.__docsPageLoaded = true })
+    document.addEventListener('astro:page-load', () => {
+      window.__docsPageLoaded = true
+    })
   })
   const page = await context.newPage()
   page.setDefaultTimeout(process.env.CI ? 20000 : 10000)
   const source = page.locator('.api-source-details')
   const assertFirstFrame = async (open) => {
     await page.waitForFunction(() => window.__sourceFrames.length > 0)
-    assert.equal(await page.evaluate(() => window.__sourceFrames.at(-1).open), open,
-      'The first frame has the saved native disclosure state')
+    assert.equal(
+      await page.evaluate(() => window.__sourceFrames.at(-1).open),
+      open,
+      'The first frame has the saved native disclosure state',
+    )
     assert.equal(await source.evaluate((el) => el.open), open)
   }
   try {
@@ -50,7 +55,10 @@ export async function checkReferencePreferences(browser, base) {
         heading: document.querySelector('h1').getBoundingClientRect().top,
         header: document.querySelector('.site-header').getBoundingClientRect().bottom,
       }))
-      assert(overview.scroll < errorsScroll - 20, `Overview returns above Errors with source ${open ? 'open' : 'closed'}`)
+      assert(
+        overview.scroll < errorsScroll - 20,
+        `Overview returns above Errors with source ${open ? 'open' : 'closed'}`,
+      )
       assert(overview.heading >= overview.header && overview.heading < 350, 'Overview reveals the heading')
     }
     await page.reload()
@@ -76,16 +84,23 @@ export async function checkReferencePreferences(browser, base) {
     await other.locator('.api-source-details > summary').click()
     await page.waitForFunction(() => document.querySelector('.api-source-details').open)
     await other.close()
-    console.log('Source and package: default open, keyboard, reload, client route, cross-port/tab and first-frame state pass')
+    console.log(
+      'Source and package: default open, keyboard, reload, client route, cross-port/tab and first-frame state pass',
+    )
   } finally {
     await context.close()
   }
 
   for (const javaScriptEnabled of [false, true]) {
     const fallback = await browser.newContext({ javaScriptEnabled, reducedMotion: 'reduce' })
-    if (javaScriptEnabled) await fallback.addInitScript(() => {
-      Object.defineProperty(window, 'localStorage', { get() { throw new Error('Storage blocked') } })
-    })
+    if (javaScriptEnabled)
+      await fallback.addInitScript(() => {
+        Object.defineProperty(window, 'localStorage', {
+          get() {
+            throw new Error('Storage blocked')
+          },
+        })
+      })
     const page = await fallback.newPage()
     try {
       await page.goto(`${base}${path}`)
@@ -110,7 +125,13 @@ export async function checkGlobalHeader(browser, base) {
     const page = await context.newPage()
     const headerFrames = new Map()
     try {
-      for (const path of ['/', '/tmux/latest/manual/capture-pane/', '/py/latest/', '/ts/latest/', '/api-example-probe/']) {
+      for (const path of [
+        '/',
+        '/tmux/latest/manual/capture-pane/',
+        '/py/latest/',
+        '/ts/latest/',
+        '/api-example-probe/',
+      ]) {
         await page.goto(`${base}${path}`)
         await page.waitForFunction(() => document.fonts.status === 'loaded')
         for (const width of [280, 304, 390, 768, 784, 1024, 1440, 1600, 1920]) {
@@ -124,17 +145,32 @@ export async function checkGlobalHeader(browser, base) {
             const controls = document.querySelector('.site-header__always').getBoundingClientRect()
             const menu = document.querySelector('.site-header__menu-button').getBoundingClientRect()
             const bar = document.querySelector('.site-header__bar').getBoundingClientRect()
-            return { fits: document.documentElement.scrollWidth <= innerWidth + 1,
-              frame: { left: bar.left, width: bar.width, height: bar.height, wordmark: brand.left, controls: controls.left, menu: menu.left },
-              wordmarkVisible: brand.width > 40 && brand.height > 20
-                && getComputedStyle(document.querySelector('.site-header__wordmark')).clipPath === 'none',
-              separate: brand.right <= controls.left && controls.right <= menu.left }
+            return {
+              fits: document.documentElement.scrollWidth <= innerWidth + 1,
+              frame: {
+                left: bar.left,
+                width: bar.width,
+                height: bar.height,
+                wordmark: brand.left,
+                controls: controls.left,
+                menu: menu.left,
+              },
+              wordmarkVisible:
+                brand.width > 40 &&
+                brand.height > 20 &&
+                getComputedStyle(document.querySelector('.site-header__wordmark')).clipPath === 'none',
+              separate: brand.right <= controls.left && controls.right <= menu.left,
+            }
           })
           assert(geometry.fits && geometry.separate, `${path} at ${width}px: header controls fit without overlap`)
           assert(geometry.wordmarkVisible, `${path} at ${width}px: the wordmark remains a visible home link`)
           if (width >= 1600) {
             if (!headerFrames.has(width)) headerFrames.set(width, geometry.frame)
-            assert.deepEqual(geometry.frame, headerFrames.get(width), `${path} at ${width}px: global controls keep their homepage positions`)
+            assert.deepEqual(
+              geometry.frame,
+              headerFrames.get(width),
+              `${path} at ${width}px: global controls keep their homepage positions`,
+            )
           }
           await menu.locator(':scope > summary').click()
         }
@@ -147,7 +183,9 @@ export async function checkGlobalHeader(browser, base) {
       await context.close()
     }
   }
-  console.log('Global header: usable menu and home link, stable wide-screen positions across home, prose, ports and reference, 280–1920px with/without JavaScript')
+  console.log(
+    'Global header: usable menu and home link, stable wide-screen positions across home, prose, ports and reference, 280–1920px with/without JavaScript',
+  )
   await checkScrollbarStability(browser, base)
 }
 
@@ -155,64 +193,98 @@ export async function checkGlobalHeader(browser, base) {
 export async function checkScrollbarStability(browser, base) {
   const classic = await browser.browserType().launch({
     ignoreDefaultArgs: ['--hide-scrollbars'],
-    ...(browser.browserType().name() === 'chromium' ? {
-      channel: process.env.LIBTMUX_DOCS_BROWSER_CHANNEL,
-      args: ['--disable-features=OverlayScrollbar'],
-    } : {}),
+    ...(browser.browserType().name() === 'chromium'
+      ? {
+          channel: process.env.LIBTMUX_DOCS_BROWSER_CHANNEL,
+          args: ['--disable-features=OverlayScrollbar'],
+        }
+      : {}),
   })
   try {
-    for (const width of [280, 628, 1280]) for (const colorScheme of ['light', 'dark']) for (const javaScriptEnabled of [true, false]) {
-      const context = await classic.newContext({ viewport: { width, height: 900 }, colorScheme, javaScriptEnabled, reducedMotion: 'reduce' })
-      const page = await context.newPage()
-      const frame = () => page.evaluate(() => {
-        const rect = (selector) => {
-          const { x, y, width, height } = document.querySelector(selector).getBoundingClientRect()
-          return { x, y, width, height }
-        }
-        return {
-          scrolls: document.documentElement.scrollHeight > innerHeight,
-          scrollbar: innerWidth - document.documentElement.clientWidth,
-          overflow: document.documentElement.scrollWidth > innerWidth,
-          pickerWidth: rect('header [data-page-port-switcher] > summary').width,
-          controls: {
-            bar: rect('.site-header__bar'), wordmark: rect('.site-header__mark'),
-            toolbar: rect('.site-header__always'), menu: rect('.site-header__menu-button'),
-          },
+    for (const width of [280, 628, 1280])
+      for (const colorScheme of ['light', 'dark'])
+        for (const javaScriptEnabled of [true, false]) {
+          const context = await classic.newContext({
+            viewport: { width, height: 900 },
+            colorScheme,
+            javaScriptEnabled,
+            reducedMotion: 'reduce',
+          })
+          const page = await context.newPage()
+          const frame = () =>
+            page.evaluate(() => {
+              const rect = (selector) => {
+                const { x, y, width, height } = document.querySelector(selector).getBoundingClientRect()
+                return { x, y, width, height }
+              }
+              return {
+                scrolls: document.documentElement.scrollHeight > innerHeight,
+                scrollbar: innerWidth - document.documentElement.clientWidth,
+                overflow: document.documentElement.scrollWidth > innerWidth,
+                pickerWidth: rect('header [data-page-port-switcher] > summary').width,
+                controls: {
+                  bar: rect('.site-header__bar'),
+                  wordmark: rect('.site-header__mark'),
+                  toolbar: rect('.site-header__always'),
+                  menu: rect('.site-header__menu-button'),
+                },
+              }
+            })
+          // Wait for font layout before comparing header geometry.
+          const settle = () => page.evaluate(() => document.fonts.ready)
+          const label = `${width}px, ${colorScheme}, JavaScript ${javaScriptEnabled}`
+          try {
+            await page.goto(`${base}/?port=py`)
+            await settle()
+            const contentHeight = await page.evaluate(() => document.documentElement.scrollHeight)
+            await page.setViewportSize({ width, height: contentHeight + 128 })
+            await settle()
+            const home = await frame()
+            assert(!home.scrolls, `${label}: the real homepage fits the viewport`)
+            assert(!home.overflow, `${label}: the homepage has no horizontal overflow`)
+            await page.goto(`${base}/ts/latest/reference/server-server/`)
+            await settle()
+            const reference = await frame()
+            assert(
+              reference.scrolls && reference.scrollbar > 0,
+              `${label}: the reference exercises a real classic scrollbar: ${JSON.stringify(reference)}`,
+            )
+            assert(!reference.overflow, `${label}: the reference has no horizontal overflow`)
+            assert.deepEqual(
+              reference.controls,
+              home.controls,
+              `${label}: a classic scrollbar does not move the shared header`,
+            )
+            // At 280px the homepage picker shares its row with the solution control.
+            if (width >= 628)
+              assert.equal(
+                reference.pickerWidth,
+                home.pickerWidth,
+                `${label}: the unconstrained language picker keeps its width`,
+              )
+            await page.locator('.site-header__mark').click()
+            await page.waitForURL(`${base}/`)
+            await settle()
+            const returned = await frame()
+            assert(!returned.scrolls, `${label}: returning home removes the need to scroll`)
+            assert.deepEqual(
+              returned.controls,
+              home.controls,
+              `${label}: returning to a short page preserves header positions`,
+            )
+            assert.equal(
+              returned.pickerWidth,
+              home.pickerWidth,
+              `${label}: returning home preserves its constrained picker width`,
+            )
+          } finally {
+            await context.close()
+          }
         }
-      })
-      // Wait for font layout before comparing header geometry.
-      const settle = () => page.evaluate(() => document.fonts.ready)
-      const label = `${width}px, ${colorScheme}, JavaScript ${javaScriptEnabled}`
-      try {
-        await page.goto(`${base}/?port=py`)
-        await settle()
-        const contentHeight = await page.evaluate(() => document.documentElement.scrollHeight)
-        await page.setViewportSize({ width, height: contentHeight + 128 })
-        await settle()
-        const home = await frame()
-        assert(!home.scrolls, `${label}: the real homepage fits the viewport`)
-        assert(!home.overflow, `${label}: the homepage has no horizontal overflow`)
-        await page.goto(`${base}/ts/latest/reference/server-server/`)
-        await settle()
-        const reference = await frame()
-        assert(reference.scrolls && reference.scrollbar > 0, `${label}: the reference exercises a real classic scrollbar: ${JSON.stringify(reference)}`)
-        assert(!reference.overflow, `${label}: the reference has no horizontal overflow`)
-        assert.deepEqual(reference.controls, home.controls, `${label}: a classic scrollbar does not move the shared header`)
-        // At 280px the homepage picker shares its row with the solution control.
-        if (width >= 628) assert.equal(reference.pickerWidth, home.pickerWidth, `${label}: the unconstrained language picker keeps its width`)
-        await page.locator('.site-header__mark').click()
-        await page.waitForURL(`${base}/`)
-        await settle()
-        const returned = await frame()
-        assert(!returned.scrolls, `${label}: returning home removes the need to scroll`)
-        assert.deepEqual(returned.controls, home.controls, `${label}: returning to a short page preserves header positions`)
-        assert.equal(returned.pickerWidth, home.pickerWidth, `${label}: returning home preserves its constrained picker width`)
-      } finally {
-        await context.close()
-      }
-    }
   } finally {
     await classic.close()
   }
-  console.log('Classic scrollbars: short and long pages retain header positions in both themes, with and without JavaScript')
+  console.log(
+    'Classic scrollbars: short and long pages retain header positions in both themes, with and without JavaScript',
+  )
 }
diff --git a/site/scripts/check-ruby-lua.mjs b/site/scripts/check-ruby-lua.mjs
index 558a7b533..2075539ca 100644
--- a/site/scripts/check-ruby-lua.mjs
+++ b/site/scripts/check-ruby-lua.mjs
@@ -68,8 +68,10 @@ for (const scheme of ['light', 'dark']) {
           }
           return top?.querySelector(':scope > [role="group"] > li:first-child a')?.getAttribute('href')
         })
-        check(firstPublicObject === new URL(BASE + path).pathname,
-          `${scheme}/${viewport}: Lua Server is not the first public Server object`)
+        check(
+          firstPublicObject === new URL(BASE + path).pathname,
+          `${scheme}/${viewport}: Lua Server is not the first public Server object`,
+        )
       }
     }
 
@@ -81,17 +83,29 @@ for (const scheme of ['light', 'dark']) {
       check(response?.ok(), `${scheme}/${viewport}: ${name} landing returned ${response?.status() ?? 'no response'}`)
       if (!response?.ok()) continue
       const targetPath = new URL(`${BASE}${target}`).pathname
-      const count = await page.locator('main a[href]').evaluateAll((links, expected) =>
-        links.filter((link) => new URL(link.href).pathname === expected.target && (link.textContent ?? '').includes(expected.label)).length,
-      { target: targetPath, label })
+      const count = await page
+        .locator('main a[href]')
+        .evaluateAll(
+          (links, expected) =>
+            links.filter(
+              (link) =>
+                new URL(link.href).pathname === expected.target && (link.textContent ?? '').includes(expected.label),
+            ).length,
+          { target: targetPath, label },
+        )
       check(count === 1, `${scheme}/${viewport}: ${name} landing has ${label}`)
     }
     const luaResponse = await page.goto(`${BASE}/lua/latest/`, { waitUntil: 'networkidle' })
-    check(luaResponse?.ok(), `${scheme}/${viewport}: Lua availability landing returned ${luaResponse?.status() ?? 'no response'}`)
+    check(
+      luaResponse?.ok(),
+      `${scheme}/${viewport}: Lua availability landing returned ${luaResponse?.status() ?? 'no response'}`,
+    )
     if (luaResponse?.ok()) {
       for (const product of ['mcp', 'workspace']) {
-        const offered = page.locator(`main a[href$="/lua/latest/${product}/"], [data-surface-picker] a[href$="/lua/latest/${product}/"]`)
-        check(await offered.count() === 0, `${scheme}/${viewport}: Lua offers unavailable ${product}`)
+        const offered = page.locator(
+          `main a[href$="/lua/latest/${product}/"], [data-surface-picker] a[href$="/lua/latest/${product}/"]`,
+        )
+        check((await offered.count()) === 0, `${scheme}/${viewport}: Lua offers unavailable ${product}`)
       }
     }
 
@@ -104,35 +118,61 @@ for (const scheme of ['light', 'dark']) {
         const option = language.locator(`a[data-port="${port}"]`)
         await option.focus()
         await option.press('Enter')
-        await page.waitForFunction((port) => document.querySelector('.lm-agent-prompt')?.dataset.activePort === port, port)
-        check(new URL(page.url()).searchParams.get('port') === port,
-          `${scheme}/${viewport}: keyboard language selection did not select ${port}`)
+        await page.waitForFunction(
+          (port) => document.querySelector('.lm-agent-prompt')?.dataset.activePort === port,
+          port,
+        )
+        check(
+          new URL(page.url()).searchParams.get('port') === port,
+          `${scheme}/${viewport}: keyboard language selection did not select ${port}`,
+        )
       }
       const install = (port) => page.locator(`.home-examples > [data-home-language="${port}"] .lm-pkg-install`)
       await choose('ruby')
       check(await install('ruby').isVisible(), `${scheme}/${viewport}: Ruby install is not visible`)
-      check(await install('ruby').locator('code').first().textContent().then((text) => /gem install/.test(text ?? '')),
-        `${scheme}/${viewport}: Ruby install command is missing`)
+      check(
+        await install('ruby')
+          .locator('code')
+          .first()
+          .textContent()
+          .then((text) => /gem install/.test(text ?? '')),
+        `${scheme}/${viewport}: Ruby install command is missing`,
+      )
       await choose('lua')
-      check(await install('lua').isVisible() && !(await install('ruby').isVisible()),
-        `${scheme}/${viewport}: Lua selection did not replace the Ruby install`)
-      check(await install('lua').locator('code').first().textContent().then((text) => /luarocks\s+(?:--local\s+)?install/.test(text ?? '')),
-        `${scheme}/${viewport}: Lua install command is missing`)
+      check(
+        (await install('lua').isVisible()) && !(await install('ruby').isVisible()),
+        `${scheme}/${viewport}: Lua selection did not replace the Ruby install`,
+      )
+      check(
+        await install('lua')
+          .locator('code')
+          .first()
+          .textContent()
+          .then((text) => /luarocks\s+(?:--local\s+)?install/.test(text ?? '')),
+        `${scheme}/${viewport}: Lua install command is missing`,
+      )
       await choose('ruby')
       const copy = install('ruby').locator('.lm-pkg-install__copy').first()
       await copy.click()
-      await copy.filter({ hasText: /copied/i }).waitFor({ timeout: 1000 }).catch(() => {})
-      check(await copy.textContent().then((text) => /copied/i.test(text ?? '')),
-        `${scheme}/${viewport}: Ruby copy control did not confirm the copy`)
-      check(await page.evaluate(() => navigator.clipboard.readText()).then((text) => /gem install/.test(text)),
-        `${scheme}/${viewport}: Ruby copy control wrote the wrong command`)
+      await copy
+        .filter({ hasText: /copied/i })
+        .waitFor({ timeout: 1000 })
+        .catch(() => {})
+      check(
+        await copy.textContent().then((text) => /copied/i.test(text ?? '')),
+        `${scheme}/${viewport}: Ruby copy control did not confirm the copy`,
+      )
+      check(
+        await page.evaluate(() => navigator.clipboard.readText()).then((text) => /gem install/.test(text)),
+        `${scheme}/${viewport}: Ruby copy control wrote the wrong command`,
+      )
 
       await page.keyboard.press('Control+k')
       const search = page.locator('#search-modal input[type="search"]')
       await search.fill('Ruby Async')
       const result = page.locator('#search-modal .search-panel__results a[href*="/ruby/latest/"]').first()
       await result.waitFor({ timeout: 5000 }).catch(() => {})
-      check(await result.count() > 0, `${scheme}/${viewport}: search returned no Ruby result`)
+      check((await result.count()) > 0, `${scheme}/${viewport}: search returned no Ruby result`)
     }
     await context.close()
   }
diff --git a/site/scripts/check-style-parity.mjs b/site/scripts/check-style-parity.mjs
index 343363db3..e5f54925c 100755
--- a/site/scripts/check-style-parity.mjs
+++ b/site/scripts/check-style-parity.mjs
@@ -119,7 +119,16 @@ const CASES = [
 ]
 
 /** Properties whose value is a length that legitimately tracks the base font. */
-const NEAR = new Set(['paddingTop', 'paddingBottom', 'paddingLeft', 'marginBottom', 'marginLeft', 'minHeight', 'borderRadius', 'letterSpacing'])
+const NEAR = new Set([
+  'paddingTop',
+  'paddingBottom',
+  'paddingLeft',
+  'marginBottom',
+  'marginLeft',
+  'minHeight',
+  'borderRadius',
+  'letterSpacing',
+])
 
 /** A measure within a few characters of gp-sphinx's reads the same. */
 const WIDTH_TOLERANCE_PX = 12
@@ -179,9 +188,7 @@ const attributeCases = CASES.filter((c) => c.page === 'attribute')
 const fromMethod = await styles(page, OURS, methodCases, 'ours')
 const fromAttribute = await styles(page, OURS_ATTRIBUTE, attributeCases, 'ours')
 const ours = CASES.map((c) =>
-  c.page === 'attribute'
-    ? fromAttribute[attributeCases.indexOf(c)]
-    : fromMethod[methodCases.indexOf(c)],
+  c.page === 'attribute' ? fromAttribute[attributeCases.indexOf(c)] : fromMethod[methodCases.indexOf(c)],
 )
 await browser.close()
 
diff --git a/site/scripts/check-tables.mjs b/site/scripts/check-tables.mjs
index 1c5fc1e94..5d943eb85 100644
--- a/site/scripts/check-tables.mjs
+++ b/site/scripts/check-tables.mjs
@@ -41,19 +41,20 @@ try {
         tables: [...document.querySelectorAll('table')].map((table) => {
           const head = [...(table.tHead?.rows[0]?.cells ?? [])]
           const body = [...(table.tBodies[0]?.rows[0]?.cells ?? [])]
-          const comparable = head.length === body.length &&
-            [...head, ...body].every((cell) => cell.colSpan === 1)
+          const comparable = head.length === body.length && [...head, ...body].every((cell) => cell.colSpan === 1)
           return {
-            columns: comparable ? head.map((cell, i) =>
-              Math.abs(cell.getBoundingClientRect().x - body[i].getBoundingClientRect().x),
-            ) : [],
+            columns: comparable
+              ? head.map((cell, i) => Math.abs(cell.getBoundingClientRect().x - body[i].getBoundingClientRect().x))
+              : [],
           }
         }),
       }))
       assert(result.pageOverflow <= 1, `${path} at ${width}px: page overflows by ${result.pageOverflow}px`)
       for (const table of result.tables) {
-        assert(table.columns.every((offset) => offset <= 1),
-          `${path} at ${width}px: header/body columns differ by ${table.columns.join(', ')}px`)
+        assert(
+          table.columns.every((offset) => offset <= 1),
+          `${path} at ${width}px: header/body columns differ by ${table.columns.join(', ')}px`,
+        )
         checked++
       }
     }
diff --git a/site/src/components/api/api-tree-state.ts b/site/src/components/api/api-tree-state.ts
index 2955dacf8..46bcc61dc 100644
--- a/site/src/components/api/api-tree-state.ts
+++ b/site/src/components/api/api-tree-state.ts
@@ -51,11 +51,15 @@ export function captureApiTree(nav: HTMLElement, tree: HTMLElement): ApiTreeStat
       }
       const link = row.matches('a') ? row : row.querySelector('a')
       const mark = row.querySelector<HTMLElement>('.api-nav__kind')
-      return { label: text, href: link?.getAttribute('href') ?? undefined,
+      return {
+        label: text,
+        href: link?.getAttribute('href') ?? undefined,
         kind: entry.getAttribute('aria-description') ?? row.getAttribute('aria-description') ?? undefined,
-        mark: mark?.textContent?.trim(), lazy: (entry as HTMLElement).dataset.lazy,
+        mark: mark?.textContent?.trim(),
+        lazy: (entry as HTMLElement).dataset.lazy,
         count: row.querySelector('.api-nav__count')?.textContent?.trim(),
-        ...(link?.hasAttribute('data-api-shortcut') ? { shortcut: true } : {}) }
+        ...(link?.hasAttribute('data-api-shortcut') ? { shortcut: true } : {}),
+      }
     })
   }
   return { top: tree.scrollTop, branches, version: nav.dataset.version, groups }
@@ -71,16 +75,27 @@ export function initializeApiTree(nav: HTMLElement | null, restoreState = true):
   let saved: ApiTreeState | undefined
   try {
     const value = JSON.parse(window.sessionStorage.getItem(`libtmux:api-tree:${nav.dataset.base}`) ?? 'null')
-    if (Number.isFinite(value?.top) && value.top >= 0 && value.branches && typeof value.branches === 'object') saved = value
-  } catch { /* Navigation remains usable without session storage. */ }
+    if (Number.isFinite(value?.top) && value.top >= 0 && value.branches && typeof value.branches === 'object')
+      saved = value
+  } catch {
+    /* Navigation remains usable without session storage. */
+  }
   let selection: ApiTreeSelection | undefined
   try {
     const incoming = nav.hasAttribute('data-api-tree-arrival')
     const value = incoming ? JSON.parse(nav.dataset.apiTreeArrival!) : window.history.state?.libtmuxApiTree
-    if (value?.base === nav.dataset.base && value.version === nav.dataset.version &&
-        typeof value.version === 'string' && value.href === window.location.pathname + window.location.search &&
-        Array.isArray(value.path) && value.path.length <= 32 && value.path.every((part: unknown) => typeof part === 'string') &&
-        Number.isFinite(value.top) && value.top >= 0) selection = value
+    if (
+      value?.base === nav.dataset.base &&
+      value.version === nav.dataset.version &&
+      typeof value.version === 'string' &&
+      value.href === window.location.pathname + window.location.search &&
+      Array.isArray(value.path) &&
+      value.path.length <= 32 &&
+      value.path.every((part: unknown) => typeof part === 'string') &&
+      Number.isFinite(value.top) &&
+      value.top >= 0
+    )
+      selection = value
     if (incoming) {
       const state = { ...window.history.state }
       delete state.libtmuxApiTree
@@ -88,7 +103,9 @@ export function initializeApiTree(nav: HTMLElement | null, restoreState = true):
       window.history.replaceState(state, '')
       delete nav.dataset.apiTreeArrival
     }
-  } catch { /* A direct arrival retains its canonical selection. */ }
+  } catch {
+    /* A direct arrival retains its canonical selection. */
+  }
   // A new model, nav ordering, or renderer must not resurrect stale links.
   const groups = saved?.version && saved.version === nav.dataset.version ? saved.groups : undefined
   let seq = 0
@@ -132,7 +149,10 @@ export function initializeApiTree(nav: HTMLElement | null, restoreState = true):
         }
       }
       // Saved labels are text, never HTML; links remain local HTTP paths.
-      const href = typeof entry.href === 'string' && /^\/(?!\/)/.test(entry.href) && !entry.href.includes('\\') ? entry.href : undefined
+      const href =
+        typeof entry.href === 'string' && /^\/(?!\/)/.test(entry.href) && !entry.href.includes('\\')
+          ? entry.href
+          : undefined
       const label = element(entry.lazy && href ? 'a' : 'span', 'api-nav__label')
       for (const [j, part] of entry.label.entries()) {
         if (j) label.append(document.createElement('wbr'))
@@ -165,7 +185,8 @@ export function initializeApiTree(nav: HTMLElement | null, restoreState = true):
     if (depth > 32) return
     for (const item of root.querySelectorAll<HTMLElement>(':scope > [role="treeitem"][data-lazy]')) {
       const current = Boolean(item.querySelector('[aria-current="page"]'))
-      const open = current || selection?.path.includes(item.dataset.lazy!) || saved?.branches[item.dataset.lazy!] === true
+      const open =
+        current || selection?.path.includes(item.dataset.lazy!) || saved?.branches[item.dataset.lazy!] === true
       let group = item.querySelector<HTMLElement>(':scope > [role="group"]')
       const cached = groups?.[item.dataset.lazy!]
       if (open && !group && Array.isArray(cached)) {
@@ -177,15 +198,17 @@ export function initializeApiTree(nav: HTMLElement | null, restoreState = true):
     }
   }
   if (restoreState && (saved || selection)) restore(tree)
-  const selected = selection && [...tree.querySelectorAll<HTMLElement>('a[data-api-shortcut]')].find((link) => {
-    const href = new URL(link.getAttribute('href')!, window.location.href)
-    if (href.origin !== window.location.origin || href.pathname + href.search !== selection!.href) return false
-    const path: string[] = []
-    for (let node = link.parentElement; node && node !== tree; node = node.parentElement) {
-      if (node.dataset.lazy) path.unshift(node.dataset.lazy)
-    }
-    return JSON.stringify(path) === JSON.stringify(selection!.path)
-  })
+  const selected =
+    selection &&
+    [...tree.querySelectorAll<HTMLElement>('a[data-api-shortcut]')].find((link) => {
+      const href = new URL(link.getAttribute('href')!, window.location.href)
+      if (href.origin !== window.location.origin || href.pathname + href.search !== selection!.href) return false
+      const path: string[] = []
+      for (let node = link.parentElement; node && node !== tree; node = node.parentElement) {
+        if (node.dataset.lazy) path.unshift(node.dataset.lazy)
+      }
+      return JSON.stringify(path) === JSON.stringify(selection!.path)
+    })
   if (selected) {
     for (const link of tree.querySelectorAll('[aria-current="page"]')) link.removeAttribute('aria-current')
     selected.setAttribute('aria-current', 'page')
@@ -209,7 +232,13 @@ export function initializeApiTree(nav: HTMLElement | null, restoreState = true):
     }
   }
   for (const event of ['wheel', 'pointerdown', 'keydown']) {
-    tree.addEventListener(event, () => { nav.dataset.apiTreeInteracted = 'true' }, { once: true })
+    tree.addEventListener(
+      event,
+      () => {
+        nav.dataset.apiTreeInteracted = 'true'
+      },
+      { once: true },
+    )
   }
   nav.dataset.apiTreeInitialized = 'true'
   return selection
diff --git a/site/src/components/api/api-tree.ts b/site/src/components/api/api-tree.ts
index 7a97209eb..a556dcd70 100644
--- a/site/src/components/api/api-tree.ts
+++ b/site/src/components/api/api-tree.ts
@@ -11,8 +11,19 @@
  */
 import { wordBreak } from '../../lib/word-break'
 import { kindMark } from '../../lib/api-labels'
-import { apiTreeHref, searchApi, type ApiTreeBucket as JsonBucket, type ApiTreeJson as TreeJson } from '../../lib/api-search'
-import { apiTreePath, captureApiTree, initializeApiTree, type ApiTreeSelection, type ApiTreeState } from './api-tree-state'
+import {
+  apiTreeHref,
+  searchApi,
+  type ApiTreeBucket as JsonBucket,
+  type ApiTreeJson as TreeJson,
+} from '../../lib/api-search'
+import {
+  apiTreePath,
+  captureApiTree,
+  initializeApiTree,
+  type ApiTreeSelection,
+  type ApiTreeState,
+} from './api-tree-state'
 
 const ITEM = '[role="treeitem"]'
 const EASING = 'cubic-bezier(0.8, 0, 0.2, 1)'
@@ -27,19 +38,36 @@ export function saveApiTreeState(event?: Event) {
   for (const nav of document.querySelectorAll<HTMLElement>('.api-nav')) {
     const tree = nav.querySelector<HTMLElement>('[role="tree"]')
     if (!tree || nav.dataset.restoring === 'true') continue
-    try { window.sessionStorage.setItem(stateKey(nav), JSON.stringify(captureApiTree(nav, tree))) } catch { /* Storage is optional. */ }
+    try {
+      window.sessionStorage.setItem(stateKey(nav), JSON.stringify(captureApiTree(nav, tree)))
+    } catch {
+      /* Storage is optional. */
+    }
   }
-  const transition = event as (Event & { newDocument?: Document; to?: URL; sourceElement?: HTMLElement; navigationType?: string }) | undefined
+  const transition = event as
+    | (Event & { newDocument?: Document; to?: URL; sourceElement?: HTMLElement; navigationType?: string })
+    | undefined
   if (!transition?.newDocument || !transition.to || transition.navigationType === 'traverse') return
   const link = transition.sourceElement?.closest<HTMLAnchorElement>('.api-nav__tree a[data-api-shortcut]')
   const nav = link?.closest<HTMLElement>('.api-nav')
   const tree = nav?.querySelector<HTMLElement>('[role="tree"]')
   for (const incoming of transition.newDocument.querySelectorAll<HTMLElement>('.api-nav')) {
-    const selection: ApiTreeSelection | null = link && nav && tree &&
-      incoming.dataset.base === nav.dataset.base && incoming.dataset.version === nav.dataset.version &&
-      link.origin === transition.to.origin && link.pathname + link.search === transition.to.pathname + transition.to.search
-      ? { base: nav.dataset.base!, version: nav.dataset.version!, href: link.pathname + link.search,
-        path: apiTreePath(link, tree), top: tree.scrollTop } : null
+    const selection: ApiTreeSelection | null =
+      link &&
+      nav &&
+      tree &&
+      incoming.dataset.base === nav.dataset.base &&
+      incoming.dataset.version === nav.dataset.version &&
+      link.origin === transition.to.origin &&
+      link.pathname + link.search === transition.to.pathname + transition.to.search
+        ? {
+            base: nav.dataset.base!,
+            version: nav.dataset.version!,
+            href: link.pathname + link.search,
+            path: apiTreePath(link, tree),
+            top: tree.scrollTop,
+          }
+        : null
     incoming.dataset.apiTreeArrival = JSON.stringify(selection)
   }
 }
@@ -50,22 +78,36 @@ async function restoreTree(nav: HTMLElement, tree: HTMLElement, signal: AbortSig
   let saved: ApiTreeState | undefined
   try {
     const value = JSON.parse(window.sessionStorage.getItem(stateKey(nav)) ?? 'null')
-    if (Number.isFinite(value?.top) && value.top >= 0 && value.branches && typeof value.branches === 'object') saved = value
-  } catch { /* A fresh or storage-restricted page still reveals its current row. */ }
+    if (Number.isFinite(value?.top) && value.top >= 0 && value.branches && typeof value.branches === 'object')
+      saved = value
+  } catch {
+    /* A fresh or storage-restricted page still reveals its current row. */
+  }
   nav.dataset.restoring = 'true'
   let interacted = nav.dataset.apiTreeInteracted === 'true'
   for (const event of ['wheel', 'pointerdown', 'keydown']) {
-    tree.addEventListener(event, () => { interacted = true }, { signal, once: true })
+    tree.addEventListener(
+      event,
+      () => {
+        interacted = true
+      },
+      { signal, once: true },
+    )
   }
   if (saved || selection) {
     const restore = async (root: HTMLElement) => {
       for (const item of root.querySelectorAll<HTMLElement>(':scope > [role="treeitem"][data-lazy]')) {
         if (signal.aborted || interacted) return
         const current = Boolean(item.querySelector('[aria-current="page"]'))
-        const open = current || selection?.path.includes(item.dataset.lazy!) || saved?.branches[item.dataset.lazy!] === true
+        const open =
+          current || selection?.path.includes(item.dataset.lazy!) || saved?.branches[item.dataset.lazy!] === true
         let group = item.querySelector<HTMLElement>(':scope > [role="group"]')
         if (open && !group) {
-          try { group = await build(nav, item) ?? null } catch { /* Keep the branch retryable. */ }
+          try {
+            group = (await build(nav, item)) ?? null
+          } catch {
+            /* Keep the branch retryable. */
+          }
         }
         if (signal.aborted || interacted) return
         if (group || !open) item.setAttribute('aria-expanded', String(open))
@@ -77,15 +119,23 @@ async function restoreTree(nav: HTMLElement, tree: HTMLElement, signal: AbortSig
   if (signal.aborted || !tree.isConnected) return
   initializeApiTree(nav, false)
   const currentShortcut = tree.querySelector<HTMLElement>('a[data-api-shortcut][aria-current="page"]')
-  const selectedTop = currentShortcut && selection && JSON.stringify(apiTreePath(currentShortcut, tree)) === JSON.stringify(selection.path)
-    ? selection.top : undefined
+  const selectedTop =
+    currentShortcut &&
+    selection &&
+    JSON.stringify(apiTreePath(currentShortcut, tree)) === JSON.stringify(selection.path)
+      ? selection.top
+      : undefined
   if (!interacted && (selectedTop !== undefined || saved)) tree.scrollTop = selectedTop ?? saved!.top
   const reveal = () => {
     if (signal.aborted || !tree.isConnected || interacted) return
     const current = tree.querySelector<HTMLElement>('[aria-current="page"]')
     const row = current?.closest<HTMLElement>('.api-nav__row') ?? current
     if (!row || !tree.clientHeight) return
-    for (let owner = row.closest<HTMLElement>('[aria-expanded]'); owner; owner = owner.parentElement?.closest<HTMLElement>('[aria-expanded]') ?? null) {
+    for (
+      let owner = row.closest<HTMLElement>('[aria-expanded]');
+      owner;
+      owner = owner.parentElement?.closest<HTMLElement>('[aria-expanded]') ?? null
+    ) {
       owner.setAttribute('aria-expanded', 'true')
     }
     const box = tree.getBoundingClientRect()
@@ -115,15 +165,30 @@ function initSearch(nav: HTMLElement, tree: HTMLElement, signal: AbortSignal) {
   let generation = 0
   input.disabled = false
   for (const button of filters) button.disabled = button.hasAttribute('data-api-search-empty')
-  document.addEventListener('keydown', (event) => {
-    if (event.key !== '/' || event.defaultPrevented || event.isComposing || event.metaKey || event.ctrlKey || event.altKey) return
-    const target = event.target as Element
-    if (target.closest('input, textarea, select, [role="textbox"], [contenteditable]:not([contenteditable="false"])') ||
-        document.querySelector('dialog[open]')) return
-    event.preventDefault()
-    if (nav.inert) document.querySelector<HTMLButtonElement>('[data-api-nav-toggle]')?.click()
-    input.focus({ preventScroll: true })
-  }, { signal })
+  document.addEventListener(
+    'keydown',
+    (event) => {
+      if (
+        event.key !== '/' ||
+        event.defaultPrevented ||
+        event.isComposing ||
+        event.metaKey ||
+        event.ctrlKey ||
+        event.altKey
+      )
+        return
+      const target = event.target as Element
+      if (
+        target.closest('input, textarea, select, [role="textbox"], [contenteditable]:not([contenteditable="false"])') ||
+        document.querySelector('dialog[open]')
+      )
+        return
+      event.preventDefault()
+      if (nav.inert) document.querySelector<HTMLButtonElement>('[data-api-nav-toggle]')?.click()
+      input.focus({ preventScroll: true })
+    },
+    { signal },
+  )
   const render = async () => {
     const ownGeneration = ++generation
     const query = input.value.trim()
@@ -138,8 +203,10 @@ function initSearch(nav: HTMLElement, tree: HTMLElement, signal: AbortSignal) {
       const json = await load(nav.dataset.src ?? '')
       if (signal.aborted || generation !== ownGeneration) return
       const found = searchApi(json, query, kind)
-      status.textContent = found.length > 100 ? `Showing 100 of ${found.length} results. Refine your search.`
-        : `${found.length} ${found.length === 1 ? 'result' : 'results'}`
+      status.textContent =
+        found.length > 100
+          ? `Showing 100 of ${found.length} results. Refine your search.`
+          : `${found.length} ${found.length === 1 ? 'result' : 'results'}`
       for (const record of found.slice(0, 100)) {
         const li = document.createElement('li')
         const link = document.createElement('a')
@@ -164,35 +231,56 @@ function initSearch(nav: HTMLElement, tree: HTMLElement, signal: AbortSignal) {
   }
   input.addEventListener('input', () => void render(), { signal })
   retry?.addEventListener('click', () => void render(), { signal })
-  for (const button of filters) button.addEventListener('click', () => {
-    kind = button.dataset.apiSearchKind ?? 'all'
-    for (const filter of filters) filter.setAttribute('aria-pressed', String(filter === button))
-    void render()
-  }, { signal })
-  input.addEventListener('keydown', (event) => {
-    if (event.key === 'ArrowDown') {
-      results.querySelector<HTMLAnchorElement>('a')?.focus()
+  for (const button of filters)
+    button.addEventListener(
+      'click',
+      () => {
+        kind = button.dataset.apiSearchKind ?? 'all'
+        for (const filter of filters) filter.setAttribute('aria-pressed', String(filter === button))
+        void render()
+      },
+      { signal },
+    )
+  input.addEventListener(
+    'keydown',
+    (event) => {
+      if (event.key === 'ArrowDown') {
+        results.querySelector<HTMLAnchorElement>('a')?.focus()
+        event.preventDefault()
+      } else if (event.key === 'Escape' && (input.value || kind !== 'all')) {
+        event.stopPropagation()
+        input.value = ''
+        filters[0]?.click()
+      }
+    },
+    { signal },
+  )
+  results.addEventListener(
+    'keydown',
+    (event) => {
+      const links = [...results.querySelectorAll<HTMLAnchorElement>('a')]
+      const current = links.indexOf(document.activeElement as HTMLAnchorElement)
+      if (event.key === 'Escape') {
+        input.focus()
+        return
+      }
+      const next =
+        event.key === 'ArrowDown'
+          ? current + 1
+          : event.key === 'ArrowUp'
+            ? current - 1
+            : event.key === 'Home'
+              ? 0
+              : event.key === 'End'
+                ? links.length - 1
+                : undefined
+      if (next === undefined) return
       event.preventDefault()
-    } else if (event.key === 'Escape' && (input.value || kind !== 'all')) {
-      event.stopPropagation()
-      input.value = ''
-      filters[0]?.click()
-    }
-  }, { signal })
-  results.addEventListener('keydown', (event) => {
-    const links = [...results.querySelectorAll<HTMLAnchorElement>('a')]
-    const current = links.indexOf(document.activeElement as HTMLAnchorElement)
-    if (event.key === 'Escape') {
-      input.focus()
-      return
-    }
-    const next = event.key === 'ArrowDown' ? current + 1 : event.key === 'ArrowUp' ? current - 1
-      : event.key === 'Home' ? 0 : event.key === 'End' ? links.length - 1 : undefined
-    if (next === undefined) return
-    event.preventDefault()
-    if (next < 0) input.focus()
-    else links[Math.min(next, links.length - 1)]?.focus()
-  }, { signal })
+      if (next < 0) input.focus()
+      else links[Math.min(next, links.length - 1)]?.focus()
+    },
+    { signal },
+  )
 }
 
 function load(src: string): Promise<TreeJson> {
@@ -213,7 +301,11 @@ const reducedMotion = () => window.matchMedia('(prefers-reduced-motion: reduce)'
 
 /** A row is visible when every branch above it is expanded. */
 function shown(item: HTMLElement): boolean {
-  for (let group = item.parentElement?.closest('[role="group"]'); group; group = group.parentElement?.closest('[role="group"]')) {
+  for (
+    let group = item.parentElement?.closest('[role="group"]');
+    group;
+    group = group.parentElement?.closest('[role="group"]')
+  ) {
     if (group.closest(ITEM)?.getAttribute('aria-expanded') !== 'true') return false
   }
   return true
@@ -223,7 +315,12 @@ const rows = (tree: HTMLElement) => [...tree.querySelectorAll<HTMLElement>(ITEM)
 const isBranch = (item: HTMLElement) => item.hasAttribute('aria-expanded')
 const isOpen = (item: HTMLElement) => item.getAttribute('aria-expanded') === 'true'
 const labelOf = (item: HTMLElement) =>
-  (item.matches('a') ? item.querySelector('.api-nav__label') : item.querySelector(':scope > .api-nav__row > .api-nav__label'))?.textContent?.trim().toLowerCase() ?? ''
+  (item.matches('a')
+    ? item.querySelector('.api-nav__label')
+    : item.querySelector(':scope > .api-nav__row > .api-nav__label')
+  )?.textContent
+    ?.trim()
+    .toLowerCase() ?? ''
 
 function focusRow(tree: HTMLElement, item: HTMLElement | undefined | null) {
   if (!item) return
@@ -233,7 +330,9 @@ function focusRow(tree: HTMLElement, item: HTMLElement | undefined | null) {
   item.focus({ preventScroll: true })
   // The tree scrolls, never the page: scrollIntoView would move every
   // scrolling ancestor, the document included.
-  const row = (item.matches('a') ? item : item.querySelector<HTMLElement>(':scope > .api-nav__row'))?.getBoundingClientRect()
+  const row = (
+    item.matches('a') ? item : item.querySelector<HTMLElement>(':scope > .api-nav__row')
+  )?.getBoundingClientRect()
   const box = tree.getBoundingClientRect()
   if (!row) return
   if (row.top < box.top) tree.scrollTop -= box.top - row.top
@@ -284,7 +383,15 @@ function leaf(name: string, href: string, level: number, kind?: string, shortcut
   return li
 }
 
-function branch(name: string, href: string | undefined, level: number, lazy: string, count?: number, kind?: string, shortcut = false): HTMLLIElement {
+function branch(
+  name: string,
+  href: string | undefined,
+  level: number,
+  lazy: string,
+  count?: number,
+  kind?: string,
+  shortcut = false,
+): HTMLLIElement {
   const id = `api-nav-c${++seq}`
   const li = document.createElement('li')
   li.setAttribute('role', 'treeitem')
@@ -357,7 +464,11 @@ async function build(nav: HTMLElement, item: HTMLElement): Promise<HTMLElement |
     if (!bucket) return undefined
     for (const t of bucket.types) {
       const href = apiTreeHref(base, t, json.hrefs)
-      children.push(t.m ? branch(t.name, href, level, `type:${t.id}`, undefined, t.kind, t.shortcut) : leaf(t.name, href, level, t.kind, t.shortcut))
+      children.push(
+        t.m
+          ? branch(t.name, href, level, `type:${t.id}`, undefined, t.kind, t.shortcut)
+          : leaf(t.name, href, level, t.kind, t.shortcut),
+      )
     }
     for (const c of bucket.children) {
       children.push(branch(c.label, c.slug ? `${base}${c.slug}/` : undefined, level, `bucket:${c.id}`, c.types.length))
@@ -365,9 +476,11 @@ async function build(nav: HTMLElement, item: HTMLElement): Promise<HTMLElement |
   } else {
     for (const [name, slug, memberId, kind] of json.members[id] ?? []) {
       const href = apiTreeHref(base, { id: memberId, slug }, json.hrefs)
-      children.push(memberId && json.members[memberId]?.length
-        ? branch(name, href, level, `type:${memberId}`, undefined, kind)
-        : leaf(name, href, level, kind))
+      children.push(
+        memberId && json.members[memberId]?.length
+          ? branch(name, href, level, `type:${memberId}`, undefined, kind)
+          : leaf(name, href, level, kind),
+      )
     }
   }
   const group = document.createElement('ul')
@@ -393,7 +506,15 @@ function animate(group: HTMLElement, open: boolean) {
   const height = `${group.scrollHeight}px`
   group.style.overflow = 'hidden'
   const animation = group.animate(
-    open ? [{ maxHeight: '0px', opacity: 0 }, { maxHeight: height, opacity: 1 }] : [{ maxHeight: height, opacity: 1 }, { maxHeight: '0px', opacity: 0 }],
+    open
+      ? [
+          { maxHeight: '0px', opacity: 0 },
+          { maxHeight: height, opacity: 1 },
+        ]
+      : [
+          { maxHeight: height, opacity: 1 },
+          { maxHeight: '0px', opacity: 0 },
+        ],
     { duration: 200, easing: EASING },
   )
   const done = () => {
@@ -422,19 +543,36 @@ async function toggle(nav: HTMLElement, item: HTMLElement, open: boolean) {
   item.setAttribute('aria-expanded', String(open))
   if (group) animate(group, open)
   // Focus inside a closing branch would be left on a row no one can see.
-  if (!open && item.contains(document.activeElement) && document.activeElement !== item) focusRow(item.closest<HTMLElement>('[role="tree"]')!, item)
+  if (!open && item.contains(document.activeElement) && document.activeElement !== item)
+    focusRow(item.closest<HTMLElement>('[role="tree"]')!, item)
 }
 
 function initTree(nav: HTMLElement, tree: HTMLElement, signal: AbortSignal) {
-  tree.addEventListener('scroll', () => {
-    const selection = window.history.state?.libtmuxApiTree as ApiTreeSelection | undefined
-    const current = tree.querySelector<HTMLElement>('a[data-api-shortcut][aria-current="page"]')
-    if (!selection || !current || selection.base !== nav.dataset.base || selection.version !== nav.dataset.version ||
-        selection.href !== location.pathname + location.search || JSON.stringify(selection.path) !== JSON.stringify(apiTreePath(current, tree))) return
-    try {
-      window.history.replaceState({ ...window.history.state, libtmuxApiTree: { ...selection, top: tree.scrollTop } }, '')
-    } catch { /* History state is optional. */ }
-  }, { signal })
+  tree.addEventListener(
+    'scroll',
+    () => {
+      const selection = window.history.state?.libtmuxApiTree as ApiTreeSelection | undefined
+      const current = tree.querySelector<HTMLElement>('a[data-api-shortcut][aria-current="page"]')
+      if (
+        !selection ||
+        !current ||
+        selection.base !== nav.dataset.base ||
+        selection.version !== nav.dataset.version ||
+        selection.href !== location.pathname + location.search ||
+        JSON.stringify(selection.path) !== JSON.stringify(apiTreePath(current, tree))
+      )
+        return
+      try {
+        window.history.replaceState(
+          { ...window.history.state, libtmuxApiTree: { ...selection, top: tree.scrollTop } },
+          '',
+        )
+      } catch {
+        /* History state is optional. */
+      }
+    },
+    { signal },
+  )
   tree.addEventListener(
     'keydown',
     (event) => {
@@ -552,8 +690,12 @@ function initDrawer(nav: HTMLElement, signal: AbortSignal) {
   toggleButton?.addEventListener('click', () => setOpen(true), { signal })
   closeButton?.addEventListener('click', () => setOpen(false), { signal })
   overlay?.addEventListener('click', () => setOpen(false), { signal })
-  document.addEventListener('keydown', (e) => e.key === 'Escape' && nav.hasAttribute('data-open') && setOpen(false), { signal })
-  document.addEventListener('libtmux:drawer-open', (e) => (e as CustomEvent).detail !== 'api-nav' && setOpen(false), { signal })
+  document.addEventListener('keydown', (e) => e.key === 'Escape' && nav.hasAttribute('data-open') && setOpen(false), {
+    signal,
+  })
+  document.addEventListener('libtmux:drawer-open', (e) => (e as CustomEvent).detail !== 'api-nav' && setOpen(false), {
+    signal,
+  })
   phone.addEventListener('change', () => setOpen(false), { signal })
 }
 
diff --git a/site/src/components/docs/documentation-navigation.ts b/site/src/components/docs/documentation-navigation.ts
index 7c8ca1708..b9c9f9127 100644
--- a/site/src/components/docs/documentation-navigation.ts
+++ b/site/src/components/docs/documentation-navigation.ts
@@ -17,34 +17,56 @@ export function initDocumentationNavigation() {
       delete context.dataset.settingsOpen
       toggle.setAttribute('aria-expanded', 'false')
     }
-    toggle.addEventListener('click', () => {
-      if (!compact.matches) return
-      for (const picker of context.querySelectorAll<HTMLDetailsElement>('[data-doc-picker][open]')) picker.open = false
-      context.dataset.settingsOpen = ''
-      toggle.setAttribute('aria-expanded', 'true')
-      back.focus({ preventScroll: true })
-    }, { signal })
-    back.addEventListener('click', () => { closeSettings(); toggle.focus({ preventScroll: true }) }, { signal })
-    context.addEventListener('keydown', (event) => {
-      if (event.key !== 'Escape' || !context.hasAttribute('data-settings-open')) return
-      event.preventDefault()
-      closeSettings()
-      toggle.focus({ preventScroll: true })
-    }, { signal })
-    compact.addEventListener('change', () => {
-      const focused = document.activeElement
-      const navigationOpen = context.querySelector('.documentation-context-navigation > :is(button, [role="button"])[aria-expanded="true"]')
-      closeSettings()
-      // A drawer must still have a visible opener to restore focus on close.
-      if (compact.matches && navigationOpen) {
+    toggle.addEventListener(
+      'click',
+      () => {
+        if (!compact.matches) return
+        for (const picker of context.querySelectorAll<HTMLDetailsElement>('[data-doc-picker][open]'))
+          picker.open = false
         context.dataset.settingsOpen = ''
         toggle.setAttribute('aria-expanded', 'true')
-      }
-      // Keep keyboard focus on a visible control when resizing either way.
-      if (focused instanceof HTMLElement && context.contains(focused) && !focused.getClientRects().length) {
-        (compact.matches ? toggle : settings.querySelector<HTMLElement>('summary'))?.focus({ preventScroll: true })
-      }
-    }, { signal })
+        back.focus({ preventScroll: true })
+      },
+      { signal },
+    )
+    back.addEventListener(
+      'click',
+      () => {
+        closeSettings()
+        toggle.focus({ preventScroll: true })
+      },
+      { signal },
+    )
+    context.addEventListener(
+      'keydown',
+      (event) => {
+        if (event.key !== 'Escape' || !context.hasAttribute('data-settings-open')) return
+        event.preventDefault()
+        closeSettings()
+        toggle.focus({ preventScroll: true })
+      },
+      { signal },
+    )
+    compact.addEventListener(
+      'change',
+      () => {
+        const focused = document.activeElement
+        const navigationOpen = context.querySelector(
+          '.documentation-context-navigation > :is(button, [role="button"])[aria-expanded="true"]',
+        )
+        closeSettings()
+        // A drawer must still have a visible opener to restore focus on close.
+        if (compact.matches && navigationOpen) {
+          context.dataset.settingsOpen = ''
+          toggle.setAttribute('aria-expanded', 'true')
+        }
+        // Keep keyboard focus on a visible control when resizing either way.
+        if (focused instanceof HTMLElement && context.contains(focused) && !focused.getClientRects().length) {
+          ;(compact.matches ? toggle : settings.querySelector<HTMLElement>('summary'))?.focus({ preventScroll: true })
+        }
+      },
+      { signal },
+    )
   }
   for (const picker of document.querySelectorAll<HTMLDetailsElement>('[data-doc-picker]')) {
     const panel = picker.querySelector<HTMLElement>('[data-picker-panel]')!
@@ -62,7 +84,12 @@ export function initDocumentationNavigation() {
     if (searchLabel) searchLabel.hidden = false
     const position = () => {
       const rect = summary.getBoundingClientRect()
-      if (!summary.getClientRects().length || summary.closest('[inert]') || rect.bottom <= 8 || rect.top >= window.innerHeight - 8) {
+      if (
+        !summary.getClientRects().length ||
+        summary.closest('[inert]') ||
+        rect.bottom <= 8 ||
+        rect.top >= window.innerHeight - 8
+      ) {
         picker.open = false
         if (topLayer && panel.matches(':popover-open')) panel.hidePopover()
         return
@@ -81,10 +108,14 @@ export function initDocumentationNavigation() {
     const filter = () => {
       const tokens = (search?.value ?? '').toLocaleLowerCase().trim().split(/\s+/).filter(Boolean)
       const entries = options()
-      for (const option of entries) option.hidden = !tokens.every((token) => option.dataset.match!.toLocaleLowerCase().includes(token))
+      for (const option of entries)
+        option.hidden = !tokens.every((token) => option.dataset.match!.toLocaleLowerCase().includes(token))
       groups().forEach((group) => {
-        group.hidden = ![...group.querySelectorAll<HTMLElement>('[data-picker-option]')].some((option) => !option.hidden)
-        if (group instanceof HTMLDetailsElement) group.open = tokens.length ? !group.hidden : saved.get(group) ?? false
+        group.hidden = ![...group.querySelectorAll<HTMLElement>('[data-picker-option]')].some(
+          (option) => !option.hidden,
+        )
+        if (group instanceof HTMLDetailsElement)
+          group.open = tokens.length ? !group.hidden : (saved.get(group) ?? false)
       })
       const count = entries.filter((option) => !option.hidden).length
       const empty = picker.querySelector<HTMLElement>('[data-picker-empty]')
@@ -92,60 +123,120 @@ export function initDocumentationNavigation() {
       const status = picker.querySelector<HTMLElement>('[data-picker-status]')
       if (status) status.textContent = tokens.length ? `${count} matching entries` : ''
     }
-    const visibleLinks = () => options().filter((option) => !option.hidden)
-      .flatMap((option) => option instanceof HTMLAnchorElement ? [option] : [...option.querySelectorAll<HTMLAnchorElement>('[data-picker-home]')])
-      .filter((link) => Boolean(link.getClientRects().length))
-    picker.addEventListener('toggle', () => {
-      if (!picker.open) {
-        if (topLayer && panel.matches(':popover-open')) panel.hidePopover()
-        if (search?.value) { search.value = ''; filter() }
-        return
-      }
-      for (const other of document.querySelectorAll<HTMLDetailsElement>('[data-doc-picker][open]')) {
-        if (other !== picker) other.open = false
-      }
-      saved = new Map(groups().map((group) => [group, group instanceof HTMLDetailsElement && group.open]))
-      if (search) { search.value = ''; filter() }
-      if (topLayer) panel.showPopover()
-      position()
-      // A reopened menu must not leave its focused search above the viewport.
-      panel.scrollTop = 0
-      if (picker.open) (search ?? panel.querySelector<HTMLElement>('a[aria-current]') ?? visibleLinks()[0])?.focus({ preventScroll: true })
-    }, { signal })
+    const visibleLinks = () =>
+      options()
+        .filter((option) => !option.hidden)
+        .flatMap((option) =>
+          option instanceof HTMLAnchorElement
+            ? [option]
+            : [...option.querySelectorAll<HTMLAnchorElement>('[data-picker-home]')],
+        )
+        .filter((link) => Boolean(link.getClientRects().length))
+    picker.addEventListener(
+      'toggle',
+      () => {
+        if (!picker.open) {
+          if (topLayer && panel.matches(':popover-open')) panel.hidePopover()
+          if (search?.value) {
+            search.value = ''
+            filter()
+          }
+          return
+        }
+        for (const other of document.querySelectorAll<HTMLDetailsElement>('[data-doc-picker][open]')) {
+          if (other !== picker) other.open = false
+        }
+        saved = new Map(groups().map((group) => [group, group instanceof HTMLDetailsElement && group.open]))
+        if (search) {
+          search.value = ''
+          filter()
+        }
+        if (topLayer) panel.showPopover()
+        position()
+        // A reopened menu must not leave its focused search above the viewport.
+        panel.scrollTop = 0
+        if (picker.open)
+          (search ?? panel.querySelector<HTMLElement>('a[aria-current]') ?? visibleLinks()[0])?.focus({
+            preventScroll: true,
+          })
+      },
+      { signal },
+    )
     search?.addEventListener('input', filter, { signal })
-    picker.addEventListener('keydown', (event) => {
-      if (event.key === 'Escape' && picker.open) {
-        event.preventDefault()
-        event.stopPropagation()
-        picker.open = false
-        summary.focus({ preventScroll: true })
-        return
-      }
-      const links = visibleLinks()
-      if (event.target === search) {
-        if (event.key === 'ArrowDown') { event.preventDefault(); links[0]?.focus() }
-        if (event.key === 'Enter' && search?.value.trim()) { event.preventDefault(); links[0]?.click() }
-      } else if (event.target instanceof HTMLAnchorElement && links.includes(event.target) && ['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)) {
-        const index = links.indexOf(event.target)
-        const next = event.key === 'Home' ? 0 : event.key === 'End' ? links.length - 1
-          : (index + (event.key === 'ArrowDown' ? 1 : -1) + links.length) % links.length
-        event.preventDefault()
-        links[next]?.focus()
-      }
-    }, { signal })
-    picker.addEventListener('click', (event) => {
-      const link = event.target instanceof Element ? event.target.closest<HTMLAnchorElement>('a[data-preserve-fragment]') : null
-      if (link && location.hash) link.hash = location.hash
-    }, { signal })
-    document.addEventListener('click', (event) => {
-      if (picker.open && event.target instanceof Node && !picker.contains(event.target)) picker.open = false
-    }, { signal })
-    document.addEventListener('focusin', (event) => {
-      if (picker.open && event.target instanceof Node && !picker.contains(event.target)) picker.open = false
-    }, { signal })
-    window.addEventListener('resize', () => { if (picker.open) position() }, { signal })
-    document.addEventListener('scroll', (event) => {
-      if (picker.open && event.target instanceof Node && !panel.contains(event.target)) position()
-    }, { capture: true, signal })
+    picker.addEventListener(
+      'keydown',
+      (event) => {
+        if (event.key === 'Escape' && picker.open) {
+          event.preventDefault()
+          event.stopPropagation()
+          picker.open = false
+          summary.focus({ preventScroll: true })
+          return
+        }
+        const links = visibleLinks()
+        if (event.target === search) {
+          if (event.key === 'ArrowDown') {
+            event.preventDefault()
+            links[0]?.focus()
+          }
+          if (event.key === 'Enter' && search?.value.trim()) {
+            event.preventDefault()
+            links[0]?.click()
+          }
+        } else if (
+          event.target instanceof HTMLAnchorElement &&
+          links.includes(event.target) &&
+          ['ArrowDown', 'ArrowUp', 'Home', 'End'].includes(event.key)
+        ) {
+          const index = links.indexOf(event.target)
+          const next =
+            event.key === 'Home'
+              ? 0
+              : event.key === 'End'
+                ? links.length - 1
+                : (index + (event.key === 'ArrowDown' ? 1 : -1) + links.length) % links.length
+          event.preventDefault()
+          links[next]?.focus()
+        }
+      },
+      { signal },
+    )
+    picker.addEventListener(
+      'click',
+      (event) => {
+        const link =
+          event.target instanceof Element ? event.target.closest<HTMLAnchorElement>('a[data-preserve-fragment]') : null
+        if (link && location.hash) link.hash = location.hash
+      },
+      { signal },
+    )
+    document.addEventListener(
+      'click',
+      (event) => {
+        if (picker.open && event.target instanceof Node && !picker.contains(event.target)) picker.open = false
+      },
+      { signal },
+    )
+    document.addEventListener(
+      'focusin',
+      (event) => {
+        if (picker.open && event.target instanceof Node && !picker.contains(event.target)) picker.open = false
+      },
+      { signal },
+    )
+    window.addEventListener(
+      'resize',
+      () => {
+        if (picker.open) position()
+      },
+      { signal },
+    )
+    document.addEventListener(
+      'scroll',
+      (event) => {
+        if (picker.open && event.target instanceof Node && !panel.contains(event.target)) position()
+      },
+      { capture: true, signal },
+    )
   }
 }
diff --git a/site/src/components/docs/documentation-sidebar.ts b/site/src/components/docs/documentation-sidebar.ts
index a0b263b54..13742295b 100644
--- a/site/src/components/docs/documentation-sidebar.ts
+++ b/site/src/components/docs/documentation-sidebar.ts
@@ -5,32 +5,50 @@ export function initializeDocumentationSidebar(nav: HTMLElement | null) {
   const links = [...nav.querySelectorAll<HTMLElement>('.sidebar-nav [data-sidebar-label]')]
   const groups = [...nav.querySelectorAll<HTMLDetailsElement>('.sidebar-nav details')]
   const scroll = nav.closest<HTMLElement>('[data-documentation-scroll]')
-  const controller = new AbortController(), { signal } = controller
+  const controller = new AbortController(),
+    { signal } = controller
   let searchSaved: boolean[] | undefined
-  let initialized = false, interacted = false
+  let initialized = false,
+    interacted = false
   let queued = false
   let timer: ReturnType<typeof setTimeout> | undefined
   const key = `libtmux:section-nav:${nav.dataset.sectionScope}`
   const branchKey = (group: HTMLDetailsElement) => {
     const path: string[] = []
-    for (let parent: HTMLDetailsElement | null = group; parent && nav.contains(parent); parent = parent.parentElement?.closest('details') ?? null) {
+    for (
+      let parent: HTMLDetailsElement | null = group;
+      parent && nav.contains(parent);
+      parent = parent.parentElement?.closest('details') ?? null
+    ) {
       const summary = parent.querySelector(':scope > summary')!
-      path.unshift(summary.querySelector('a')?.getAttribute('href') ?? summary.querySelector<HTMLElement>('[data-sidebar-label]')?.dataset.sidebarLabel ?? summary.textContent!.trim())
+      path.unshift(
+        summary.querySelector('a')?.getAttribute('href') ??
+          summary.querySelector<HTMLElement>('[data-sidebar-label]')?.dataset.sidebarLabel ??
+          summary.textContent!.trim(),
+      )
     }
     return JSON.stringify(path)
   }
   const visible = () => Boolean(scroll?.getClientRects().length && !scroll.closest('[inert]'))
   const save = () => {
     if (!initialized || !visible() || !scroll) return
-    const branches = Object.fromEntries(groups.map((group, index) => [branchKey(group), searchSaved?.[index] ?? group.open]))
-    try { window.sessionStorage.setItem(key, JSON.stringify({ top: scroll.scrollTop, branches })) } catch { /* Storage is optional. */ }
+    const branches = Object.fromEntries(
+      groups.map((group, index) => [branchKey(group), searchSaved?.[index] ?? group.open]),
+    )
+    try {
+      window.sessionStorage.setItem(key, JSON.stringify({ top: scroll.scrollTop, branches }))
+    } catch {
+      /* Storage is optional. */
+    }
   }
   const reveal = () => {
     if (!scroll || !visible() || interacted || signal.aborted || !nav.isConnected) return
     const current = nav.querySelector<HTMLElement>('[aria-current="page"]')
     if (!current) return
-    const row = current.getBoundingClientRect(), box = scroll.getBoundingClientRect()
-    const top = Math.max(0, box.top), bottom = Math.min(window.innerHeight, box.bottom)
+    const row = current.getBoundingClientRect(),
+      box = scroll.getBoundingClientRect()
+    const top = Math.max(0, box.top),
+      bottom = Math.min(window.innerHeight, box.bottom)
     if (row.top < top || row.bottom > bottom) {
       // Move only the sidebar; the document may be arriving at a deep fragment.
       scroll.scrollTop += row.top - top - (bottom - top - row.height) / 2
@@ -47,14 +65,22 @@ export function initializeDocumentationSidebar(nav: HTMLElement | null) {
     if (!initialized) {
       try {
         const saved = JSON.parse(window.sessionStorage.getItem(key) ?? 'null')
-        if (Number.isFinite(saved?.top) && saved.top >= 0 && saved.branches && typeof saved.branches === 'object' && !Array.isArray(saved.branches)) {
+        if (
+          Number.isFinite(saved?.top) &&
+          saved.top >= 0 &&
+          saved.branches &&
+          typeof saved.branches === 'object' &&
+          !Array.isArray(saved.branches)
+        ) {
           for (const group of groups) {
             const open = saved.branches[branchKey(group)]
             if (typeof open === 'boolean') group.open = Boolean(group.querySelector('[aria-current="page"]')) || open
           }
           scroll.scrollTop = saved.top
         }
-      } catch { /* Direct arrivals remain usable without saved state. */ }
+      } catch {
+        /* Direct arrivals remain usable without saved state. */
+      }
       initialized = true
     }
     reveal()
@@ -62,46 +88,78 @@ export function initializeDocumentationSidebar(nav: HTMLElement | null) {
   const later = () => {
     if (queued) return
     queued = true
-    window.requestAnimationFrame(() => { queued = false; restore() })
+    window.requestAnimationFrame(() => {
+      queued = false
+      restore()
+    })
   }
-  input.addEventListener('input', () => {
-    const query = input.value.trim().toLocaleLowerCase()
-    if (query && !searchSaved) searchSaved = groups.map((group) => group.open)
-    for (const link of links) {
-      const ancestors = []
-      for (let parent = link.closest('details'); parent && nav.contains(parent); parent = parent.parentElement?.closest('details') ?? null) {
-        const summary = parent.querySelector(':scope > summary')!
-        ancestors.push((summary.querySelector<HTMLElement>('[data-sidebar-label]')?.dataset.sidebarLabel ?? summary.textContent!).trim())
+  input.addEventListener(
+    'input',
+    () => {
+      const query = input.value.trim().toLocaleLowerCase()
+      if (query && !searchSaved) searchSaved = groups.map((group) => group.open)
+      for (const link of links) {
+        const ancestors = []
+        for (
+          let parent = link.closest('details');
+          parent && nav.contains(parent);
+          parent = parent.parentElement?.closest('details') ?? null
+        ) {
+          const summary = parent.querySelector(':scope > summary')!
+          ancestors.push(
+            (
+              summary.querySelector<HTMLElement>('[data-sidebar-label]')?.dataset.sidebarLabel ?? summary.textContent!
+            ).trim(),
+          )
+        }
+        const label = link.dataset.sidebarLabel ?? link.textContent!.trim()
+        const qualified = [...ancestors].reverse().concat(label).join('.')
+        link.hidden = ![label, qualified, ...ancestors].some((text) => text.toLocaleLowerCase().includes(query))
       }
-      const label = link.dataset.sidebarLabel ?? link.textContent!.trim()
-      const qualified = [...ancestors].reverse().concat(label).join('.')
-      link.hidden = ![label, qualified, ...ancestors].some((text) => text.toLocaleLowerCase().includes(query))
-    }
-    for (const group of [...groups].reverse()) {
-      group.hidden = ![...group.querySelectorAll<HTMLElement>('[data-sidebar-label]')].some((link) => !link.hidden)
-      const heading = group.querySelector<HTMLElement>(':scope > summary > a')
-      if (heading && !group.hidden) heading.hidden = false
-      if (query) group.open = !group.hidden
-      else if (searchSaved) group.open = searchSaved[groups.indexOf(group)]
-    }
-    if (!query) searchSaved = undefined
-    nav.querySelector<HTMLElement>('[data-section-empty]')!.hidden = links.some((link) => !link.hidden)
-  }, { signal })
+      for (const group of [...groups].reverse()) {
+        group.hidden = ![...group.querySelectorAll<HTMLElement>('[data-sidebar-label]')].some((link) => !link.hidden)
+        const heading = group.querySelector<HTMLElement>(':scope > summary > a')
+        if (heading && !group.hidden) heading.hidden = false
+        if (query) group.open = !group.hidden
+        else if (searchSaved) group.open = searchSaved[groups.indexOf(group)]
+      }
+      if (!query) searchSaved = undefined
+      nav.querySelector<HTMLElement>('[data-section-empty]')!.hidden = links.some((link) => !link.hidden)
+    },
+    { signal },
+  )
   // Bind and reveal together, before the parser paints this sidebar.
   nav.querySelector<HTMLElement>('[data-section-search-label]')!.hidden = false
   for (const event of ['wheel', 'pointerdown', 'keydown']) {
-    scroll?.addEventListener(event, () => { interacted = true }, { signal, once: true })
+    scroll?.addEventListener(
+      event,
+      () => {
+        interacted = true
+      },
+      { signal, once: true },
+    )
   }
-  scroll?.addEventListener('scroll', () => {
-    clearTimeout(timer)
-    timer = setTimeout(save, 80)
-  }, { signal, passive: true })
+  scroll?.addEventListener(
+    'scroll',
+    () => {
+      clearTimeout(timer)
+      timer = setTimeout(save, 80)
+    },
+    { signal, passive: true },
+  )
   nav.addEventListener('toggle', save, { signal, capture: true })
   // Capture before the mobile drawer closes and becomes inert on navigation.
   nav.addEventListener('click', save, { signal, capture: true })
-  document.addEventListener('astro:before-swap', () => {
-    save(); clearTimeout(timer); observer?.disconnect(); controller.abort()
-  }, { signal, once: true })
+  document.addEventListener(
+    'astro:before-swap',
+    () => {
+      save()
+      clearTimeout(timer)
+      observer?.disconnect()
+      controller.abort()
+    },
+    { signal, once: true },
+  )
   window.addEventListener('pagehide', save, { signal })
   window.addEventListener('resize', later, { signal })
   window.addEventListener('scroll', later, { signal, passive: true })
diff --git a/site/src/components/widgets/mcp-install.js b/site/src/components/widgets/mcp-install.js
index 5642eea82..9c5279655 100644
--- a/site/src/components/widgets/mcp-install.js
+++ b/site/src/components/widgets/mcp-install.js
@@ -40,7 +40,7 @@
  *
  * Vanilla JS, no deps.
  */
-(function () {
+;(function () {
   'use strict'
 
   var STORAGE_PREFIX = 'libtmux-docs.mcp-install'
@@ -450,7 +450,10 @@
   function announceCopyResult(button, copied) {
     var widget = button.closest('.lm-mcp-install')
     var status = widget && widget.querySelector('[data-copy-status]')
-    if (status) status.replaceChildren(document.createTextNode(copied ? 'Copied to clipboard.' : 'Copy failed. Select and copy the text manually.'))
+    if (status)
+      status.replaceChildren(
+        document.createTextNode(copied ? 'Copied to clipboard.' : 'Copy failed. Select and copy the text manually.'),
+      )
     var original = button.getAttribute('data-copy-label') || button.textContent
     button.setAttribute('data-copy-label', original)
     button.textContent = copied ? 'Copied' : 'Copy failed'
diff --git a/site/src/content.config.ts b/site/src/content.config.ts
index 231640d0f..422cd7a5a 100644
--- a/site/src/content.config.ts
+++ b/site/src/content.config.ts
@@ -27,7 +27,9 @@ const docs = defineCollection({
     /** Restricts a page to one port's section, e.g. 'py'. Omit for shared pages. */
     port: z.string().optional(),
     /** Shared prose is published only where its native APIs are documented. */
-    supportedPorts: z.array(z.string().refine((slug) => PORTS.some((port) => port.slug === slug), 'Unknown documentation port')).optional(),
+    supportedPorts: z
+      .array(z.string().refine((slug) => PORTS.some((port) => port.slug === slug), 'Unknown documentation port'))
+      .optional(),
     /** Product pages are authored separately for each port. */
     product: z.enum(['mcp', 'workspace']).optional(),
     /** Published package a staged source guide documents. */
@@ -51,10 +53,22 @@ const docs = defineCollection({
       })
       .optional(),
     /** Browse links shared by HTML and Markdown; `href` is relative to the page. */
-    cards: z.array(z.object({
-      label: z.string(), href: z.string(), body: z.string(),
-      ports: z.array(z.string().refine((slug) => slug === 'root' || PORTS.some((port) => port.slug === slug), 'Unknown card port')).optional(),
-    })).optional(),
+    cards: z
+      .array(
+        z.object({
+          label: z.string(),
+          href: z.string(),
+          body: z.string(),
+          ports: z
+            .array(
+              z
+                .string()
+                .refine((slug) => slug === 'root' || PORTS.some((port) => port.slug === slug), 'Unknown card port'),
+            )
+            .optional(),
+        }),
+      )
+      .optional(),
     /** Suppress the on-page table of contents. */
     tableOfContents: z.boolean().default(true),
     /** Explicit canonical override; normally computed. */
diff --git a/site/src/content/_workspace-shared/workspace/configuration/environment.md b/site/src/content/_workspace-shared/workspace/configuration/environment.md
index 48958e623..766c439df 100644
--- a/site/src/content/_workspace-shared/workspace/configuration/environment.md
+++ b/site/src/content/_workspace-shared/workspace/configuration/environment.md
@@ -99,8 +99,10 @@ windows:
     panes:
       - environment:
           DOC_PANE: pane
-        shell_command: 'printf "ENV=%s|%s|%s\n" "$DOC_SESSION" "$DOC_WINDOW" "$DOC_PANE"'
-      - shell_command: 'printf "ENV=%s|%s|%s\n" "$DOC_SESSION" "$DOC_WINDOW" "$DOC_PANE"'
+        shell_command:
+          'printf "ENV=%s|%s|%s\n" "$DOC_SESSION" "$DOC_WINDOW" "$DOC_PANE"'
+      - shell_command:
+          'printf "ENV=%s|%s|%s\n" "$DOC_SESSION" "$DOC_WINDOW" "$DOC_PANE"'
 ```
 
 A pane map selects its launch environment in place of the window map. Session
diff --git a/site/src/content/_workspace-shared/workspace/examples/gallery.md b/site/src/content/_workspace-shared/workspace/examples/gallery.md
index 717d24d4e..37add8284 100644
--- a/site/src/content/_workspace-shared/workspace/examples/gallery.md
+++ b/site/src/content/_workspace-shared/workspace/examples/gallery.md
@@ -173,7 +173,7 @@ windows:
     panes:
       - pane
       - shell_command:
-          - echo 'this pane should be focused, when window switched to first time'
+          - echo 'this pane is focused when its window is first selected'
         focus: true
       - pane
 ```
@@ -283,7 +283,7 @@ windows:
       - shell: /usr/bin/vim -u none
         shell_command:
           - iAll panes have the `remain-on-exit` setting on.
-          - When you exit out of the shell or application, the panes will remain.
+          - When you exit the shell or application, the panes remain.
           - Use tmux command `:kill-pane` to remove the pane.
           - Use tmux command `:respawn-pane` to restart the shell in the pane.
           - Use <Escape> and then `:q!` to get out of this vim window. :-)
diff --git a/site/src/content/_workspace-shared/workspace/guides/installation.md b/site/src/content/_workspace-shared/workspace/guides/installation.md
index ef06f0aac..2156a2e5f 100644
--- a/site/src/content/_workspace-shared/workspace/guides/installation.md
+++ b/site/src/content/_workspace-shared/workspace/guides/installation.md
@@ -113,7 +113,9 @@ $ WORKSPACE_BIN="$(mktemp -d)"
 ```
 
 ```console
-$ ln -s "$PWD/packages/workspace-cli/dist/main.js" "$WORKSPACE_BIN/tmux-workspace"
+$ ln -s \
+    "$PWD/packages/workspace-cli/dist/main.js" \
+    "$WORKSPACE_BIN/tmux-workspace"
 ```
 
 ```console
@@ -202,7 +204,8 @@ $ ./gradlew --no-daemon --max-workers=2 :libtmux-workspace-cli:installDist
 ```
 
 ```console
-$ export PATH="$PWD/libtmux-workspace-cli/build/install/tmux-workspace/bin:$PATH"
+$ BIN="$PWD/libtmux-workspace-cli/build/install/tmux-workspace/bin" && \
+    export PATH="$BIN:$PATH"
 ```
 
 Keep the distribution's `bin` and `lib` directories together. Set `JAVA_HOME`
@@ -228,7 +231,9 @@ $ git checkout --detach FETCH_HEAD
 Use the .NET 10 SDK to build the command:
 
 ```console
-$ dotnet build src/LibTmux.Workspace.Cli/LibTmux.Workspace.Cli.csproj --configuration Release
+$ dotnet build \
+    src/LibTmux.Workspace.Cli/LibTmux.Workspace.Cli.csproj \
+    --configuration Release
 ```
 
 ```console
@@ -236,7 +241,9 @@ $ WORKSPACE_BIN="$(mktemp -d)"
 ```
 
 ```console
-$ ln -s "$PWD/src/LibTmux.Workspace.Cli/bin/Release/net10.0/LibTmux.Workspace.Cli" "$WORKSPACE_BIN/tmux-workspace"
+$ ln -s \
+    "$PWD/src/LibTmux.Workspace.Cli/bin/Release/net10.0/LibTmux.Workspace.Cli" \
+    "$WORKSPACE_BIN/tmux-workspace"
 ```
 
 ```console
@@ -300,7 +307,10 @@ $ git checkout --detach FETCH_HEAD
 Use Swift 6.2 and enable YAML decoding for this walkthrough:
 
 ```console
-$ swift build --force-resolved-versions --traits YAMLWorkspaces --product tmux-workspace
+$ swift build \
+    --force-resolved-versions \
+    --traits YAMLWorkspaces \
+    --product tmux-workspace
 ```
 
 ```console
diff --git a/site/src/content/docs/concepts/queries.md b/site/src/content/docs/concepts/queries.md
index 6fe4f8171..f341b596e 100644
--- a/site/src/content/docs/concepts/queries.md
+++ b/site/src/content/docs/concepts/queries.md
@@ -147,8 +147,10 @@ List<Window> editors = server.windows().stream()
         .toList();
 
 // Selections.exactlyOne() is the `.get()`-shaped call.
-Session build = Selections.exactlyOne(
-        server.sessions().stream().filter(Session_.name().is("build")).toList());
+List<Session> builds = server.sessions().stream()
+        .filter(Session_.name().is("build"))
+        .toList();
+Session build = Selections.exactlyOne(builds);
 ```
 
 ```csharp
@@ -163,8 +165,9 @@ IReadOnlyList<Session> matched = sessions.Matching<Session>(
 ```
 
 ```cpp
-// A filter is a value built from typed fields; `window::active.starts_with(...)`
-// would not compile: a flag has no string operations.
+// A filter is a value built from typed fields;
+// `window::active.starts_with(...)` would not compile: a flag has no
+// string operations.
 const auto interesting =
     libtmux::window::name.starts_with("e") || libtmux::window::name == "logs";
 
@@ -182,7 +185,10 @@ if (const auto only = libtmux::exactly_one(logs); only.has_value()) {
 let editors = try await server.panes().filter { $0.currentCommand == "nvim" }
 
 // Or build a filter that travels: stored, sent, replayed elsewhere:
-let expression = try FilterExpr<Pane>.where(\.currentCommand, .isIn(["nvim", "vim"]))
+let expression = try FilterExpr<Pane>.where(
+    \.currentCommand,
+    .isIn(["nvim", "vim"])
+)
 let matching = try await server.panes().filter(expression)
 ```
 <!-- /port -->
diff --git a/site/src/content/docs/concepts/server-session-window-pane.md b/site/src/content/docs/concepts/server-session-window-pane.md
index f0380ac36..48c74db24 100644
--- a/site/src/content/docs/concepts/server-session-window-pane.md
+++ b/site/src/content/docs/concepts/server-session-window-pane.md
@@ -110,7 +110,8 @@ for (Session session : server.sessions()) {
     for (Window window : session.windows()) {
         System.out.println("  " + window.index() + " " + window.name());
         for (Pane pane : window.panes()) {
-            System.out.println("    " + pane.id().value() + " " + pane.currentCommand());
+            String line = pane.id().value() + " " + pane.currentCommand();
+            System.out.println("    " + line);
         }
     }
 }
diff --git a/site/src/content/docs/concepts/transports.md b/site/src/content/docs/concepts/transports.md
index 7bb9c6310..a1954bab4 100644
--- a/site/src/content/docs/concepts/transports.md
+++ b/site/src/content/docs/concepts/transports.md
@@ -197,7 +197,7 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
     // One-shot: every call underneath this handle spawns a `tmux` process.
     let server = Server::new()?;
     let session = server.new_session("work").await?;
-    let window = session.active_window().await?.expect("a session has a window");
+    let window = session.active_window().await?.expect("session has a window");
     let pane = window.active_pane().await?.expect("a window has a pane");
     pane.send_line("echo hello").await?;
     Ok(())
@@ -226,7 +226,10 @@ if err != nil {
 	return err
 }
 command := "echo hello"
-return pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &command, Literal: true})
+return pane.SendKeys(ctx, tmux.SendKeysRequest{
+	Command: &command,
+	Literal: true,
+})
 ```
 
 ```java
@@ -247,7 +250,8 @@ using LibTmux;
 
 // One-shot: every call underneath this handle spawns a `tmux` process.
 Server server = await Server.ConnectAsync();
-Session session = await server.CreateSessionAsync(new NewSessionRequest(name: "work"));
+NewSessionRequest request = new(name: "work");
+Session session = await server.CreateSessionAsync(request);
 Window window = (await session.GetWindowsAsync())[0];
 Pane pane = (await window.GetPanesAsync())[0];
 
diff --git a/site/src/content/docs/concepts/workspaces.md b/site/src/content/docs/concepts/workspaces.md
index 5da7069b7..8b49b7d6d 100644
--- a/site/src/content/docs/concepts/workspaces.md
+++ b/site/src/content/docs/concepts/workspaces.md
@@ -48,7 +48,9 @@ window.select_layout(Layout::MainVertical).await?;
 ```
 
 ```go
-window, err := session.NewWindow(ctx, tmux.NewWindowRequest{Name: tmux.Ptr("dev")})
+window, err := session.NewWindow(ctx, tmux.NewWindowRequest{
+	Name: tmux.Ptr("dev"),
+})
 if err != nil {
 	return err
 }
@@ -60,11 +62,14 @@ terminal, err := window.SplitPane(ctx, tmux.SplitPaneRequest{
 if err != nil {
 	return err
 }
-if _, err := window.SplitPane(ctx, tmux.SplitPaneRequest{Direction: tmux.PaneDirectionRight}); err != nil {
+right := tmux.SplitPaneRequest{Direction: tmux.PaneDirectionRight}
+if _, err := window.SplitPane(ctx, right); err != nil {
 	return err
 }
 _ = terminal
-return window.SelectLayout(ctx, tmux.SelectLayoutRequest{Layout: "main-vertical"})
+return window.SelectLayout(ctx, tmux.SelectLayoutRequest{
+	Layout: "main-vertical",
+})
 ```
 
 ```java
@@ -76,11 +81,13 @@ window.selectLayout(Layout.MAIN_VERTICAL);
 ```
 
 ```csharp
-Window window = await session.CreateWindowAsync(new NewWindowRequest(name: "dev"));
+NewWindowRequest dev = new(name: "dev");
+Window window = await session.CreateWindowAsync(dev);
 Pane main = (await window.GetPanesAsync())[0];
 
 Pane terminal = await main.SplitAsync(new SplitPaneRequest(percentage: 30));
-Pane logs = await terminal.SplitAsync(new SplitPaneRequest(direction: PaneDirection.Right));
+SplitPaneRequest right = new(direction: PaneDirection.Right);
+Pane logs = await terminal.SplitAsync(right);
 
 await window.SelectLayoutAsync(new SelectLayoutRequest("main-vertical"));
 ```
@@ -195,7 +202,10 @@ await applyWorkspace(server, {
   session_name: "api",
   windows: [
     { window_name: "editor", panes: ["vim", "git status"] },
-    { window_name: "server", panes: [{ shell_command: "bun dev", focus: true }] },
+    {
+      window_name: "server",
+      panes: [{ shell_command: "bun dev", focus: true }],
+    },
   ],
 });
 ```
@@ -226,7 +236,8 @@ Session session = WorkspaceBuilder.build(server, workspace);
 
 ```csharp
 WorkspaceFile workspace = WorkspaceFile.Parse(yaml);
-WorkspaceResult result = await new WorkspaceBuilder(server).BuildAsync(workspace, ct);
+WorkspaceBuilder builder = new(server);
+WorkspaceResult result = await builder.BuildAsync(workspace, ct);
 ```
 
 ```swift
@@ -278,7 +289,9 @@ with session.new_window(window_name='temp-window') as temp_win:
 ```go
 // No context manager: defer runs the cleanup at the end of the enclosing
 // function instead of the end of a block.
-session, err := server.NewSession(ctx, tmux.NewSessionRequest{Name: "temp-session"})
+session, err := server.NewSession(ctx, tmux.NewSessionRequest{
+	Name: "temp-session",
+})
 if err != nil {
 	return err
 }
diff --git a/site/src/content/docs/guides/capturing-output.md b/site/src/content/docs/guides/capturing-output.md
index a2718162c..f9e92ce65 100644
--- a/site/src/content/docs/guides/capturing-output.md
+++ b/site/src/content/docs/guides/capturing-output.md
@@ -41,8 +41,13 @@ cleanup() {
 trap cleanup 0
 trap 'exit 1' HUP INT TERM
 
-tmux -S "$socket" -f /dev/null new-session -d -s capture -x 80 -y 10 \
-    'i=1; while [ "$i" -le 40 ]; do printf "row-%s\n" "$i"; i=$((i + 1)); done; exec cat'
+tmux -S "$socket" -f /dev/null new-session -d -s capture -x 80 -y 10 '
+    i=1
+    while [ "$i" -le 40 ]; do
+        printf "row-%s\n" "$i"
+        i=$((i + 1))
+    done
+    exec cat'
 tmux -S "$socket" resize-window -t capture:0 -x 80 -y 10
 
 attempt=0
diff --git a/site/src/content/docs/ports/csharp/examples/capture-pane-output.md b/site/src/content/docs/ports/csharp/examples/capture-pane-output.md
index 7094c512c..2d4bd37ec 100644
--- a/site/src/content/docs/ports/csharp/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/csharp/examples/capture-pane-output.md
@@ -35,7 +35,8 @@ using System.Threading.Tasks;
 using LibTmux;
 
 if (OperatingSystem.IsWindows())
-    throw new PlatformNotSupportedException("Run this example on Linux or macOS");
+    throw new PlatformNotSupportedException(
+        "Run this example on Linux or macOS");
 
 string directory = Path.Combine(
     "/tmp/libtmux-dotnet-dev", Guid.NewGuid().ToString("N"));
diff --git a/site/src/content/docs/ports/csharp/guides/attaching-to-tmux.md b/site/src/content/docs/ports/csharp/guides/attaching-to-tmux.md
index 23593c1bf..4d2e0c9bd 100644
--- a/site/src/content/docs/ports/csharp/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/csharp/guides/attaching-to-tmux.md
@@ -33,7 +33,8 @@ using System.Threading.Tasks;
 using LibTmux;
 
 string socket = Environment.GetEnvironmentVariable("LIBTMUX_SOCKET_PATH")
-    ?? throw new InvalidOperationException("Set LIBTMUX_SOCKET_PATH to an existing socket");
+    ?? throw new InvalidOperationException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket");
 using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5));
 Server server = await Server.ConnectAsync(
     new ServerConnectionOptions { SocketPath = socket }, timeout.Token);
diff --git a/site/src/content/docs/ports/csharp/mcp/examples/inspect-sessions.md b/site/src/content/docs/ports/csharp/mcp/examples/inspect-sessions.md
index 43310da97..b275fd8a3 100644
--- a/site/src/content/docs/ports/csharp/mcp/examples/inspect-sessions.md
+++ b/site/src/content/docs/ports/csharp/mcp/examples/inspect-sessions.md
@@ -67,7 +67,8 @@ using ModelContextProtocol.Protocol;
 
 if (OperatingSystem.IsWindows())
 {
-    throw new PlatformNotSupportedException("Use Linux, macOS, or WSL with tmux.");
+    throw new PlatformNotSupportedException(
+        "Use Linux, macOS, or WSL with tmux.");
 }
 
 using CancellationTokenSource deadline = new(TimeSpan.FromSeconds(30));
@@ -95,7 +96,8 @@ try
 
     Dictionary<string, string?> environment =
         StdioClientTransportOptions.GetDefaultEnvironmentVariables();
-    environment["DOTNET_ROOT"] = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+    string? dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+    environment["DOTNET_ROOT"] = dotnetRoot;
     environment["LIBTMUX_SOCKET_PATH"] = socket;
     environment["LIBTMUX_TOOLSETS"] = "inspect";
 
@@ -118,7 +120,8 @@ try
 
     ReadResourceResult resource = await client.ReadResourceAsync(
         "tmux://capabilities", cancellationToken: token);
-    TextResourceContents text = (TextResourceContents)resource.Contents.Single();
+    TextResourceContents text =
+        (TextResourceContents)resource.Contents.Single();
     using JsonDocument capabilities = JsonDocument.Parse(text.Text);
     string?[] selection = capabilities.RootElement.GetProperty("toolsets")
         .EnumerateArray().Select(value => value.GetString()).ToArray();
@@ -130,7 +133,8 @@ try
 
     CallToolResult result = await client.CallToolAsync(
         "list_sessions", cancellationToken: token);
-    if (result.IsError == true || result.StructuredContent is not JsonElement data)
+    if (result.IsError == true
+        || result.StructuredContent is not JsonElement data)
     {
         throw new InvalidOperationException(JsonSerializer.Serialize(result));
     }
@@ -181,7 +185,8 @@ if (stopped)
     }
     catch (Exception error)
     {
-        failures.Add(new IOException("Temporary directory cleanup failed.", error));
+        failures.Add(
+            new IOException("Temporary directory cleanup failed.", error));
     }
 }
 else
diff --git a/site/src/content/docs/ports/csharp/mcp/examples/run-command.md b/site/src/content/docs/ports/csharp/mcp/examples/run-command.md
index 915bb35b3..fa164f4a9 100644
--- a/site/src/content/docs/ports/csharp/mcp/examples/run-command.md
+++ b/site/src/content/docs/ports/csharp/mcp/examples/run-command.md
@@ -70,7 +70,8 @@ using ModelContextProtocol.Protocol;
 
 if (OperatingSystem.IsWindows())
 {
-    throw new PlatformNotSupportedException("Use Linux, macOS, or WSL with tmux.");
+    throw new PlatformNotSupportedException(
+        "Use Linux, macOS, or WSL with tmux.");
 }
 
 using CancellationTokenSource deadline = new(TimeSpan.FromSeconds(30));
@@ -98,7 +99,8 @@ try
 
     Dictionary<string, string?> environment =
         StdioClientTransportOptions.GetDefaultEnvironmentVariables();
-    environment["DOTNET_ROOT"] = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+    string? dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT");
+    environment["DOTNET_ROOT"] = dotnetRoot;
     environment["LIBTMUX_SOCKET_PATH"] = socket;
     environment["LIBTMUX_TOOLSETS"] = "inspect,execute";
     environment["LIBTMUX_MCP_WAIT_MAX_SECONDS"] = "5";
@@ -116,7 +118,8 @@ try
     var tools = await client.ListToolsAsync(cancellationToken: token);
     if (!tools.Any(tool => tool.Name == "run_shell_command"))
     {
-        throw new InvalidOperationException("Command execution is not offered.");
+        throw new InvalidOperationException(
+            "Command execution is not offered.");
     }
 
     JsonElement panes = ReadResult(await client.CallToolAsync(
@@ -138,7 +141,8 @@ try
         || result.GetProperty("paneExited").GetBoolean()
         || !result.GetProperty("started").GetBoolean())
     {
-        throw new InvalidOperationException($"Command did not finish: {result}");
+        throw new InvalidOperationException(
+            $"Command did not finish: {result}");
     }
     int status = result.GetProperty("exitStatus").GetInt32();
     if (status != 0)
@@ -153,7 +157,8 @@ try
         || result.GetProperty("linesMissed").GetBoolean()
         || result.GetProperty("anchorLost").GetBoolean())
     {
-        throw new InvalidOperationException($"Incomplete command output: {result}");
+        throw new InvalidOperationException(
+            $"Incomplete command output: {result}");
     }
     Console.WriteLine($"Command exit status: {status}");
     Console.WriteLine("Captured marker: MCP command ready");
@@ -196,7 +201,8 @@ if (stopped)
     }
     catch (Exception error)
     {
-        failures.Add(new IOException("Temporary directory cleanup failed.", error));
+        failures.Add(
+            new IOException("Temporary directory cleanup failed.", error));
     }
 }
 else
@@ -212,7 +218,8 @@ Console.WriteLine("Owned server stopped.");
 
 static JsonElement ReadResult(CallToolResult result)
 {
-    if (result.IsError == true || result.StructuredContent is not JsonElement data)
+    if (result.IsError == true
+        || result.StructuredContent is not JsonElement data)
     {
         throw new InvalidOperationException(JsonSerializer.Serialize(result));
     }
diff --git a/site/src/content/docs/ports/csharp/workspace/internals/examples.md b/site/src/content/docs/ports/csharp/workspace/internals/examples.md
index 857bafb23..3be6fd04d 100644
--- a/site/src/content/docs/ports/csharp/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/csharp/workspace/internals/examples.md
@@ -22,8 +22,10 @@ In a new directory, fetch the source revision used by this documentation:
 $ mkdir dotnet-workspace-example
 $ cd dotnet-workspace-example
 $ git init -q libtmux-source
-$ git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-dotnet.git
-$ git -C libtmux-source fetch --depth=1 origin 320dc64f4b8b7815842471327a5e6b84a1499bf8
+$ git -C libtmux-source remote add origin \
+    https://github.com/libtmux/libtmux-dotnet.git
+$ git -C libtmux-source fetch --depth=1 origin \
+    320dc64f4b8b7815842471327a5e6b84a1499bf8
 $ git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -42,7 +44,9 @@ package and its core dependency from that checkout.
   <ItemGroup>
     <Compile Include="Program.cs" />
     <ProjectReference Include="libtmux-source/src/LibTmux/LibTmux.csproj" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.Workspace/LibTmux.Workspace.csproj" />
+    <ProjectReference
+        Include="libtmux-source/src/LibTmux.Workspace/LibTmux.Workspace.csproj"
+    />
   </ItemGroup>
 </Project>
 ```
@@ -63,9 +67,10 @@ internal static class Program
     private static async Task Main()
     {
         if (OperatingSystem.IsWindows())
-            throw new PlatformNotSupportedException("This example requires POSIX tmux.");
+            throw new PlatformNotSupportedException("Requires POSIX tmux.");
 
-        using var deadline = new CancellationTokenSource(TimeSpan.FromSeconds(30));
+        TimeSpan limit = TimeSpan.FromSeconds(30);
+        using var deadline = new CancellationTokenSource(limit);
         WorkspaceFile workspace = WorkspaceFile.Parse("""
             session_name: built
             options:
@@ -89,7 +94,8 @@ internal static class Program
             deadline.Token);
         WorkspaceResult result = await new WorkspaceBuilder(owned.Value)
             .BuildAsync(workspace, deadline.Token);
-        Console.WriteLine($"{result.Session.Name}: {result.Windows.Count} windows");
+        int windows = result.Windows.Count;
+        Console.WriteLine($"{result.Session.Name}: {windows} windows");
         foreach (string unsupported in result.Unsupported)
             Console.WriteLine(unsupported);
     }
diff --git a/site/src/content/docs/ports/cxx/examples/capture-pane-output.md b/site/src/content/docs/ports/cxx/examples/capture-pane-output.md
index 75d0ba8c1..5bfb992b9 100644
--- a/site/src/content/docs/ports/cxx/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/cxx/examples/capture-pane-output.md
@@ -61,8 +61,9 @@ int main() {
 
     auto sent = pane.send_line("printf '\\nlibtmux capture ready\\n'");
     if (!sent) throw std::runtime_error(sent.error().diagnostic);
-    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds{5};
-    while (std::chrono::steady_clock::now() < deadline && !captured) {
+    using Clock = std::chrono::steady_clock;
+    const auto deadline = Clock::now() + std::chrono::seconds{5};
+    while (Clock::now() < deadline && !captured) {
       auto text = pane.capture();
       if (!text) throw std::runtime_error(text.error().diagnostic);
       std::istringstream lines{*text};
diff --git a/site/src/content/docs/ports/cxx/guides/attaching-to-tmux.md b/site/src/content/docs/ports/cxx/guides/attaching-to-tmux.md
index 5e763e120..c429c2886 100644
--- a/site/src/content/docs/ports/cxx/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/cxx/guides/attaching-to-tmux.md
@@ -36,7 +36,9 @@ the example.
 int main() {
   try {
     const char* socket = std::getenv("LIBTMUX_SOCKET_PATH");
-    if (!socket) throw std::runtime_error("Set LIBTMUX_SOCKET_PATH to an existing socket");
+    if (!socket) {
+      throw std::runtime_error("Set LIBTMUX_SOCKET_PATH to an existing socket");
+    }
     auto server = libtmux::Server::at_socket_path(socket);
     if (!server) throw std::runtime_error(server.error().diagnostic);
     auto sessions = server->sessions();
diff --git a/site/src/content/docs/ports/cxx/workspace/internals/examples.md b/site/src/content/docs/ports/cxx/workspace/internals/examples.md
index cfa208c6b..16a81d8af 100644
--- a/site/src/content/docs/ports/cxx/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/cxx/workspace/internals/examples.md
@@ -23,8 +23,10 @@ In a new directory, fetch the source revision used by this documentation:
 $ mkdir cxx-workspace-example
 $ cd cxx-workspace-example
 $ git init -q libtmux-source
-$ git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-cxx.git
-$ git -C libtmux-source fetch --depth=1 origin 393d4b0ad666f18a6581f1eb281741a75a7503f0
+$ git -C libtmux-source remote add origin \
+    https://github.com/libtmux/libtmux-cxx.git
+$ git -C libtmux-source fetch --depth=1 origin \
+    393d4b0ad666f18a6581f1eb281741a75a7503f0
 $ git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -70,16 +72,20 @@ int main() {
     auto cleanup = std::make_shared<libtmux::test::TeardownReport>();
     bool complete = false;
     try {
-        auto owned = libtmux::test::ScopedTmuxServer::start({.teardown_report = cleanup});
+        auto owned = libtmux::test::ScopedTmuxServer::start(
+            {.teardown_report = cleanup});
         if (!owned) throw std::runtime_error(owned.error());
-        auto server = libtmux::Server::at_socket_path(owned->socket_path().string());
+        auto socket = owned->socket_path().string();
+        auto server = libtmux::Server::at_socket_path(socket);
         if (!server) throw std::runtime_error(server.error().diagnostic);
 
         namespace workspace = libtmux::workspace;
         const workspace::Workspace description{
             .session_name = "built",
-            .windows = {{.name = "editor", .panes = {{.shell = "/bin/cat"}, {.shell = "/bin/cat"}}},
-                        {.name = "logs", .panes = {{.shell = "/bin/cat"}}}}};
+            .windows = {
+                {.name = "editor",
+                 .panes = {{.shell = "/bin/cat"}, {.shell = "/bin/cat"}}},
+                {.name = "logs", .panes = {{.shell = "/bin/cat"}}}}};
         const auto built = workspace::build(*server, description);
         if (!built) throw std::runtime_error(built.error().reason);
         const auto windows = built->windows();
diff --git a/site/src/content/docs/ports/fsharp/concepts/queries.md b/site/src/content/docs/ports/fsharp/concepts/queries.md
index 1fdbbed29..aeea2f9c0 100644
--- a/site/src/content/docs/ports/fsharp/concepts/queries.md
+++ b/site/src/content/docs/ports/fsharp/concepts/queries.md
@@ -27,7 +27,8 @@ Use an empty directory on Linux with Git, tmux 3.2a or newer, and .NET SDK 10.0.
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(Example).fs" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
+    <ProjectReference
+      Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
   </ItemGroup>
 </Project>
 ```
@@ -58,7 +59,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -95,22 +97,32 @@ let run () = task {
     let! captured = server |> Server.capture token SnapshotDepth.Sessions
     let prefix = Filter.startsWith "work-" SessionFields.name
     let matching = captured.Sessions |> Query.matching prefix
-    let names = matching |> Seq.map (fun session -> session.Name) |> Seq.sort |> Seq.toList
+    let names =
+        matching
+        |> Seq.map (fun session -> session.Name)
+        |> Seq.sort
+        |> Seq.toList
     if names <> [ "work-one"; "work-two" ] then failwith "Unexpected sessions"
     printfn "%s" (String.concat ", " names)
-    let native = captured.Sessions |> Seq.filter (fun session -> session.Name.StartsWith("work-"))
-    if Seq.length native <> matching.Count then failwith "Local filters disagree"
+    let native =
+        captured.Sessions
+        |> Seq.filter (fun session -> session.Name.StartsWith("work-"))
+    if Seq.length native <> matching.Count then
+        failwith "Local filters disagree"
     let onlyOne = Filter.allOf [
         Filter.startsWith "work-" SessionFields.name
         Filter.eq "work-one" SessionFields.name
     ]
     let selected = captured.Sessions |> Query.matching onlyOne
-    if selected.Count <> 1 || selected[0].Name <> "work-one" then failwith "Wrong AND result"
+    if selected.Count <> 1 || selected[0].Name <> "work-one" then
+        failwith "Wrong AND result"
     let either = Filter.oneOf [ "work-one"; "work-two" ] SessionFields.name
-    if (captured.Sessions |> Query.matching either).Count <> 2 then failwith "Wrong OR result"
+    let eitherMatches = captured.Sessions |> Query.matching either
+    if eitherMatches.Count <> 2 then failwith "Wrong OR result"
     let excluded = Filter.eq "work-one" SessionFields.name |> Filter.negate
     let remaining = captured.Sessions |> Query.matching excluded
-    if remaining.Count <> 1 || remaining[0].Name <> "work-two" then failwith "Wrong NOT result"
+    if remaining.Count <> 1 || remaining[0].Name <> "work-two" then
+        failwith "Wrong NOT result"
 }
 
 [<EntryPoint>]
@@ -125,7 +137,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Local \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Local
 ```
 
@@ -156,11 +169,14 @@ let run () = task {
         ServerConnectionOptions(SocketPath = socket), token)
     let! captured = server |> Server.capture token SnapshotDepth.Sessions
     for name in [ "work-one"; "missing" ] do
-        let matches = captured.Sessions |> Query.matching (Filter.eq name SessionFields.name)
+        let matches =
+            captured.Sessions
+            |> Query.matching (Filter.eq name SessionFields.name)
         match matches |> Selection.exactlyOne with
         | Ok session -> printfn "%s: selected" session.Name
         | Error CardinalityError.NoMatches -> printfn "%s: absent" name
-        | Error CardinalityError.MultipleMatches -> failwithf "Ambiguous session: %s" name
+        | Error CardinalityError.MultipleMatches ->
+            failwithf "Ambiguous session: %s" name
     let many = captured.Sessions |> Selection.exactlyOne
     match many with
     | Error CardinalityError.MultipleMatches -> printfn "work-: ambiguous"
@@ -179,7 +195,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Cardinality \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Cardinality
 ```
 
@@ -217,8 +234,10 @@ let run () = task {
     let! captured = server |> Server.capture token depth
     let selected = captured.Sessions |> Query.matching withEditor
     let excluded = captured.Sessions |> Query.matching withoutEditor
-    if selected.Count <> 1 || selected[0].Name <> "work-one" then failwith "Wrong editor session"
-    if excluded.Count <> 1 || excluded[0].Name <> "work-two" then failwith "Wrong other session"
+    if selected.Count <> 1 || selected[0].Name <> "work-one" then
+        failwith "Wrong editor session"
+    if excluded.Count <> 1 || excluded[0].Name <> "work-two" then
+        failwith "Wrong other session"
     printfn "editor: %s" selected[0].Name
     printfn "no editor: %s" excluded[0].Name
 }
@@ -235,7 +254,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Relations \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Relations
 ```
 
diff --git a/site/src/content/docs/ports/fsharp/concepts/server-session-window-pane.md b/site/src/content/docs/ports/fsharp/concepts/server-session-window-pane.md
index 9f648ecba..b00ccf5e0 100644
--- a/site/src/content/docs/ports/fsharp/concepts/server-session-window-pane.md
+++ b/site/src/content/docs/ports/fsharp/concepts/server-session-window-pane.md
@@ -29,7 +29,8 @@ Use an empty directory on Linux with Git, tmux 3.2a or newer, and .NET SDK 10.0.
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(Example).fs" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
+    <ProjectReference
+      Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
   </ItemGroup>
 </Project>
 ```
@@ -60,7 +61,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -96,8 +98,14 @@ let run () = task {
         ServerConnectionOptions(SocketPath = socket), token)
     let! captured = server |> Server.capture token SnapshotDepth.Panes
     let sessions = captured.Sessions
-    let windows = sessions |> Seq.collect (fun session -> session.Windows) |> Seq.toList
-    let panes = windows |> Seq.collect (fun window -> window.Panes) |> Seq.toList
+    let windows =
+        sessions
+        |> Seq.collect (fun session -> session.Windows)
+        |> Seq.toList
+    let panes =
+        windows
+        |> Seq.collect (fun window -> window.Panes)
+        |> Seq.toList
     if sessions.Count <> 2 || windows.Length <> 2 || panes.Length <> 2 then
         failwith "Unexpected hierarchy"
     for session in sessions do
@@ -117,7 +125,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Hierarchy \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Hierarchy
 ```
 
@@ -149,14 +158,16 @@ let run () = task {
     let! server = LibTmux.Server.ConnectAsync(
         ServerConnectionOptions(SocketPath = socket), token)
     let! captured = server |> Server.capture token SnapshotDepth.Windows
-    let session = captured.Sessions |> Seq.find (fun session -> session.Name = "work-one")
+    let session = captured.Sessions |> Seq.find (fun s -> s.Name = "work-one")
     let before = session.Windows[0]
     let! after = before.RenameAsync("renamed", token)
-    if before.Name <> "editor" || after.Name <> "renamed" then failwith "Unexpected rename state"
+    if before.Name <> "editor" || after.Name <> "renamed" then
+        failwith "Unexpected rename state"
     let! refreshed = server |> Server.capture token SnapshotDepth.Windows
     let session = refreshed.Sessions |> Seq.find (fun s -> s.Name = "work-one")
     let window = session.Windows[0]
-    if window.Name <> "renamed" then failwith "Fresh read did not see the rename"
+    if window.Name <> "renamed" then
+        failwith "Fresh read did not see the rename"
     printfn "%s -> %s" before.Name window.Name
 }
 
@@ -172,7 +183,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Refresh \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Refresh
 ```
 
diff --git a/site/src/content/docs/ports/fsharp/concepts/transports.md b/site/src/content/docs/ports/fsharp/concepts/transports.md
index b0fc28a17..ff865c7b6 100644
--- a/site/src/content/docs/ports/fsharp/concepts/transports.md
+++ b/site/src/content/docs/ports/fsharp/concepts/transports.md
@@ -27,7 +27,8 @@ Use an empty directory on Linux with Git, tmux 3.2a or newer, and .NET SDK 10.0.
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(Example).fs" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
+    <ProjectReference
+      Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
   </ItemGroup>
 </Project>
 ```
@@ -58,7 +59,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -95,22 +97,32 @@ let run () = task {
     let! captured = server |> Server.capture token SnapshotDepth.Sessions
     let prefix = Filter.startsWith "work-" SessionFields.name
     let matching = captured.Sessions |> Query.matching prefix
-    let names = matching |> Seq.map (fun session -> session.Name) |> Seq.sort |> Seq.toList
+    let names =
+        matching
+        |> Seq.map (fun session -> session.Name)
+        |> Seq.sort
+        |> Seq.toList
     if names <> [ "work-one"; "work-two" ] then failwith "Unexpected sessions"
     printfn "%s" (String.concat ", " names)
-    let native = captured.Sessions |> Seq.filter (fun session -> session.Name.StartsWith("work-"))
-    if Seq.length native <> matching.Count then failwith "Local filters disagree"
+    let native =
+        captured.Sessions
+        |> Seq.filter (fun session -> session.Name.StartsWith("work-"))
+    if Seq.length native <> matching.Count then
+        failwith "Local filters disagree"
     let onlyOne = Filter.allOf [
         Filter.startsWith "work-" SessionFields.name
         Filter.eq "work-one" SessionFields.name
     ]
     let selected = captured.Sessions |> Query.matching onlyOne
-    if selected.Count <> 1 || selected[0].Name <> "work-one" then failwith "Wrong AND result"
+    if selected.Count <> 1 || selected[0].Name <> "work-one" then
+        failwith "Wrong AND result"
     let either = Filter.oneOf [ "work-one"; "work-two" ] SessionFields.name
-    if (captured.Sessions |> Query.matching either).Count <> 2 then failwith "Wrong OR result"
+    let eitherMatches = captured.Sessions |> Query.matching either
+    if eitherMatches.Count <> 2 then failwith "Wrong OR result"
     let excluded = Filter.eq "work-one" SessionFields.name |> Filter.negate
     let remaining = captured.Sessions |> Query.matching excluded
-    if remaining.Count <> 1 || remaining[0].Name <> "work-two" then failwith "Wrong NOT result"
+    if remaining.Count <> 1 || remaining[0].Name <> "work-two" then
+        failwith "Wrong NOT result"
 }
 
 [<EntryPoint>]
@@ -125,7 +137,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Local \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Local
 ```
 
@@ -155,10 +168,12 @@ let run () = task {
     let! server = LibTmux.Server.ConnectAsync(
         ServerConnectionOptions(SocketPath = socket), token)
     do! server |> Control.withSession token (fun control -> task {
-        let command = TmuxCommand.Create("list-sessions", "-F", "#{session_name}")
+        let command =
+            TmuxCommand.Create("list-sessions", "-F", "#{session_name}")
         let! lines = control.SendAsync(command, token)
         let names = lines |> Seq.sort |> Seq.toList
-        if names <> [ "work-one"; "work-two" ] then failwith "Unexpected sessions"
+        if names <> [ "work-one"; "work-two" ] then
+            failwith "Unexpected sessions"
         printfn "%s" (String.concat ", " names)
     })
     let! captured = server |> Server.capture token SnapshotDepth.Sessions
@@ -178,7 +193,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Control \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Control
 ```
 
diff --git a/site/src/content/docs/ports/fsharp/concepts/workspaces.md b/site/src/content/docs/ports/fsharp/concepts/workspaces.md
index 6013d8a3a..b0f9cf4e3 100644
--- a/site/src/content/docs/ports/fsharp/concepts/workspaces.md
+++ b/site/src/content/docs/ports/fsharp/concepts/workspaces.md
@@ -25,7 +25,8 @@ Use an empty directory on Linux with Git, tmux 3.2a or newer, and .NET SDK 10.0.
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="$(Example).fs" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
+    <ProjectReference
+      Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
   </ItemGroup>
 </Project>
 ```
@@ -56,7 +57,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -95,9 +97,11 @@ let run () = task {
     let request = NewWindowRequest(Name = "tools", Command = "/bin/cat")
     let! window = session.CreateWindowAsync(request, token)
     let! panes = window.GetPanesAsync(token)
-    let split = SplitPaneRequest(Direction = PaneDirection.Right, Command = "/bin/cat")
+    let split =
+        SplitPaneRequest(Direction = PaneDirection.Right, Command = "/bin/cat")
     let! _ = panes[0] |> Pane.split token split
-    let! _ = window.SelectLayoutAsync(SelectLayoutRequest(Layout = "even-horizontal"), token)
+    let layout = SelectLayoutRequest(Layout = "even-horizontal")
+    let! _ = window.SelectLayoutAsync(layout, token)
     let! refreshed = window.GetPanesAsync(token)
     if refreshed.Count <> 2 then failwith "Expected two panes"
     printfn "tools: 2 panes"
@@ -115,7 +119,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=Layout \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Layout
 ```
 
@@ -146,8 +151,10 @@ let run () = task {
         ServerConnectionOptions(SocketPath = socket), token)
     let ensureTools () = task {
         let! captured = server |> Server.capture token SnapshotDepth.Windows
-        let session = captured.Sessions |> Seq.find (fun s -> s.Name = "work-one")
-        match session.Windows |> Seq.tryFind (fun window -> window.Name = "tools") with
+        let session =
+            captured.Sessions |> Seq.find (fun s -> s.Name = "work-one")
+        let tools = session.Windows |> Seq.tryFind (fun w -> w.Name = "tools")
+        match tools with
         | Some window -> return window
         | None ->
             return! session.CreateWindowAsync(
@@ -158,7 +165,8 @@ let run () = task {
     if first.Id <> second.Id then failwith "Created duplicate windows"
     let! captured = server |> Server.capture token SnapshotDepth.Windows
     let session = captured.Sessions |> Seq.find (fun s -> s.Name = "work-one")
-    if session.Windows.Count <> 2 then failwith "Expected editor and tools windows"
+    if session.Windows.Count <> 2 then
+        failwith "Expected editor and tools windows"
     printfn "one tools window after two calls"
 }
 
@@ -174,7 +182,8 @@ let main _ =
 
 ```console
 $ dotnet build Query.fsproj --maxcpucount:1 -p:Example=ReuseLayout \
-  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath="$PWD/.packages" &&
+    -p:DisableImplicitLibraryPacksFolder=true \
+    -p:RestorePackagesPath="$PWD/.packages" &&
   sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=ReuseLayout
 ```
 
diff --git a/site/src/content/docs/ports/fsharp/examples/capture-pane-output.md b/site/src/content/docs/ports/fsharp/examples/capture-pane-output.md
index 93173af5e..044ed3aec 100644
--- a/site/src/content/docs/ports/fsharp/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/fsharp/examples/capture-pane-output.md
@@ -30,7 +30,8 @@ open LibTmux
 open LibTmux.FSharp
 
 let capture () = task {
-    let directory = Path.Combine("/tmp/libtmux-dotnet-dev", Guid.NewGuid().ToString("N"))
+    let root = "/tmp/libtmux-dotnet-dev"
+    let directory = Path.Combine(root, Guid.NewGuid().ToString("N"))
     Directory.CreateDirectory(directory) |> ignore
     let errors = ResizeArray<exn>()
     let mutable owned: OwnedServerScope option = None
@@ -51,8 +52,11 @@ let capture () = task {
             NewSessionRequest(Name = "capture", Command = "/bin/sh"), token)
         let! panes = session.GetPanesAsync(token)
         let pane = panes[0]
-        do! pane |> Pane.sendKeys token (SendKeysRequest(
-            Text = "printf '\\nlibtmux capture ready\\n'", Literal = true, Enter = true))
+        let keys = SendKeysRequest(
+            Text = "printf '\\nlibtmux capture ready\\n'",
+            Literal = true,
+            Enter = true)
+        do! pane |> Pane.sendKeys token keys
 
         let elapsed = Stopwatch.StartNew()
         let mutable captured = false
@@ -61,7 +65,8 @@ let capture () = task {
             captured <- Seq.contains "libtmux capture ready" lines
             if not captured then do! Task.Delay(25, token)
         if not captured then
-            raise (TimeoutException("Output did not arrive within five seconds"))
+            let message = "Output did not arrive within five seconds"
+            raise (TimeoutException(message))
         printfn "libtmux capture ready"
     with error -> errors.Add(error)
 
@@ -114,7 +119,8 @@ Save `Capture.fsproj` beside `Program.fs`.
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Program.fs" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
+    <ProjectReference
+      Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
   </ItemGroup>
 </Project>
 ```
diff --git a/site/src/content/docs/ports/fsharp/guides/attaching-to-tmux.md b/site/src/content/docs/ports/fsharp/guides/attaching-to-tmux.md
index 26102eed2..2f274c82d 100644
--- a/site/src/content/docs/ports/fsharp/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/fsharp/guides/attaching-to-tmux.md
@@ -39,7 +39,8 @@ let connect () = task {
     use timeout = new CancellationTokenSource(TimeSpan.FromSeconds(5.0))
     let! server = Server.ConnectAsync(
         ServerConnectionOptions(SocketPath = socket), timeout.Token)
-    let! exists = server.HasSessionAsync("work", cancellationToken = timeout.Token)
+    let! exists =
+        server.HasSessionAsync("work", cancellationToken = timeout.Token)
     if not exists then invalidOp "The work session does not exist"
     printfn "work"
 }
@@ -70,7 +71,8 @@ Save this file beside the program using the displayed filename.
   </PropertyGroup>
   <ItemGroup>
     <Compile Include="Program.fs" />
-    <ProjectReference Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
+    <ProjectReference
+      Include="libtmux-source/src/LibTmux.FSharp/LibTmux.FSharp.fsproj" />
   </ItemGroup>
 </Project>
 ```
diff --git a/site/src/content/docs/ports/go/concepts/queries.md b/site/src/content/docs/ports/go/concepts/queries.md
index b23c6b5d6..6c98dbb97 100644
--- a/site/src/content/docs/ports/go/concepts/queries.md
+++ b/site/src/content/docs/ports/go/concepts/queries.md
@@ -67,7 +67,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -124,7 +125,10 @@ func run() error {
 	if socket == "" {
 		return errors.New("run this program with run.sh")
 	}
-	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
+	server, err := tmux.NewServer(tmux.ServerOptions{
+		SocketPath: socket,
+		ConfigFile: "/dev/null",
+	})
 	if err != nil {
 		return err
 	}
@@ -140,7 +144,11 @@ func run() error {
 		filter tmux.SessionFilter
 		want   string
 	}{
-		{"prefix", tmux.SessionFilter{NameRegex: "^work-"}, "work-one, work-two"},
+		{
+			"prefix",
+			tmux.SessionFilter{NameRegex: "^work-"},
+			"work-one, work-two",
+		},
 		{"AND and NOT", tmux.SessionFilter{
 			NameRegex: "^work-", Not: tmux.Ptr(tmux.SessionNameIs("work-two")),
 		}, "work-one"},
@@ -172,7 +180,8 @@ func run() error {
 		}
 		fmt.Printf("%s: %s\n", test.label, got)
 	}
-	_, err = tmuxq.Matching(snapshot.Sessions(), tmux.SessionFilter{NameRegex: "["})
+	invalid := tmux.SessionFilter{NameRegex: "["}
+	_, err = tmuxq.Matching(snapshot.Sessions(), invalid)
 	if !errors.Is(err, tmux.ErrInvalidFilter) {
 		return fmt.Errorf("expected invalid filter, got %v", err)
 	}
@@ -231,7 +240,10 @@ func run() error {
 	if socket == "" {
 		return errors.New("run this program with run.sh")
 	}
-	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
+	server, err := tmux.NewServer(tmux.ServerOptions{
+		SocketPath: socket,
+		ConfigFile: "/dev/null",
+	})
 	if err != nil {
 		return err
 	}
@@ -249,7 +261,11 @@ func run() error {
 	}{
 		{"work-one", tmux.SessionNameIs("work-one"), nil},
 		{"missing", tmux.SessionNameIs("missing"), tmuxq.ErrNoMatch},
-		{"work-", tmux.SessionFilter{NameRegex: "^work-"}, tmuxq.ErrMultipleMatches},
+		{
+			"work-",
+			tmux.SessionFilter{NameRegex: "^work-"},
+			tmuxq.ErrMultipleMatches,
+		},
 	}
 	for _, test := range cases {
 		predicate, err := test.filter.Predicate()
@@ -329,7 +345,10 @@ func run() error {
 	if socket == "" {
 		return errors.New("run this program with run.sh")
 	}
-	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
+	server, err := tmux.NewServer(tmux.ServerOptions{
+		SocketPath: socket,
+		ConfigFile: "/dev/null",
+	})
 	if err != nil {
 		return err
 	}
@@ -351,12 +370,17 @@ func run() error {
 		{"every window is editor", tmux.WindowRel{Every: &editor}, "work-one"},
 	}
 	for _, test := range cases {
-		matches, err := tmuxq.Matching(snapshot.Sessions(), tmux.SessionFilter{Windows: &test.relation})
+		filter := tmux.SessionFilter{Windows: &test.relation}
+		matches, err := tmuxq.Matching(snapshot.Sessions(), filter)
 		if err != nil {
 			return err
 		}
 		if len(matches) != 1 {
-			return fmt.Errorf("%s: expected one match, got %d", test.label, len(matches))
+			return fmt.Errorf(
+				"%s: expected one match, got %d",
+				test.label,
+				len(matches),
+			)
 		}
 		name, ok := matches[0].Name()
 		if !ok || name != test.want {
@@ -374,9 +398,10 @@ func run() error {
 		return errors.New("live filter should return work-one")
 	}
 	if _, captured := live[0].Windows(); captured {
-		return errors.New("a session-only listing should not contain window relations")
+		return errors.New("a session listing should not have windows")
 	}
-	matches, err := tmuxq.Matching(live, tmux.SessionFilter{Windows: &tmux.WindowRel{None: &editor}})
+	none := tmux.SessionFilter{Windows: &tmux.WindowRel{None: &editor}}
+	matches, err := tmuxq.Matching(live, none)
 	if err != nil {
 		return err
 	}
diff --git a/site/src/content/docs/ports/go/concepts/server-session-window-pane.md b/site/src/content/docs/ports/go/concepts/server-session-window-pane.md
index 834beed33..95f95f63d 100644
--- a/site/src/content/docs/ports/go/concepts/server-session-window-pane.md
+++ b/site/src/content/docs/ports/go/concepts/server-session-window-pane.md
@@ -66,7 +66,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -130,7 +131,10 @@ func run() error {
 	if socket == "" {
 		return errors.New("run this program with run.sh")
 	}
-	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
+	server, err := tmux.NewServer(tmux.ServerOptions{
+		SocketPath: socket,
+		ConfigFile: "/dev/null",
+	})
 	if err != nil {
 		return err
 	}
@@ -138,13 +142,17 @@ func run() error {
 	defer cancel()
 
 	session, err := server.NewSession(ctx, tmux.NewSessionRequest{
-		Name: "tools", WindowName: "editor", Command: "/bin/cat", Width: 100, Height: 30,
+		Name:       "tools",
+		WindowName: "editor",
+		Command:    "/bin/cat",
+		Width:      100,
+		Height:     30,
 	})
 	if err != nil {
 		return fmt.Errorf("create tools session: %w", err)
 	}
 	if _, captured := session.Windows(); captured {
-		return errors.New("a newly created session unexpectedly includes window relations")
+		return errors.New("a new session unexpectedly includes windows")
 	}
 	window, err := session.NewWindow(ctx, tmux.NewWindowRequest{
 		Name: tmux.Ptr("logs"), Command: "/bin/cat",
@@ -152,7 +160,8 @@ func run() error {
 	if err != nil {
 		return fmt.Errorf("create logs window: %w", err)
 	}
-	if _, err := window.SplitPane(ctx, tmux.SplitPaneRequest{Command: "/bin/cat"}); err != nil {
+	split := tmux.SplitPaneRequest{Command: "/bin/cat"}
+	if _, err := window.SplitPane(ctx, split); err != nil {
 		return fmt.Errorf("split logs window: %w", err)
 	}
 
@@ -169,8 +178,12 @@ func run() error {
 		return err
 	}
 	if len(sessions) != 3 || len(windows) != 4 || len(panes) != 5 {
-		return fmt.Errorf("unexpected counts: %d sessions, %d windows, %d panes",
-			len(sessions), len(windows), len(panes))
+		return fmt.Errorf(
+			"unexpected counts: %d sessions, %d windows, %d panes",
+			len(sessions),
+			len(windows),
+			len(panes),
+		)
 	}
 	fmt.Println("server: 3 sessions, 4 windows, 5 panes")
 
@@ -246,7 +259,10 @@ func run() error {
 	if socket == "" {
 		return errors.New("run this program with run.sh")
 	}
-	server, err := tmux.NewServer(tmux.ServerOptions{SocketPath: socket, ConfigFile: "/dev/null"})
+	server, err := tmux.NewServer(tmux.ServerOptions{
+		SocketPath: socket,
+		ConfigFile: "/dev/null",
+	})
 	if err != nil {
 		return err
 	}
@@ -257,7 +273,9 @@ func run() error {
 	if err != nil {
 		return err
 	}
-	if len(before.Sessions()) != 2 || len(before.Windows()) != 2 || len(before.Panes()) != 2 {
+	if len(before.Sessions()) != 2 ||
+		len(before.Windows()) != 2 ||
+		len(before.Panes()) != 2 {
 		return errors.New("expected the initial two-session fixture")
 	}
 	var editor tmux.Window
@@ -295,7 +313,7 @@ func run() error {
 	oldName, oldOK := editor.Name()
 	newName, newOK := renamed.Name()
 	if !oldOK || !newOK || oldName != "editor" || newName != "renamed" {
-		return errors.New("rename should return a new record without changing the old one")
+		return errors.New("rename should leave the old record unchanged")
 	}
 	after, err := server.Snapshot(ctx)
 	if err != nil {
@@ -309,7 +327,12 @@ func run() error {
 	if !ok || currentName != "renamed" {
 		return errors.New("fresh snapshot missed the rename")
 	}
-	fmt.Printf("captured: %s; returned: %s; fresh: %s\n", oldName, newName, currentName)
+	fmt.Printf(
+		"captured: %s; returned: %s; fresh: %s\n",
+		oldName,
+		newName,
+		currentName,
+	)
 	return nil
 }
 ```
diff --git a/site/src/content/docs/ports/go/examples/capture-pane-output.md b/site/src/content/docs/ports/go/examples/capture-pane-output.md
index ee6968b68..5b6b6b2c5 100644
--- a/site/src/content/docs/ports/go/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/go/examples/capture-pane-output.md
@@ -84,7 +84,8 @@ func capture() (err error) {
   }
   pane := panes[0]
   command := "printf '\\nlibtmux capture ready\\n'"
-  if err := pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &command}); err != nil {
+  keys := tmux.SendKeysRequest{Command: &command}
+  if err := pane.SendKeys(ctx, keys); err != nil {
     return err
   }
   for {
diff --git a/site/src/content/docs/ports/go/mcp/examples/inspect-sessions.md b/site/src/content/docs/ports/go/mcp/examples/inspect-sessions.md
index 2f8188c22..4b1f8d438 100644
--- a/site/src/content/docs/ports/go/mcp/examples/inspect-sessions.md
+++ b/site/src/content/docs/ports/go/mcp/examples/inspect-sessions.md
@@ -103,7 +103,8 @@ func run() (result error) {
 		return errors.Join(err, os.RemoveAll(directory))
 	}
 	defer func() {
-		cleanup, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		background := context.Background()
+		cleanup, cancel := context.WithTimeout(background, 5*time.Second)
 		defer cancel()
 		if err := server.Kill(cleanup); err != nil {
 			result = errors.Join(result, fmt.Errorf(
@@ -150,7 +151,8 @@ func run() (result error) {
 	}
 	defer func() {
 		if err := connection.Close(); err != nil {
-			result = errors.Join(result, fmt.Errorf("close MCP client: %w", err))
+			closeErr := fmt.Errorf("close MCP client: %w", err)
+			result = errors.Join(result, closeErr)
 		}
 	}()
 
@@ -184,7 +186,8 @@ func run() (result error) {
 	if err := json.Unmarshal(data, &listed); err != nil {
 		return fmt.Errorf("decode sessions: %w", err)
 	}
-	if len(listed.Sessions) != 1 || listed.Sessions[0].ID != string(created.ID()) {
+	want := string(created.ID())
+	if len(listed.Sessions) != 1 || listed.Sessions[0].ID != want {
 		return fmt.Errorf("unexpected session listing: %s", data)
 	}
 	session := listed.Sessions[0]
diff --git a/site/src/content/docs/ports/go/mcp/examples/run-command.md b/site/src/content/docs/ports/go/mcp/examples/run-command.md
index 944f8085c..a8063daea 100644
--- a/site/src/content/docs/ports/go/mcp/examples/run-command.md
+++ b/site/src/content/docs/ports/go/mcp/examples/run-command.md
@@ -103,7 +103,8 @@ func run() (result error) {
 		return errors.Join(err, os.RemoveAll(directory))
 	}
 	defer func() {
-		cleanup, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		background := context.Background()
+		cleanup, cancel := context.WithTimeout(background, 5*time.Second)
 		defer cancel()
 		if err := server.Kill(cleanup); err != nil {
 			result = errors.Join(result, fmt.Errorf(
@@ -156,7 +157,8 @@ func run() (result error) {
 	}
 	defer func() {
 		if err := connection.Close(); err != nil {
-			result = errors.Join(result, fmt.Errorf("close MCP client: %w", err))
+			closeErr := fmt.Errorf("close MCP client: %w", err)
+			result = errors.Join(result, closeErr)
 		}
 	}()
 
@@ -197,13 +199,18 @@ func run() (result error) {
 		return fmt.Errorf("decode command result: %w", err)
 	}
 	if ran.TimedOut || ran.ExitStatus == nil {
-		return errors.New("command completion is unconfirmed; do not retry it automatically")
+		return errors.New("command completion is unconfirmed; " +
+			"do not retry it automatically")
 	}
-	if ran.PaneID != string(pane.ID()) || len(ran.ResolvedPaneIDs) != 1 || ran.ResolvedPaneIDs[0] != ran.PaneID {
+	paneID := string(pane.ID())
+	resolved := ran.ResolvedPaneIDs
+	if ran.PaneID != paneID || len(resolved) != 1 || resolved[0] != paneID {
 		return fmt.Errorf("unexpected pane selection: %s", data)
 	}
 	if ran.OutputUnavailable != "" || ran.LinesMissed {
-		return fmt.Errorf("command exited %d, but its output is incomplete: %s", *ran.ExitStatus, data)
+		return fmt.Errorf(
+			"command exited %d, but its output is incomplete: %s",
+			*ran.ExitStatus, data)
 	}
 	fmt.Printf("exit status: %d\n", *ran.ExitStatus)
 	for _, line := range ran.Output {
diff --git a/site/src/content/docs/ports/go/workspace/internals/examples.md b/site/src/content/docs/ports/go/workspace/internals/examples.md
index df5219ba9..fa59cb355 100644
--- a/site/src/content/docs/ports/go/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/go/workspace/internals/examples.md
@@ -26,8 +26,10 @@ $ mkdir go-workspace-example && cd go-workspace-example
 
 ```console
 $ git init libtmux-source && \
-    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-go.git && \
-    git -C libtmux-source fetch --depth=1 origin bb06e26e116e941813ca40bf45e7e3a47d38f52a && \
+    git -C libtmux-source remote add origin \
+      https://github.com/libtmux/libtmux-go.git && \
+    git -C libtmux-source fetch --depth=1 origin \
+      bb06e26e116e941813ca40bf45e7e3a47d38f52a && \
     git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -119,10 +121,18 @@ func run() (err error) {
 		return errors.Join(err, os.RemoveAll(directory))
 	}
 	defer func() {
-		cleanup, cancel := context.WithTimeout(context.Background(), 5*time.Second)
+		cleanup, cancel := context.WithTimeout(
+			context.Background(),
+			5*time.Second,
+		)
 		defer cancel()
 		if cleanupErr := server.Kill(cleanup); cleanupErr != nil {
-			err = errors.Join(err, fmt.Errorf("stop private server at %s: %w", socket, cleanupErr))
+			stopErr := fmt.Errorf(
+				"stop private server at %s: %w",
+				socket,
+				cleanupErr,
+			)
+			err = errors.Join(err, stopErr)
 			return
 		}
 		err = errors.Join(err, os.RemoveAll(directory))
@@ -142,7 +152,11 @@ func run() (err error) {
 		return err
 	}
 	if len(windows) != 2 || len(panes) != 3 {
-		return fmt.Errorf("expected two windows and three panes, got %d and %d", len(windows), len(panes))
+		return fmt.Errorf(
+			"expected two windows and three panes, got %d and %d",
+			len(windows),
+			len(panes),
+		)
 	}
 	fmt.Printf("built: %d windows\npanes: %d\n", len(windows), len(panes))
 	return nil
diff --git a/site/src/content/docs/ports/java/examples/capture-pane-output.md b/site/src/content/docs/ports/java/examples/capture-pane-output.md
index 5f85f67ec..a37bbc776 100644
--- a/site/src/content/docs/ports/java/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/java/examples/capture-pane-output.md
@@ -47,10 +47,13 @@ public final class Capture {
         try (Server server = Server.open(config)) {
             try {
                 Session session = server.newSession(s -> s
-                        .named("capture").running("sh").env("ENV", "/dev/null"));
+                        .named("capture")
+                        .running("sh")
+                        .env("ENV", "/dev/null"));
                 Pane pane = session.windows().get(0).panes().get(0);
                 pane.sendLine("printf '\\nlibtmux capture ready\\n'");
-                long deadline = System.nanoTime() + Duration.ofSeconds(5).toNanos();
+                long timeout = Duration.ofSeconds(5).toNanos();
+                long deadline = System.nanoTime() + timeout;
                 while (System.nanoTime() < deadline) {
                     List<String> lines = pane.capture();
                     if (lines.contains("libtmux capture ready")) {
@@ -59,7 +62,8 @@ public final class Capture {
                     }
                     Thread.sleep(20);
                 }
-                throw new IllegalStateException("Timed out waiting for pane output");
+                throw new IllegalStateException(
+                        "Timed out waiting for pane output");
             } finally {
                 server.killServer();
             }
diff --git a/site/src/content/docs/ports/java/guides/attaching-to-tmux.md b/site/src/content/docs/ports/java/guides/attaching-to-tmux.md
index eaf698352..f1e3401b8 100644
--- a/site/src/content/docs/ports/java/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/java/guides/attaching-to-tmux.md
@@ -37,7 +37,8 @@ import java.util.Objects;
 
 public final class Connect {
     public static void main(String[] args) {
-        String socket = Objects.requireNonNull(System.getenv("LIBTMUX_SOCKET_PATH"),
+        String socket = Objects.requireNonNull(
+                System.getenv("LIBTMUX_SOCKET_PATH"),
                 "Set LIBTMUX_SOCKET_PATH to an existing socket");
         ServerConfig config = ServerConfig.builder()
                 .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
@@ -47,7 +48,8 @@ public final class Connect {
             Session session = server.sessions().stream()
                     .filter(candidate -> candidate.name().equals("work"))
                     .findFirst()
-                    .orElseThrow(() -> new IllegalStateException("The work session does not exist"));
+                    .orElseThrow(() -> new IllegalStateException(
+                            "The work session does not exist"));
             System.out.println(session.name());
         }
     }
diff --git a/site/src/content/docs/ports/java/mcp/examples.md b/site/src/content/docs/ports/java/mcp/examples.md
index 8fd619e9f..127220687 100644
--- a/site/src/content/docs/ports/java/mcp/examples.md
+++ b/site/src/content/docs/ports/java/mcp/examples.md
@@ -25,8 +25,10 @@ empty project and fetch the source revision used by this example:
 ```console
 $ mkdir java-mcp-example && cd java-mcp-example && \
     git init libtmux-source && \
-    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-java.git && \
-    git -C libtmux-source fetch --depth=1 origin 842228310449e879ebcaa3f910597757c9dbffd6 && \
+    git -C libtmux-source remote add origin \
+      https://github.com/libtmux/libtmux-java.git && \
+    git -C libtmux-source fetch --depth=1 origin \
+      842228310449e879ebcaa3f910597757c9dbffd6 && \
     git -C libtmux-source checkout --detach FETCH_HEAD && \
     mkdir -p src/main/java
 ```
@@ -100,18 +102,24 @@ public final class McpExample {
                 AutoCloseable stopTmux = server::killServer) {
             server.newSession(session -> session.named("mcp-example")
                     .running("/bin/cat", "-u"));
+            Path java = Path.of(System.getProperty("java.home"), "bin", "java");
             var launcher = ServerParameters.builder("env")
                     .args("-u", "TMUX", "-u", "TMUX_PANE",
-                            "-u", "LIBTMUX_EXCLUDE_TOOLS", "-u", "LIBTMUX_SAFETY",
+                            "-u", "LIBTMUX_EXCLUDE_TOOLS",
+                            "-u", "LIBTMUX_SAFETY",
                             "-u", "LIBTMUX_WATCH",
-                            Path.of(System.getProperty("java.home"), "bin", "java").toString(),
+                            java.toString(),
                             "-classpath", System.getProperty("java.class.path"),
-                            "io.github.libtmux.mcp.Main", "--socket-name", socket)
-                    .env(Map.of("LIBTMUX_TOOLSETS", "", "LIBTMUX_TOOLS", "list_sessions",
+                            "io.github.libtmux.mcp.Main",
+                            "--socket-name", socket)
+                    .env(Map.of(
+                            "LIBTMUX_TOOLSETS", "",
+                            "LIBTMUX_TOOLS", "list_sessions",
                             "LIBTMUX_TMUX_CONFIG", "/dev/null"))
                     .build();
             var mapper = new ObjectMapper();
-            var transport = new StdioClientTransport(launcher, new JacksonMcpJsonMapper(mapper));
+            var json = new JacksonMcpJsonMapper(mapper);
+            var transport = new StdioClientTransport(launcher, json);
             transport.setStdErrorHandler(System.err::println);
             try (var client = McpClient.sync(transport)
                     .initializationTimeout(Duration.ofSeconds(10))
@@ -121,17 +129,23 @@ public final class McpExample {
                 var offered = client.listTools().tools().stream()
                         .map(McpSchema.Tool::name).toList();
                 if (!offered.equals(List.of("list_sessions"))) {
-                    throw new IllegalStateException("Unexpected tools: " + offered);
+                    throw new IllegalStateException(
+                            "Unexpected tools: " + offered);
                 }
-                var result = client.callTool(
-                        McpSchema.CallToolRequest.builder("list_sessions").build());
+                var request = McpSchema.CallToolRequest
+                        .builder("list_sessions")
+                        .build();
+                var result = client.callTool(request);
                 if (Boolean.TRUE.equals(result.isError())) {
-                    throw new IllegalStateException("Tool failed: " + result.content());
+                    throw new IllegalStateException(
+                            "Tool failed: " + result.content());
                 }
-                var sessions = mapper.valueToTree(result.structuredContent()).path("sessions");
-                if (sessions.size() != 1 ||
-                        !sessions.get(0).path("name").asText().equals("mcp-example")) {
-                    throw new IllegalStateException("Expected the example's private session");
+                var content = mapper.valueToTree(result.structuredContent());
+                var sessions = content.path("sessions");
+                String first = sessions.path(0).path("name").asText();
+                if (sessions.size() != 1 || !first.equals("mcp-example")) {
+                    throw new IllegalStateException(
+                            "Expected the example's private session");
                 }
                 System.out.println("tools: list_sessions");
                 System.out.println("sessions: mcp-example");
diff --git a/site/src/content/docs/ports/java/mcp/guides.md b/site/src/content/docs/ports/java/mcp/guides.md
index 53d9708ec..67227e0e8 100644
--- a/site/src/content/docs/ports/java/mcp/guides.md
+++ b/site/src/content/docs/ports/java/mcp/guides.md
@@ -25,8 +25,10 @@ Fetch the source revision used by this guide and build its distribution:
 
 ```console
 $ git init libtmux-source && \
-    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-java.git && \
-    git -C libtmux-source fetch --depth=1 origin 842228310449e879ebcaa3f910597757c9dbffd6 && \
+    git -C libtmux-source remote add origin \
+      https://github.com/libtmux/libtmux-java.git && \
+    git -C libtmux-source fetch --depth=1 origin \
+      842228310449e879ebcaa3f910597757c9dbffd6 && \
     git -C libtmux-source checkout --detach FETCH_HEAD && \
     ./libtmux-source/gradlew --no-daemon --max-workers=2 \
     -p libtmux-source :libtmux-mcp:installDist
@@ -72,8 +74,9 @@ tmux -S "$directory/s" -f /dev/null \
     set-environment -g ENV '' \; \
     set-environment -g BASH_ENV '' \; \
     new-session -d -s mcp-example 'exec /bin/cat'
+dist="$project/libtmux-source/libtmux-mcp/build/install/libtmux-mcp"
 LIBTMUX_TMUX_CONFIG=/dev/null LIBTMUX_TOOLSETS= LIBTMUX_TOOLS=list_sessions \
-    "$project/libtmux-source/libtmux-mcp/build/install/libtmux-mcp/bin/libtmux-mcp" \
+    "$dist/bin/libtmux-mcp" \
     --socket "$directory/s" --tmux tmux
 ```
 
diff --git a/site/src/content/docs/ports/java/workspace/internals/examples.md b/site/src/content/docs/ports/java/workspace/internals/examples.md
index abb62ab12..60176a6dd 100644
--- a/site/src/content/docs/ports/java/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/java/workspace/internals/examples.md
@@ -22,8 +22,10 @@ In a new directory, fetch the source revision used by this documentation:
 $ mkdir java-workspace-example
 $ cd java-workspace-example
 $ git init -q libtmux-source
-$ git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-java.git
-$ git -C libtmux-source fetch --depth=1 origin 842228310449e879ebcaa3f910597757c9dbffd6
+$ git -C libtmux-source remote add origin \
+    https://github.com/libtmux/libtmux-java.git
+$ git -C libtmux-source fetch --depth=1 origin \
+    842228310449e879ebcaa3f910597757c9dbffd6
 $ git -C libtmux-source checkout --detach FETCH_HEAD
 $ mkdir -p src/main/java
 ```
@@ -49,7 +51,9 @@ repositories {
 }
 
 dependencies {
-    implementation("io.github.libtmux:libtmux-workspace:0.0.1-alpha.12-SNAPSHOT")
+    implementation(
+        "io.github.libtmux:libtmux-workspace:0.0.1-alpha.12-SNAPSHOT"
+    )
 }
 
 java {
@@ -89,16 +93,20 @@ public final class WorkspaceExample {
                     panes:
                       - echo three
                 """);
+        String socket = "workspace-" + UUID.randomUUID();
         try (Server server = Server.builder()
-                .endpoint(ServerEndpoint.namedSocket("workspace-" + UUID.randomUUID()))
+                .endpoint(ServerEndpoint.namedSocket(socket))
                 .configFile(Path.of("/dev/null"))
                 .defaultTimeout(Duration.ofSeconds(10))
                 .build()) {
             try {
                 server.newSession("bootstrap");
                 Session session = WorkspaceBuilder.build(server, workspace);
-                System.out.println(session.name() + ": " + session.windows().size() + " windows");
-                System.out.println("editor: " + session.windows().getFirst().panes().size() + " panes");
+                var windows = session.windows();
+                var editor = windows.getFirst().panes();
+                String name = session.name();
+                System.out.println(name + ": " + windows.size() + " windows");
+                System.out.println("editor: " + editor.size() + " panes");
             } finally {
                 server.killServer();
             }
diff --git a/site/src/content/docs/ports/kotlin/concepts/queries.md b/site/src/content/docs/ports/kotlin/concepts/queries.md
index 12cdb13e1..5dd11935f 100644
--- a/site/src/content/docs/ports/kotlin/concepts/queries.md
+++ b/site/src/content/docs/ports/kotlin/concepts/queries.md
@@ -76,7 +76,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -120,11 +121,13 @@ fun main() = runBlocking {
         println(names.joinToString(", "))
         // Filtering the captured list makes no new tmux calls.
         check(sessions.filter { it.name.startsWith("work-") } == matching)
-        val onlyOne = (Session.name startsWith "work-").and(Session.name endsWith "one")
+        val endsInOne = Session.name endsWith "one"
+        val onlyOne = (Session.name startsWith "work-").and(endsInOne)
         check(sessions.filter(onlyOne).single().name == "work-one")
         val either = (Session.name eq "work-one").or(Session.name eq "work-two")
         check(sessions.filter(either).size == 2)
-        check(sessions.filter(!(Session.name eq "work-one")).single().name == "work-two")
+        val notOne = sessions.filter(!(Session.name eq "work-one"))
+        check(notOne.single().name == "work-two")
     }
 }
 ```
@@ -147,6 +150,7 @@ The program distinguishes zero and one local result. The checked server lookup t
 ```kotlin title="Cardinality.kt"
 import io.github.libtmux.ServerConfig
 import io.github.libtmux.ServerEndpoint
+import io.github.libtmux.exception.CardinalityException
 import io.github.libtmux.kotlin.*
 import io.github.libtmux.kotlin.query.*
 import java.nio.file.Path
@@ -177,7 +181,7 @@ fun main() = runBlocking {
         try {
             server.session(Session.name startsWith "work-")
             error("Expected an ambiguous selection")
-        } catch (error: io.github.libtmux.exception.CardinalityException.MultipleMatches) {
+        } catch (error: CardinalityException.MultipleMatches) {
             println("work-: ambiguous")
         }
     }
diff --git a/site/src/content/docs/ports/kotlin/concepts/server-session-window-pane.md b/site/src/content/docs/ports/kotlin/concepts/server-session-window-pane.md
index c310a42c9..c74676f92 100644
--- a/site/src/content/docs/ports/kotlin/concepts/server-session-window-pane.md
+++ b/site/src/content/docs/ports/kotlin/concepts/server-session-window-pane.md
@@ -78,7 +78,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -167,7 +168,8 @@ fun main() = runBlocking {
         val after = before.rename("renamed")
         check(before.name == "editor")
         check(after.name == "renamed")
-        val readAgain = server.sessions().single { it.name == "work-one" }.windows.single()
+        val again = server.sessions().single { it.name == "work-one" }
+        val readAgain = again.windows.single()
         check(readAgain.name == "renamed")
         println("${before.name} -> ${readAgain.name}")
     }
diff --git a/site/src/content/docs/ports/kotlin/concepts/transports.md b/site/src/content/docs/ports/kotlin/concepts/transports.md
index 665791ab0..7e8579dd0 100644
--- a/site/src/content/docs/ports/kotlin/concepts/transports.md
+++ b/site/src/content/docs/ports/kotlin/concepts/transports.md
@@ -76,7 +76,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -120,11 +121,13 @@ fun main() = runBlocking {
         println(names.joinToString(", "))
         // Filtering the captured list makes no new tmux calls.
         check(sessions.filter { it.name.startsWith("work-") } == matching)
-        val onlyOne = (Session.name startsWith "work-").and(Session.name endsWith "one")
+        val endsInOne = Session.name endsWith "one"
+        val onlyOne = (Session.name startsWith "work-").and(endsInOne)
         check(sessions.filter(onlyOne).single().name == "work-one")
         val either = (Session.name eq "work-one").or(Session.name eq "work-two")
         check(sessions.filter(either).size == 2)
-        check(sessions.filter(!(Session.name eq "work-one")).single().name == "work-two")
+        val notOne = sessions.filter(!(Session.name eq "work-one"))
+        check(notOne.single().name == "work-two")
     }
 }
 ```
@@ -165,7 +168,9 @@ fun main() = runBlocking {
         val session = server.sessions().single { it.name == "work-one" }
         withControl(server, session) { control ->
             val reply = control.send("list-sessions", "-F", "#{session_name}")
-            check(reply.succeeded()) { "tmux rejected list-sessions: ${reply.outcome()}" }
+            check(reply.succeeded()) {
+                "tmux rejected list-sessions: ${reply.outcome()}"
+            }
             val names = reply.lines().sorted()
             check(names == listOf("work-one", "work-two"))
             println(names.joinToString(", "))
diff --git a/site/src/content/docs/ports/kotlin/concepts/workspaces.md b/site/src/content/docs/ports/kotlin/concepts/workspaces.md
index c272442b2..a97e3839c 100644
--- a/site/src/content/docs/ports/kotlin/concepts/workspaces.md
+++ b/site/src/content/docs/ports/kotlin/concepts/workspaces.md
@@ -74,7 +74,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -115,7 +116,11 @@ fun main() = runBlocking {
         val window = session.newWindow(io.github.libtmux.WindowSpec.builder()
             .named("tools").running("/bin/cat").build())
         val original = window.panes.single()
-        original.split(io.github.libtmux.SplitSpec.builder().toRight().running("/bin/cat").build())
+        val right = io.github.libtmux.SplitSpec.builder()
+            .toRight()
+            .running("/bin/cat")
+            .build()
+        original.split(right)
         window.selectLayout(io.github.libtmux.Layout.EVEN_HORIZONTAL)
         val refreshed = server.sessions().single { it.name == "work-one" }
         val tools = refreshed.windows.single { it.name == "tools" }
@@ -168,7 +173,8 @@ fun main() = runBlocking {
         val first = ensureTools()
         val second = ensureTools()
         check(first.id == second.id)
-        check(server.sessions().single { it.name == "work-one" }.windows.size == 2)
+        val one = server.sessions().single { it.name == "work-one" }
+        check(one.windows.size == 2)
         println("one tools window after two calls")
     }
 }
diff --git a/site/src/content/docs/ports/kotlin/guides/attaching-to-tmux.md b/site/src/content/docs/ports/kotlin/guides/attaching-to-tmux.md
index a0dfc8686..ff1574587 100644
--- a/site/src/content/docs/ports/kotlin/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/kotlin/guides/attaching-to-tmux.md
@@ -128,7 +128,9 @@ Fetch the verified library revision, build, and run:
 ```console
 $ git clone https://github.com/libtmux/libtmux-java libtmux-source &&
   git -C libtmux-source checkout 85ebf6955e56703c5be74e2afd34a18309044741 &&
-  sh run.sh ./libtmux-source/gradlew --project-dir . run --console=plain --max-workers=2
+  sh run.sh ./libtmux-source/gradlew --project-dir . run \
+    --console=plain \
+    --max-workers=2
 ```
 
 The program prints `work`. To use an existing server of your own, set
diff --git a/site/src/content/docs/ports/lua/examples/capture-pane-output.md b/site/src/content/docs/ports/lua/examples/capture-pane-output.md
index 12ac7be5e..8777dc604 100644
--- a/site/src/content/docs/ports/lua/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/lua/examples/capture-pane-output.md
@@ -38,16 +38,21 @@ local socket = assert(arg[1], "pass the private socket path")
 local binary = assert(arg[2], "pass the absolute tmux executable path")
 
 must(adapter.run(function(runtime)
-    local server = must(runtime:connect({ binary = binary, socket_path = socket }):await())
+    local server = must(runtime:connect({
+        binary = binary,
+        socket_path = socket,
+    }):await())
     local created = must(server:new_session({
         name = "capture", argv = { "/bin/sh" },
     }):await())
     local pane = created.pane
+    local tmux = quote(binary) .. " -S " .. quote(socket)
     local command = "printf '\\nlibtmux capture ready\\n'; "
-        .. quote(binary) .. " -S " .. quote(socket) .. " wait-for -S capture-ready"
+        .. tmux .. " wait-for -S capture-ready"
     must(pane:send_text(command):await())
     must(pane:send_keys({ "Enter" }):await())
-    must(server:command({ "wait-for", "capture-ready" }, { timeout = 5000 }):await())
+    local wait = { "wait-for", "capture-ready" }
+    must(server:command(wait, { timeout = 5000 }):await())
 
     local capture = must(pane:capture({ history_lines = 20 }):await())
     local found = false
diff --git a/site/src/content/docs/ports/lua/guides/attaching-to-tmux.md b/site/src/content/docs/ports/lua/guides/attaching-to-tmux.md
index dc8587b68..be4b5c9ab 100644
--- a/site/src/content/docs/ports/lua/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/lua/guides/attaching-to-tmux.md
@@ -34,11 +34,20 @@ local function must(value, err)
     return value
 end
 
-local socket = assert(os.getenv("LIBTMUX_SOCKET_PATH"), "set LIBTMUX_SOCKET_PATH")
-local binary = assert(os.getenv("TMUX_BIN"), "set TMUX_BIN to the absolute tmux path")
+local socket = assert(
+    os.getenv("LIBTMUX_SOCKET_PATH"),
+    "set LIBTMUX_SOCKET_PATH"
+)
+local binary = assert(
+    os.getenv("TMUX_BIN"),
+    "set TMUX_BIN to the absolute tmux path"
+)
 
 must(adapter.run(function(runtime)
-    local server = must(runtime:connect({ binary = binary, socket_path = socket }):await())
+    local server = must(runtime:connect({
+        binary = binary,
+        socket_path = socket,
+    }):await())
     local snapshot, capture_error = server:snapshot({ strict = true }):await()
     local closed, close_error = server:close():await()
     must(snapshot, capture_error)
diff --git a/site/src/content/docs/ports/rs/concepts/queries.md b/site/src/content/docs/ports/rs/concepts/queries.md
index e6bf06bf3..0d6b2230a 100644
--- a/site/src/content/docs/ports/rs/concepts/queries.md
+++ b/site/src/content/docs/ports/rs/concepts/queries.md
@@ -191,7 +191,8 @@ async fn main() -> Result<(), ExampleError> {
         .config_file("/dev/null")
         .default_timeout(Duration::from_secs(5))
         .build()?;
-    let outcome = tokio::time::timeout(Duration::from_secs(10), demonstrate(&server)).await;
+    let demo = demonstrate(&server);
+    let outcome = tokio::time::timeout(Duration::from_secs(10), demo).await;
 
     // Stop the owned daemon before closing the client executor.
     let killed = server.kill().await;
@@ -211,7 +212,8 @@ async fn main() -> Result<(), ExampleError> {
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
@@ -276,7 +278,9 @@ session is a normal [`None`](https://doc.rust-lang.org/std/option/enum.Option.ht
 use std::error::Error;
 use std::time::Duration;
 
-use libtmux::query::{ExactlyOneError, Filterable as _, MultipleItemsError, QueryIteratorExt as _};
+use libtmux::query::{
+    ExactlyOneError, Filterable as _, MultipleItemsError, QueryIteratorExt as _,
+};
 use libtmux::{NewSessionOptions, Server, Session};
 
 type ExampleError = Box<dyn Error>;
@@ -352,7 +356,8 @@ async fn main() -> Result<(), ExampleError> {
         .config_file("/dev/null")
         .default_timeout(Duration::from_secs(5))
         .build()?;
-    let outcome = tokio::time::timeout(Duration::from_secs(10), demonstrate(&server)).await;
+    let demo = demonstrate(&server);
+    let outcome = tokio::time::timeout(Duration::from_secs(10), demo).await;
 
     // Stop the owned daemon before closing the client executor.
     let killed = server.kill().await;
@@ -372,7 +377,8 @@ async fn main() -> Result<(), ExampleError> {
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
@@ -503,7 +509,8 @@ async fn main() -> Result<(), ExampleError> {
         .config_file("/dev/null")
         .default_timeout(Duration::from_secs(5))
         .build()?;
-    let outcome = tokio::time::timeout(Duration::from_secs(10), demonstrate(&server)).await;
+    let demo = demonstrate(&server);
+    let outcome = tokio::time::timeout(Duration::from_secs(10), demo).await;
 
     // Stop the owned daemon before closing the client executor.
     let killed = server.kill().await;
@@ -523,7 +530,8 @@ async fn main() -> Result<(), ExampleError> {
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
diff --git a/site/src/content/docs/ports/rs/concepts/transports.md b/site/src/content/docs/ports/rs/concepts/transports.md
index 058f4d473..efe818e05 100644
--- a/site/src/content/docs/ports/rs/concepts/transports.md
+++ b/site/src/content/docs/ports/rs/concepts/transports.md
@@ -140,7 +140,8 @@ async fn main() -> Result<(), ExampleError> {
         .config_file("/dev/null")
         .default_timeout(Duration::from_secs(5))
         .build()?;
-    let outcome = tokio::time::timeout(Duration::from_secs(10), demonstrate(&server)).await;
+    let demo = demonstrate(&server);
+    let outcome = tokio::time::timeout(Duration::from_secs(10), demo).await;
 
     // Stop the owned daemon before closing the client executor.
     let killed = server.kill().await;
@@ -160,7 +161,8 @@ async fn main() -> Result<(), ExampleError> {
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
diff --git a/site/src/content/docs/ports/rs/examples/capture-pane-output.md b/site/src/content/docs/ports/rs/examples/capture-pane-output.md
index 7c97803f9..a0681aa02 100644
--- a/site/src/content/docs/ports/rs/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/rs/examples/capture-pane-output.md
@@ -40,9 +40,9 @@ async fn main() -> Result<(), Box<dyn Error>> {
         .build()?;
 
     let captured = timeout(Duration::from_secs(5), async {
-        let session = server
-            .new_session(NewSessionOptions::new("capture").command("env ENV=/dev/null sh"))
-            .await?;
+        let options = NewSessionOptions::new("capture")
+            .command("env ENV=/dev/null sh");
+        let session = server.new_session(options).await?;
         let panes = session.panes().await?;
         let pane = panes.first().ok_or("the session has no pane")?;
         pane.send_line("printf '\\nlibtmux capture ready\\n'").await?;
diff --git a/site/src/content/docs/ports/rs/guides/batching-commands.md b/site/src/content/docs/ports/rs/guides/batching-commands.md
index b7049a046..aa104c2ff 100644
--- a/site/src/content/docs/ports/rs/guides/batching-commands.md
+++ b/site/src/content/docs/ports/rs/guides/batching-commands.md
@@ -39,10 +39,14 @@ publish = false
 exclude = ["libtmux-source"]
 
 [dependencies]
-libtmux = { path = "libtmux-source/crates/libtmux", default-features = false, features = ["plan"] }
 tempfile = "=3.27.0"
 tokio = { version = "=1.53.1", features = ["macros", "rt", "time"] }
 
+[dependencies.libtmux]
+path = "libtmux-source/crates/libtmux"
+default-features = false
+features = ["plan"]
+
 [[bin]]
 name = "batching"
 path = "batching.rs"
@@ -101,7 +105,10 @@ async fn demonstrate(server: &Server) -> Result<(), ExampleError> {
 
         let result = plan.run(server, planner).await?;
         if !result.is_complete() {
-            return Err(format!("{name} did not complete: {:?}", result.operations()).into());
+            let operations = result.operations();
+            return Err(
+                format!("{name} did not complete: {operations:?}").into()
+            );
         }
         check(result.dispatches() == expected, "unexpected dispatch count")?;
 
@@ -166,7 +173,8 @@ async fn main() -> Result<(), ExampleError> {
         .config_file("/dev/null")
         .default_timeout(Duration::from_secs(5))
         .build()?;
-    let outcome = tokio::time::timeout(Duration::from_secs(10), demonstrate(&server)).await;
+    let demo = demonstrate(&server);
+    let outcome = tokio::time::timeout(Duration::from_secs(10), demo).await;
 
     // Stop the owned daemon before closing the client executor.
     let killed = server.kill().await;
@@ -186,7 +194,8 @@ async fn main() -> Result<(), ExampleError> {
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
diff --git a/site/src/content/docs/ports/rs/guides/control-mode.md b/site/src/content/docs/ports/rs/guides/control-mode.md
index 46b2a7620..6e29096a2 100644
--- a/site/src/content/docs/ports/rs/guides/control-mode.md
+++ b/site/src/content/docs/ports/rs/guides/control-mode.md
@@ -41,10 +41,14 @@ publish = false
 exclude = ["libtmux-source"]
 
 [dependencies]
-libtmux = { path = "libtmux-source/crates/libtmux", default-features = false, features = ["control-mode"] }
 tempfile = "=3.27.0"
 tokio = { version = "=1.53.1", features = ["macros", "rt", "time"] }
 
+[dependencies.libtmux]
+path = "libtmux-source/crates/libtmux"
+default-features = false
+features = ["control-mode"]
+
 [[bin]]
 name = "control"
 path = "control.rs"
@@ -174,7 +178,8 @@ async fn main() -> Result<(), ExampleError> {
         .config_file("/dev/null")
         .default_timeout(Duration::from_secs(5))
         .build()?;
-    let outcome = tokio::time::timeout(Duration::from_secs(20), demonstrate(&server)).await;
+    let demo = demonstrate(&server);
+    let outcome = tokio::time::timeout(Duration::from_secs(20), demo).await;
 
     // Stop the owned daemon before closing the client executor.
     let killed = server.kill().await;
@@ -194,7 +199,8 @@ async fn main() -> Result<(), ExampleError> {
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
diff --git a/site/src/content/docs/ports/rs/mcp/examples/inspect-sessions.md b/site/src/content/docs/ports/rs/mcp/examples/inspect-sessions.md
index d3e1ba13f..ca34e5f45 100644
--- a/site/src/content/docs/ports/rs/mcp/examples/inspect-sessions.md
+++ b/site/src/content/docs/ports/rs/mcp/examples/inspect-sessions.md
@@ -47,12 +47,21 @@ edition = "2024"
 publish = false
 
 [dependencies]
-libtmux = { git = "https://github.com/libtmux/libtmux-rs", rev = "a6fc2a65674177b92b17fa380757155d2ba150fd" }
-tmux-mcp = { git = "https://github.com/libtmux/libtmux-rs", rev = "a6fc2a65674177b92b17fa380757155d2ba150fd" }
 rmcp = { version = "=3.1.2", features = ["client", "server", "transport-io"] }
 serde_json = "=1.0.151"
 tempfile = "=3.27.0"
-tokio = { version = "=1.53.1", features = ["io-util", "macros", "net", "rt-multi-thread", "time"] }
+
+[dependencies.libtmux]
+git = "https://github.com/libtmux/libtmux-rs"
+rev = "a6fc2a65674177b92b17fa380757155d2ba150fd"
+
+[dependencies.tmux-mcp]
+git = "https://github.com/libtmux/libtmux-rs"
+rev = "a6fc2a65674177b92b17fa380757155d2ba150fd"
+
+[dependencies.tokio]
+version = "=1.53.1"
+features = ["io-util", "macros", "net", "rt-multi-thread", "time"]
 ```
 
 Save this as `src/main.rs`:
@@ -91,11 +100,12 @@ async fn inspect(client: &Peer<RoleClient>) -> Result<(), ExampleError> {
         "send_keys was offered by the inspection server",
     )?;
 
-    let result = client
-        .call_tool(CallToolRequestParams::new("list_sessions").with_arguments(Default::default()))
-        .await?;
+    let request = CallToolRequestParams::new("list_sessions")
+        .with_arguments(Default::default());
+    let result = client.call_tool(request).await?;
     if result.is_error == Some(true) {
-        return Err(format!("list_sessions failed: {}", serde_json::to_string(&result)?).into());
+        let body = serde_json::to_string(&result)?;
+        return Err(format!("list_sessions failed: {body}").into());
     }
     let data = result
         .structured_content
@@ -127,7 +137,9 @@ fn record_close(
     match result {
         Ok(Some(QuitReason::Cancelled | QuitReason::Closed)) => {}
         Ok(Some(reason)) => failures.push(format!("{label}: {reason:?}")),
-        Ok(None) => failures.push(format!("{label}: cleanup deadline exceeded")),
+        Ok(None) => {
+            failures.push(format!("{label}: cleanup deadline exceeded"))
+        }
         Err(error) => failures.push(format!("{label}: {error}")),
     }
 }
@@ -144,8 +156,10 @@ async fn exchange(server: &Server) -> Result<(), ExampleError> {
             async { tools.serve(server_io).await.map_err(ExampleError::from) },
         )
     };
-    let (mut client, mut service) = timeout(Duration::from_secs(5), startup).await??;
-    let outcome = timeout(Duration::from_secs(10), inspect(client.peer())).await;
+    let started = timeout(Duration::from_secs(5), startup).await??;
+    let (mut client, mut service) = started;
+    let inspection = inspect(client.peer());
+    let outcome = timeout(Duration::from_secs(10), inspection).await;
 
     let mut failures = Vec::new();
     match outcome {
@@ -218,10 +232,12 @@ async fn main() -> Result<(), ExampleError> {
 
     // Stop the owned daemon before closing its command executor.
     let killed = server.kill().await;
-    let stopped = timeout(Duration::from_secs(5), wait_until_stopped(&socket)).await;
+    let stopping = wait_until_stopped(&socket);
+    let stopped = timeout(Duration::from_secs(5), stopping).await;
     let closed = timeout(Duration::from_secs(5), server.shutdown()).await;
-    let cleanup_failed =
-        killed.is_err() || !matches!(&stopped, Ok(Ok(()))) || !matches!(&closed, Ok(Ok(())));
+    let cleanup_failed = killed.is_err()
+        || !matches!(&stopped, Ok(Ok(())))
+        || !matches!(&closed, Ok(Ok(())));
     let mut failures = Vec::new();
     if let Err(error) = outcome {
         failures.push(format!("example: {error}"));
@@ -231,17 +247,24 @@ async fn main() -> Result<(), ExampleError> {
     }
     match stopped {
         Ok(Ok(())) => {}
-        Ok(Err(error)) => failures.push(format!("daemon cleanup verification: {error}")),
-        Err(error) => failures.push(format!("daemon cleanup verification deadline: {error}")),
+        Ok(Err(error)) => {
+            failures.push(format!("daemon stop verification: {error}"))
+        }
+        Err(error) => {
+            failures.push(format!("daemon stop verification deadline: {error}"))
+        }
     }
     match closed {
         Ok(Ok(())) => {}
         Ok(Err(error)) => failures.push(format!("executor cleanup: {error}")),
-        Err(error) => failures.push(format!("executor cleanup deadline: {error}")),
+        Err(error) => {
+            failures.push(format!("executor cleanup deadline: {error}"))
+        }
     }
     if cleanup_failed {
         let retained = directory.keep();
-        failures.push(format!("inspect retained directory {}", retained.display()));
+        let kept = retained.display();
+        failures.push(format!("inspect retained directory {kept}"));
     } else if let Err(error) = directory.close() {
         failures.push(format!("directory cleanup: {error}"));
     }
diff --git a/site/src/content/docs/ports/rs/workspace/internals/examples.md b/site/src/content/docs/ports/rs/workspace/internals/examples.md
index 5dd901e4e..a85e650dd 100644
--- a/site/src/content/docs/ports/rs/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/rs/workspace/internals/examples.md
@@ -27,8 +27,10 @@ $ mkdir rust-workspace-example && cd rust-workspace-example && \
 
 ```console
 $ git init libtmux-source && \
-    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-rs.git && \
-    git -C libtmux-source fetch --depth=1 origin d4e08b4eaab62ef4eeedab79b47973ae9a1de310 && \
+    git -C libtmux-source remote add origin \
+      https://github.com/libtmux/libtmux-rs.git && \
+    git -C libtmux-source fetch --depth=1 origin \
+      d4e08b4eaab62ef4eeedab79b47973ae9a1de310 && \
     git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -46,10 +48,17 @@ name = "workspace-example"
 version = "0.1.0"
 edition = "2024"
 
-[dependencies]
-libtmux = { path = "libtmux-source/crates/libtmux", features = ["test-support"] }
-tmux-workspace = { path = "libtmux-source/crates/tmux-workspace", default-features = false }
-tokio = { version = "=1.53.1", features = ["macros", "rt-multi-thread", "time"] }
+[dependencies.libtmux]
+path = "libtmux-source/crates/libtmux"
+features = ["test-support"]
+
+[dependencies.tmux-workspace]
+path = "libtmux-source/crates/tmux-workspace"
+default-features = false
+
+[dependencies.tokio]
+version = "=1.53.1"
+features = ["macros", "rt-multi-thread", "time"]
 ```
 
 Create the workspace file beside `Cargo.toml`:
@@ -94,7 +103,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
         }
         let captured = freeze(&session).await?;
         if Workspace::from_yaml(&captured.to_yaml())? != captured {
-            return Err("captured workspace did not survive its YAML round trip".into());
+            return Err("captured workspace failed its YAML round trip".into());
         }
         println!("built: {} windows", windows.len());
         println!("panes: {}", panes.len());
@@ -111,7 +120,10 @@ async fn main() -> Result<(), Box<dyn Error>> {
         (Err(error), Ok(())) => Err(error),
         (Ok(()), Err(error)) => Err(error.into()),
         (Err(operation), Err(cleanup)) => {
-            Err(format!("workspace failed: {operation}; cleanup failed: {cleanup}").into())
+            let message = format!(
+                "workspace failed: {operation}; cleanup failed: {cleanup}"
+            );
+            Err(message.into())
         }
     }
 }
diff --git a/site/src/content/docs/ports/ruby/guides/attaching-to-tmux.md b/site/src/content/docs/ports/ruby/guides/attaching-to-tmux.md
index dfa9917fb..f1f9fb54c 100644
--- a/site/src/content/docs/ports/ruby/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/ruby/guides/attaching-to-tmux.md
@@ -30,7 +30,8 @@ the example.
 require "libtmux"
 
 LibTmux::Server.open(socket_path: ENV.fetch("LIBTMUX_SOCKET_PATH")) do |server|
-  session = server.snapshot.sessions.find { |candidate| candidate.name == "work" }
+  sessions = server.snapshot.sessions
+  session = sessions.find { |candidate| candidate.name == "work" }
   raise "The work session does not exist" unless session
   puts session.name
 end
diff --git a/site/src/content/docs/ports/ruby/mcp/examples/page-session-metadata.md b/site/src/content/docs/ports/ruby/mcp/examples/page-session-metadata.md
index 279e28223..a8c07aea7 100644
--- a/site/src/content/docs/ports/ruby/mcp/examples/page-session-metadata.md
+++ b/site/src/content/docs/ports/ruby/mcp/examples/page-session-metadata.md
@@ -62,7 +62,8 @@ def describe_failure(error)
     details.concat(error.cleanup_errors.map { |message| "Cleanup: #{message}" })
   end
   if error.respond_to?(:async_cleanup_errors)
-    details.concat(error.async_cleanup_errors.map { |message| "Cleanup: #{message}" })
+    async_errors = error.async_cleanup_errors
+    details.concat(async_errors.map { |message| "Cleanup: #{message}" })
   end
   details.join("\n")
 end
diff --git a/site/src/content/docs/ports/scala/concepts/queries.md b/site/src/content/docs/ports/scala/concepts/queries.md
index f9d7b4678..771f44b2d 100644
--- a/site/src/content/docs/ports/scala/concepts/queries.md
+++ b/site/src/content/docs/ports/scala/concepts/queries.md
@@ -80,7 +80,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -111,7 +112,8 @@ import scala.jdk.CollectionConverters.*
 object Local {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -124,11 +126,13 @@ object Local {
       println(names.mkString(", "))
       // Filtering the captured vector makes no new tmux calls.
       assert(sessions.filter(_.name.startsWith("work-")) == matching)
-      val onlyOne = Session.name.startsWith("work-") && Session.name.endsWith("one")
+      val endsInOne = Session.name.endsWith("one")
+      val onlyOne = Session.name.startsWith("work-") && endsInOne
       assert(sessions.matching(onlyOne).head.name == "work-one")
       val either = Session.name.is("work-one") || Session.name.is("work-two")
       assert(sessions.matching(either).size == 2)
-      assert(sessions.matching(!Session.name.is("work-one")).head.name == "work-two")
+      val notOne = sessions.matching(!Session.name.is("work-one"))
+      assert(notOne.head.name == "work-two")
     }
   }
 }
@@ -161,7 +165,8 @@ import scala.jdk.CollectionConverters.*
 object Cardinality {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -173,7 +178,8 @@ object Cardinality {
           case Right(session) => println(s"${session.name}: selected")
           case Left(CardinalityError.NoMatch) => println(s"$name: absent")
           case Left(CardinalityError.MultipleMatches(count)) =>
-            throw new IllegalStateException(s"At least $count sessions named $name")
+            throw new IllegalStateException(
+              s"At least $count sessions named $name")
         }
       }
       val many = sessions.matching(Session.name.startsWith("work-")).atMostOne
@@ -213,7 +219,8 @@ import scala.jdk.CollectionConverters.*
 object Relations {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
diff --git a/site/src/content/docs/ports/scala/concepts/server-session-window-pane.md b/site/src/content/docs/ports/scala/concepts/server-session-window-pane.md
index 59ab9d550..79a76a8e7 100644
--- a/site/src/content/docs/ports/scala/concepts/server-session-window-pane.md
+++ b/site/src/content/docs/ports/scala/concepts/server-session-window-pane.md
@@ -82,7 +82,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -113,7 +114,8 @@ import scala.jdk.CollectionConverters.*
 object Hierarchy {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -161,7 +163,8 @@ import scala.jdk.CollectionConverters.*
 object Refresh {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -172,7 +175,8 @@ object Refresh {
       val after = before.rename("renamed")
       assert(before.name == "editor")
       assert(after.name == "renamed")
-      val readAgain = server.sessions().find(_.name == "work-one").get.windows.head
+      val again = server.sessions().find(_.name == "work-one").get
+      val readAgain = again.windows.head
       assert(readAgain.name == "renamed")
       println(s"${before.name} -> ${readAgain.name}")
     }
diff --git a/site/src/content/docs/ports/scala/concepts/transports.md b/site/src/content/docs/ports/scala/concepts/transports.md
index 1e1b6ec89..6615da858 100644
--- a/site/src/content/docs/ports/scala/concepts/transports.md
+++ b/site/src/content/docs/ports/scala/concepts/transports.md
@@ -80,7 +80,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -111,7 +112,8 @@ import scala.jdk.CollectionConverters.*
 object Local {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -124,11 +126,13 @@ object Local {
       println(names.mkString(", "))
       // Filtering the captured vector makes no new tmux calls.
       assert(sessions.filter(_.name.startsWith("work-")) == matching)
-      val onlyOne = Session.name.startsWith("work-") && Session.name.endsWith("one")
+      val endsInOne = Session.name.endsWith("one")
+      val onlyOne = Session.name.startsWith("work-") && endsInOne
       assert(sessions.matching(onlyOne).head.name == "work-one")
       val either = Session.name.is("work-one") || Session.name.is("work-two")
       assert(sessions.matching(either).size == 2)
-      assert(sessions.matching(!Session.name.is("work-one")).head.name == "work-two")
+      val notOne = sessions.matching(!Session.name.is("work-one"))
+      assert(notOne.head.name == "work-two")
     }
   }
 }
@@ -161,7 +165,8 @@ import scala.jdk.CollectionConverters.*
 object Control {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -170,7 +175,9 @@ object Control {
       val session = server.sessions().find(_.name == "work-one").get
       Using.resource(server.control(session)) { control =>
         val reply = control.send("list-sessions", "-F", "#{session_name}")
-        require(reply.succeeded(), s"tmux rejected list-sessions: ${reply.outcome()}")
+        require(
+          reply.succeeded(),
+          s"tmux rejected list-sessions: ${reply.outcome()}")
         val names = reply.lines().asScala.toVector.sorted
         assert(names == Vector("work-one", "work-two"))
         println(names.mkString(", "))
diff --git a/site/src/content/docs/ports/scala/concepts/workspaces.md b/site/src/content/docs/ports/scala/concepts/workspaces.md
index 5b4fe5825..89da30445 100644
--- a/site/src/content/docs/ports/scala/concepts/workspaces.md
+++ b/site/src/content/docs/ports/scala/concepts/workspaces.md
@@ -78,7 +78,8 @@ trap 'exit 1' HUP INT TERM
 
 unset TMUX TMUX_PANE
 export LIBTMUX_SOCKET_PATH="$socket" TMUX_BIN="$binary"
-"$binary" -S "$socket" -f /dev/null new-session -d -s work-one -n editor /bin/cat
+"$binary" -S "$socket" -f /dev/null \
+    new-session -d -s work-one -n editor /bin/cat
 "$binary" -S "$socket" new-session -d -s work-two -n logs /bin/cat
 "$@"
 "$binary" -S "$socket" has-session -t '=work-one'
@@ -109,7 +110,8 @@ import scala.jdk.CollectionConverters.*
 object Layout {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -157,7 +159,8 @@ import scala.jdk.CollectionConverters.*
 object ReuseLayout {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -173,7 +176,8 @@ object ReuseLayout {
       val first = ensureTools()
       val second = ensureTools()
       assert(first.id == second.id)
-      assert(server.sessions().find(_.name == "work-one").get.windows.size == 2)
+      val one = server.sessions().find(_.name == "work-one").get
+      assert(one.windows.size == 2)
       println("one tools window after two calls")
     }
   }
diff --git a/site/src/content/docs/ports/scala/examples/capture-pane-output.md b/site/src/content/docs/ports/scala/examples/capture-pane-output.md
index 1aa845600..c260784bb 100644
--- a/site/src/content/docs/ports/scala/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/scala/examples/capture-pane-output.md
@@ -41,7 +41,10 @@ object Capture {
       Using.resource(Server.open(config)) { server =>
         try {
           val session = server.newSession(SessionSpec.builder()
-            .named("capture").running("/bin/sh").env("ENV", "/dev/null").build())
+            .named("capture")
+            .running("/bin/sh")
+            .env("ENV", "/dev/null")
+            .build())
           val pane = session.windows.head.panes.head
           pane.sendLine("printf '\\nlibtmux capture ready\\n'")
           val deadline = System.nanoTime() + Duration.ofSeconds(5).toNanos
@@ -51,7 +54,8 @@ object Capture {
             if (!captured) Thread.sleep(25)
           }
           if (!captured)
-            throw new IllegalStateException("Output did not arrive within five seconds")
+            throw new IllegalStateException(
+              "Output did not arrive within five seconds")
           println("libtmux capture ready")
         } catch {
           case error: Throwable =>
diff --git a/site/src/content/docs/ports/scala/guides/attaching-to-tmux.md b/site/src/content/docs/ports/scala/guides/attaching-to-tmux.md
index c22bb1017..d1b9a84ad 100644
--- a/site/src/content/docs/ports/scala/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/scala/guides/attaching-to-tmux.md
@@ -36,7 +36,8 @@ import scala.util.Using
 object Connect {
   def main(args: Array[String]): Unit = {
     val socket = sys.env.getOrElse("LIBTMUX_SOCKET_PATH",
-      throw new IllegalArgumentException("Set LIBTMUX_SOCKET_PATH to an existing socket"))
+      throw new IllegalArgumentException(
+        "Set LIBTMUX_SOCKET_PATH to an existing socket"))
     val config = ServerConfig.builder()
       .endpoint(ServerEndpoint.socketPath(Path.of(socket)))
       .defaultTimeout(Duration.ofSeconds(5))
@@ -132,7 +133,9 @@ Fetch the verified library revision, build, and run:
 ```console
 $ git clone https://github.com/libtmux/libtmux-java libtmux-source &&
   git -C libtmux-source checkout 85ebf6955e56703c5be74e2afd34a18309044741 &&
-  sh run.sh ./libtmux-source/gradlew --project-dir . run --console=plain --max-workers=2
+  sh run.sh ./libtmux-source/gradlew --project-dir . run \
+    --console=plain \
+    --max-workers=2
 ```
 
 The program prints `work`. To use an existing server of your own, set
diff --git a/site/src/content/docs/ports/swift/examples/capture-pane-output.md b/site/src/content/docs/ports/swift/examples/capture-pane-output.md
index e142cb7ba..a6af824bb 100644
--- a/site/src/content/docs/ports/swift/examples/capture-pane-output.md
+++ b/site/src/content/docs/ports/swift/examples/capture-pane-output.md
@@ -59,7 +59,8 @@ struct Capture {
             guard let pane = try await server.panes().first else {
                 throw CaptureError.failed("The session has no pane")
             }
-            try await server.run("printf '\\nlibtmux capture ready\\n'", in: pane)
+            let command = "printf '\\nlibtmux capture ready\\n'"
+            try await server.run(command, in: pane)
             let clock = ContinuousClock()
             let deadline = clock.now.advanced(by: .seconds(5))
             var captured = false
@@ -73,27 +74,32 @@ struct Capture {
                 try await Task.sleep(for: .milliseconds(25))
             }
             guard captured else {
-                throw CaptureError.failed("Output did not arrive within five seconds")
+                throw CaptureError.failed(
+                    "Output did not arrive within five seconds"
+                )
             }
         } catch {
             failure = error
         }
 
+        let stderr = FileHandle.standardError
         var cleanupFailed = false
         if started {
             do { try await server.killServer() }
             catch {
-                FileHandle.standardError.write(Data("Stop tmux: \(error)\n".utf8))
+                stderr.write(Data("Stop tmux: \(error)\n".utf8))
                 cleanupFailed = true
             }
         }
         do { try FileManager.default.removeItem(at: directory) }
         catch {
-            FileHandle.standardError.write(Data("Remove socket: \(error)\n".utf8))
+            stderr.write(Data("Remove socket: \(error)\n".utf8))
             cleanupFailed = true
         }
         if let failure { throw failure }
-        if cleanupFailed { throw CaptureError.failed("Cleanup failed; see diagnostics") }
+        if cleanupFailed {
+            throw CaptureError.failed("Cleanup failed; see diagnostics")
+        }
     }
 }
 ```
diff --git a/site/src/content/docs/ports/swift/guides/attaching-to-tmux.md b/site/src/content/docs/ports/swift/guides/attaching-to-tmux.md
index d29caa0e7..e5f879022 100644
--- a/site/src/content/docs/ports/swift/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/swift/guides/attaching-to-tmux.md
@@ -37,8 +37,11 @@ enum ConnectError: Error {
 @main
 struct Connect {
     static func main() async throws {
-        guard let socket = ProcessInfo.processInfo.environment["LIBTMUX_SOCKET_PATH"] else {
-            throw ConnectError.failed("Set LIBTMUX_SOCKET_PATH to an existing socket")
+        let environment = ProcessInfo.processInfo.environment
+        guard let socket = environment["LIBTMUX_SOCKET_PATH"] else {
+            throw ConnectError.failed(
+                "Set LIBTMUX_SOCKET_PATH to an existing socket"
+            )
         }
         let server = try Server(socketPath: socket)
         guard try await server.hasSession("=work") else {
diff --git a/site/src/content/docs/ports/swift/mcp/examples.md b/site/src/content/docs/ports/swift/mcp/examples.md
index 81b94e0c8..0ce0e4de6 100644
--- a/site/src/content/docs/ports/swift/mcp/examples.md
+++ b/site/src/content/docs/ports/swift/mcp/examples.md
@@ -28,8 +28,10 @@ Fetch the library revision used by this example:
 
 ```console
 $ git init libtmux-source && \
-  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \
-  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
+  git -C libtmux-source remote add origin \
+    https://github.com/libtmux/libtmux-swift.git && \
+  git -C libtmux-source fetch --depth=1 origin \
+    254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
   git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
diff --git a/site/src/content/docs/ports/swift/mcp/guides.md b/site/src/content/docs/ports/swift/mcp/guides.md
index 63f9f452c..e362bd3ef 100644
--- a/site/src/content/docs/ports/swift/mcp/guides.md
+++ b/site/src/content/docs/ports/swift/mcp/guides.md
@@ -28,8 +28,10 @@ Fetch the library revision and build its stdio server:
 
 ```console
 $ git init libtmux-source && \
-  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \
-  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
+  git -C libtmux-source remote add origin \
+    https://github.com/libtmux/libtmux-swift.git && \
+  git -C libtmux-source fetch --depth=1 origin \
+    254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
   git -C libtmux-source checkout --detach FETCH_HEAD && \
   swift build --package-path libtmux-source --product libtmux-mcp --jobs 2
 ```
diff --git a/site/src/content/docs/ports/swift/workspace/internals/examples.md b/site/src/content/docs/ports/swift/workspace/internals/examples.md
index f52be2788..3a451ea07 100644
--- a/site/src/content/docs/ports/swift/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/swift/workspace/internals/examples.md
@@ -29,8 +29,10 @@ Fetch the library revision used by this example:
 
 ```console
 $ git init libtmux-source && \
-  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \
-  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
+  git -C libtmux-source remote add origin \
+    https://github.com/libtmux/libtmux-swift.git && \
+  git -C libtmux-source fetch --depth=1 origin \
+    254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \
   git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -109,7 +111,9 @@ struct WorkspaceExample {
         try await withPrivateTmux { server in
             let started = try await server.run([
                 TmuxCommand("set-option", ["-g", "default-shell", "/bin/sh"]),
-                TmuxCommand("set-option", ["-g", "default-command", "exec /bin/cat"]),
+                TmuxCommand("set-option", [
+                    "-g", "default-command", "exec /bin/cat",
+                ]),
                 TmuxCommand("set-environment", ["-g", "ENV", ""]),
                 TmuxCommand("set-environment", ["-g", "BASH_ENV", ""]),
                 TmuxCommand("new-session", ["-d", "-s", "bootstrap"]),
@@ -127,7 +131,9 @@ struct WorkspaceExample {
                     WindowPlan(windowName: "logs", panes: [PanePlan()]),
                 ]
             )
-            let session = try await WorkspaceBuilder.build(workspace, on: server)
+            let session = try await WorkspaceBuilder.build(
+                workspace, on: server
+            )
             let snapshot = try await server.snapshot()
             let windows = snapshot.windows(of: session)
             guard windows.count == 2,
diff --git a/site/src/content/docs/ports/ts/concepts/queries.md b/site/src/content/docs/ports/ts/concepts/queries.md
index 8505c5dba..57becb4a0 100644
--- a/site/src/content/docs/ports/ts/concepts/queries.md
+++ b/site/src/content/docs/ports/ts/concepts/queries.md
@@ -74,14 +74,23 @@ import { Server } from "libtmux";
 
 const directory = await mkdtemp(join(tmpdir(), "libtmux-query-"));
 const server = new Server({
-  socketPath: join(directory, "tmux.sock"), configFile: "/dev/null", timeoutMs: 5_000,
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
 });
 const failures: unknown[] = [];
 try {
   const session = await server.newSession({
     name: "work", windowName: "shell", shellCommand: "cat",
   });
-  for (const name of ["app-api", "app-worker", "MyApp-logs", "app-v1-0", "app-beta"]) {
+  const names = [
+    "app-api",
+    "app-worker",
+    "MyApp-logs",
+    "app-v1-0",
+    "app-beta",
+  ];
+  for (const name of names) {
     await session.newWindow({ name, shellCommand: "cat" });
   }
   const { windows } = await server.snapshot();
@@ -115,13 +124,16 @@ try {
 
   const selected = windows.where({ name: { in: ["app-api", "app-worker"] } });
   assert.equal(selected.count(), 2);
-  assert.equal(selected.where({ name: { notIn: ["app-worker"] } }).one().name, "app-api");
-  console.log("membership:", selected.map((window) => window.name).sort().join(", "));
+  const rest = selected.where({ name: { notIn: ["app-worker"] } });
+  assert.equal(rest.one().name, "app-api");
+  const members = selected.map((window) => window.name).sort();
+  console.log("membership:", members.join(", "));
 
   const namesFromConfig = new Set(["shell", "app-beta"]);
   const local = windows.filter((window) => namesFromConfig.has(window.name));
   assert.equal(local.count(), 2);
-  console.log("predicate:", local.map((window) => window.name).sort().join(", "));
+  const picked = local.map((window) => window.name).sort();
+  console.log("predicate:", picked.join(", "));
 } catch (error) {
   failures.push(error);
 } finally {
@@ -129,10 +141,13 @@ try {
     if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
     await rm(directory, { recursive: true });
   } catch (error) {
-    failures.push(new Error(`Cleanup failed; inspect ${directory}`, { cause: error }));
+    const message = `Cleanup failed; inspect ${directory}`;
+    failures.push(new Error(message, { cause: error }));
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Query example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Query example failed");
+}
 ```
 
 ```console
@@ -189,7 +204,9 @@ import { Server, MultipleMatchesError, NoMatchError } from "libtmux";
 
 const directory = await mkdtemp(join(tmpdir(), "libtmux-query-"));
 const server = new Server({
-  socketPath: join(directory, "tmux.sock"), configFile: "/dev/null", timeoutMs: 5_000,
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
 });
 const failures: unknown[] = [];
 try {
@@ -230,10 +247,13 @@ try {
     if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
     await rm(directory, { recursive: true });
   } catch (error) {
-    failures.push(new Error(`Cleanup failed; inspect ${directory}`, { cause: error }));
+    const message = `Cleanup failed; inspect ${directory}`;
+    failures.push(new Error(message, { cause: error }));
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Query example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Query example failed");
+}
 ```
 
 ```console
@@ -270,7 +290,9 @@ import { Server, MultipleMatchesError } from "libtmux";
 
 const directory = await mkdtemp(join(tmpdir(), "libtmux-query-"));
 const server = new Server({
-  socketPath: join(directory, "tmux.sock"), configFile: "/dev/null", timeoutMs: 5_000,
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
 });
 const failures: unknown[] = [];
 try {
@@ -300,19 +322,26 @@ try {
   assert.deepEqual(owners, ["guest", "home"]);
   console.log("linked sessions:", owners.join(", "));
 
-  const hasLogs = snapshot.sessions.where({ windows: { some: { name: "logs" } } });
+  const hasLogs = snapshot.sessions.where({
+    windows: { some: { name: "logs" } },
+  });
   assert.equal(hasLogs.count(), 2);
   const onlyLogs = snapshot.sessions.where({
     windows: { some: {}, every: { name: "logs" } },
   });
   assert.equal(onlyLogs.one().name, "home");
-  const noShell = snapshot.sessions.where({ windows: { none: { name: "shell" } } });
+  const noShell = snapshot.sessions.where({
+    windows: { none: { name: "shell" } },
+  });
   assert.equal(noShell.one().name, "home");
-  console.log("some logs:", hasLogs.map((session) => session.name).sort().join(", "));
+  const logHolders = hasLogs.map((session) => session.name).sort();
+  console.log("some logs:", logHolders.join(", "));
   console.log("every window is logs:", onlyLogs.one().name);
   console.log("no shell:", noShell.one().name);
 
-  const guestPanes = snapshot.panes.where({ session: { is: { name: "guest" } } });
+  const guestPanes = snapshot.panes.where({
+    session: { is: { name: "guest" } },
+  });
   assert.equal(guestPanes.count(), 2);
   console.log("panes reached through guest:", guestPanes.count());
 } catch (error) {
@@ -322,10 +351,13 @@ try {
     if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
     await rm(directory, { recursive: true });
   } catch (error) {
-    failures.push(new Error(`Cleanup failed; inspect ${directory}`, { cause: error }));
+    const message = `Cleanup failed; inspect ${directory}`;
+    failures.push(new Error(message, { cause: error }));
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Query example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Query example failed");
+}
 ```
 
 ```console
@@ -359,7 +391,9 @@ import { Server } from "libtmux";
 
 const directory = await mkdtemp(join(tmpdir(), "libtmux-query-"));
 const server = new Server({
-  socketPath: join(directory, "tmux.sock"), configFile: "/dev/null", timeoutMs: 5_000,
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
 });
 const failures: unknown[] = [];
 try {
@@ -369,11 +403,13 @@ try {
   const before = await server.snapshot();
   await session.newWindow({ name: "logs", shellCommand: "cat" });
   assert.equal(before.windows.exists({ name: "logs" }), false);
-  console.log("old snapshot sees logs:", before.windows.exists({ name: "logs" }));
+  const oldSees = before.windows.exists({ name: "logs" });
+  console.log("old snapshot sees logs:", oldSees);
 
   const after = await server.snapshot();
   assert.equal(after.windows.exists({ name: "logs" }), true);
-  console.log("fresh snapshot sees logs:", after.windows.exists({ name: "logs" }));
+  const freshSees = after.windows.exists({ name: "logs" });
+  console.log("fresh snapshot sees logs:", freshSees);
   const logs = after.windows.one({ name: "logs" });
   await logs.rename("archive");
   assert.equal(logs.name, "logs");
@@ -389,10 +425,13 @@ try {
     if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
     await rm(directory, { recursive: true });
   } catch (error) {
-    failures.push(new Error(`Cleanup failed; inspect ${directory}`, { cause: error }));
+    const message = `Cleanup failed; inspect ${directory}`;
+    failures.push(new Error(message, { cause: error }));
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Query example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Query example failed");
+}
 ```
 
 ```console
@@ -432,7 +471,9 @@ import {
 
 const directory = await mkdtemp(join(tmpdir(), "libtmux-query-"));
 const server = new Server({
-  socketPath: join(directory, "tmux.sock"), configFile: "/dev/null", timeoutMs: 5_000,
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
 });
 const failures: unknown[] = [];
 try {
@@ -443,7 +484,9 @@ try {
   });
   const document = decodeWhereDocument(JSON.parse(encoded));
   assert.equal(document.model, "session");
-  if (document.model !== "session") throw new Error("Expected session criteria");
+  if (document.model !== "session") {
+    throw new Error("Expected session criteria");
+  }
   const snapshot = await server.snapshot();
   const selected = snapshot.sessions.where(document.where);
   assert.equal(selected.one().name, "prod-api");
@@ -451,7 +494,11 @@ try {
   console.log("wire JSON:", encoded);
 
   try {
-    decodeWhereDocument({ version: 1, model: "session", where: { session_naem: "prod-api" } });
+    decodeWhereDocument({
+      version: 1,
+      model: "session",
+      where: { session_naem: "prod-api" },
+    });
     throw new Error("Expected an unknown field to fail validation");
   } catch (error) {
     if (!(error instanceof QueryValidationError)) throw error;
@@ -474,10 +521,13 @@ try {
     if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
     await rm(directory, { recursive: true });
   } catch (error) {
-    failures.push(new Error(`Cleanup failed; inspect ${directory}`, { cause: error }));
+    const message = `Cleanup failed; inspect ${directory}`;
+    failures.push(new Error(message, { cause: error }));
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Query example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Query example failed");
+}
 ```
 
 ```console
@@ -512,7 +562,9 @@ import { Server } from "libtmux";
 
 const directory = await mkdtemp(join(tmpdir(), "libtmux-query-"));
 const server = new Server({
-  socketPath: join(directory, "tmux.sock"), configFile: "/dev/null", timeoutMs: 5_000,
+  socketPath: join(directory, "tmux.sock"),
+  configFile: "/dev/null",
+  timeoutMs: 5_000,
 });
 const failures: unknown[] = [];
 try {
@@ -549,10 +601,13 @@ try {
     if ((await readdir(directory)).includes("tmux.sock")) await server.kill();
     await rm(directory, { recursive: true });
   } catch (error) {
-    failures.push(new Error(`Cleanup failed; inspect ${directory}`, { cause: error }));
+    const message = `Cleanup failed; inspect ${directory}`;
+    failures.push(new Error(message, { cause: error }));
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Query example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Query example failed");
+}
 ```
 
 ```console
diff --git a/site/src/content/docs/ports/ts/guides/attaching-to-tmux.md b/site/src/content/docs/ports/ts/guides/attaching-to-tmux.md
index 3e303c571..bd6886674 100644
--- a/site/src/content/docs/ports/ts/guides/attaching-to-tmux.md
+++ b/site/src/content/docs/ports/ts/guides/attaching-to-tmux.md
@@ -30,7 +30,9 @@ the example.
 import { Server } from "libtmux";
 
 const socketPath = process.env.LIBTMUX_SOCKET_PATH;
-if (!socketPath) throw new Error("Set LIBTMUX_SOCKET_PATH to an existing socket");
+if (!socketPath) {
+  throw new Error("Set LIBTMUX_SOCKET_PATH to an existing socket");
+}
 const server = new Server({ socketPath, timeoutMs: 5_000 });
 const snapshot = await server.snapshot({ signal: AbortSignal.timeout(5_000) });
 const session = snapshot.sessions.one({ name: "work" });
diff --git a/site/src/content/docs/ports/ts/mcp/examples.md b/site/src/content/docs/ports/ts/mcp/examples.md
index 5b75ada96..14d50b074 100644
--- a/site/src/content/docs/ports/ts/mcp/examples.md
+++ b/site/src/content/docs/ports/ts/mcp/examples.md
@@ -43,8 +43,10 @@ Fetch the source revision used by this example:
 
 ```console
 $ git init libtmux-source && \
-    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \
-    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \
+    git -C libtmux-source remote add origin \
+      https://github.com/libtmux/libtmux-ts.git && \
+    git -C libtmux-source fetch --depth 1 origin \
+      3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \
     git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -144,7 +146,9 @@ try {
     catch (error) { failures.push(error); }
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "MCP example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "MCP example failed");
+}
 ```
 
 `newSession` can fail after starting tmux. Cleanup checks the owned socket
diff --git a/site/src/content/docs/ports/ts/workspace/internals/examples.md b/site/src/content/docs/ports/ts/workspace/internals/examples.md
index f31e698d2..06255b227 100644
--- a/site/src/content/docs/ports/ts/workspace/internals/examples.md
+++ b/site/src/content/docs/ports/ts/workspace/internals/examples.md
@@ -28,8 +28,10 @@ Fetch the source revision used by this example:
 
 ```console
 $ git init libtmux-source && \
-    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \
-    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \
+    git -C libtmux-source remote add origin \
+      https://github.com/libtmux/libtmux-ts.git && \
+    git -C libtmux-source fetch --depth 1 origin \
+      3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \
     git -C libtmux-source checkout --detach FETCH_HEAD
 ```
 
@@ -110,7 +112,9 @@ try {
     catch (error) { failures.push(error); }
   }
 }
-if (failures.length > 0) throw new AggregateError(failures, "Workspace example failed");
+if (failures.length > 0) {
+  throw new AggregateError(failures, "Workspace example failed");
+}
 ```
 
 `newSession` can fail after starting tmux. Cleanup checks the owned socket
diff --git a/site/src/content/docs/topics/architecture.md b/site/src/content/docs/topics/architecture.md
index 21917dc12..7ae17efe8 100644
--- a/site/src/content/docs/topics/architecture.md
+++ b/site/src/content/docs/topics/architecture.md
@@ -35,7 +35,11 @@ await pane.kill();
 
 ```go
 cmd := "printf 'hello\\n'"
-if err := pane.SendKeys(ctx, tmux.SendKeysRequest{Command: &cmd, Literal: true}); err != nil {
+err := pane.SendKeys(ctx, tmux.SendKeysRequest{
+    Command: &cmd,
+    Literal: true,
+})
+if err != nil {
     return err
 }
 if err := pane.Kill(ctx); err != nil {
diff --git a/site/src/content/docs/topics/context-managers.md b/site/src/content/docs/topics/context-managers.md
index 605ed6305..d9bf41493 100644
--- a/site/src/content/docs/topics/context-managers.md
+++ b/site/src/content/docs/topics/context-managers.md
@@ -68,7 +68,8 @@ not disposable:
 
 ```csharp
 await using OwnedSessionScope session = await server.CreateOwnedSessionAsync();
-await using OwnedWindowScope window = await session.Value.CreateOwnedWindowAsync();
+await using OwnedWindowScope window =
+    await session.Value.CreateOwnedWindowAsync();
 
 await window.Value.SendTextAsync("echo hello");
 // window, then session, killed on the way out
@@ -188,9 +189,9 @@ func temporarySession(ctx context.Context, server tmux.Server) (err error) {
         return err
     }
     defer func() {
-        cleanup, cancel := context.WithTimeout(context.Background(), time.Second)
+        done, cancel := context.WithTimeout(context.Background(), time.Second)
         defer cancel()
-        err = errors.Join(err, session.Kill(cleanup))
+        err = errors.Join(err, session.Kill(done))
     }()
     _, err = session.SearchWindows(ctx, nil)
     return err
diff --git a/site/src/content/docs/topics/environment.md b/site/src/content/docs/topics/environment.md
index dde57f143..4df5f6ba0 100644
--- a/site/src/content/docs/topics/environment.md
+++ b/site/src/content/docs/topics/environment.md
@@ -358,7 +358,8 @@ await session.showEnvironment();
 ```
 
 ```go
-if err := session.SetEnvironment(ctx, "EDITOR", "hx", tmux.SetEnvironmentOptions{}); err != nil {
+opts := tmux.SetEnvironmentOptions{}
+if err := session.SetEnvironment(ctx, "EDITOR", "hx", opts); err != nil {
     return err
 }
 values, err := session.ShowEnvironment(ctx)
@@ -381,9 +382,10 @@ await session.Environment.GetAllAsync();
 ```
 
 ```swift
+let id = session.id.rawValue
 try await server.setEnvironment("EDITOR", to: "vim", in: .global)
-try await server.setEnvironment("EDITOR", to: "hx", in: .session(session.id.rawValue))
-try await server.environment(.session(session.id.rawValue))
+try await server.setEnvironment("EDITOR", to: "hx", in: .session(id))
+try await server.environment(.session(id))
 ```
 
 <!-- /port -->
diff --git a/site/src/content/docs/topics/errors-and-exceptions.md b/site/src/content/docs/topics/errors-and-exceptions.md
index 49b22d541..d15cd9a4c 100644
--- a/site/src/content/docs/topics/errors-and-exceptions.md
+++ b/site/src/content/docs/topics/errors-and-exceptions.md
@@ -208,7 +208,8 @@ try
 {
     await session.CreateWindowAsync(new NewWindowRequest(name: "build"));
 }
-catch (LibTmuxException error) when (error.Dispatch == TmuxDispatchState.NotDispatched)
+catch (LibTmuxException error)
+    when (error.Dispatch == TmuxDispatchState.NotDispatched)
 {
     // safe to retry
 }
@@ -216,7 +217,8 @@ catch (LibTmuxException error) when (error.Dispatch == TmuxDispatchState.NotDisp
 
 ```cpp
 auto result = session.new_window({.name = "build"});
-if (!result.has_value() && result.error().delivery == libtmux::DeliveryStatus::not_started) {
+constexpr auto retryable = libtmux::DeliveryStatus::not_started;
+if (!result.has_value() && result.error().delivery == retryable) {
   // safe to retry
 }
 ```
diff --git a/site/src/content/docs/topics/format-tokens.md b/site/src/content/docs/topics/format-tokens.md
index fa988fbfc..bd9137839 100644
--- a/site/src/content/docs/topics/format-tokens.md
+++ b/site/src/content/docs/topics/format-tokens.md
@@ -120,9 +120,11 @@ not request those fields. A handle resolved by ID alone may therefore lack
 enough data to answer:
 
 ```csharp
-string? title = pane.Title;   // nullable: the ordinary absence case
-int height = pane.Height;     // throws IncompleteSnapshotException instead,
-                               // if this Pane wasn't captured with a full listing
+// nullable: the ordinary absence case
+string? title = pane.Title;
+// throws IncompleteSnapshotException instead, if this Pane wasn't
+// captured with a full listing
+int height = pane.Height;
 ```
 <!-- /port -->
 
diff --git a/site/src/content/docs/topics/options-and-hooks.md b/site/src/content/docs/topics/options-and-hooks.md
index 7259e705d..0e093d87c 100644
--- a/site/src/content/docs/topics/options-and-hooks.md
+++ b/site/src/content/docs/topics/options-and-hooks.md
@@ -167,7 +167,8 @@ await pane.unsetOption("automatic-rename");
 ```
 
 ```go
-if err := window.SetOption(ctx, "automatic-rename", "off", tmux.SetOptionOptions{}); err != nil {
+set := tmux.SetOptionOptions{}
+if err := window.SetOption(ctx, "automatic-rename", "off", set); err != nil {
     return fmt.Errorf("set automatic rename: %w", err)
 }
 options, err := window.Options(ctx)
@@ -176,7 +177,8 @@ if err != nil {
 }
 value, present := options.AutomaticRename().Get()
 fmt.Println("automatic rename:", value, "present:", present)
-if err := window.UnsetOption(ctx, "automatic-rename", tmux.UnsetOptionOptions{}); err != nil {
+unset := tmux.UnsetOptionOptions{}
+if err := window.UnsetOption(ctx, "automatic-rename", unset); err != nil {
     return fmt.Errorf("unset automatic rename: %w", err)
 }
 ```
@@ -369,7 +371,8 @@ await session.showHooks();
 ```
 
 ```go
-if err := session.SetHook(ctx, "session-renamed", "display-message 'renamed'"); err != nil {
+hook := "display-message 'renamed'"
+if err := session.SetHook(ctx, "session-renamed", hook); err != nil {
     return fmt.Errorf("set session hook: %w", err)
 }
 value, present, err := session.RawHook(ctx, "session-renamed")
@@ -390,7 +393,8 @@ session.hooks().all();
 ```
 
 ```csharp
-await session.Hooks.SetAsync(new SetHookRequest("session-renamed", "display-message 'renamed'"));
+SetHookRequest hook = new("session-renamed", "display-message 'renamed'");
+await session.Hooks.SetAsync(hook);
 await session.Hooks.GetAllAsync();
 ```
 
@@ -400,8 +404,10 @@ session.hooks(); // No session unset helper is listed above.
 ```
 
 ```swift
-try await server.setHook("session-renamed", to: "display-message 'renamed'", in: .session(session.id.rawValue))
-try await server.hooks(.session(session.id.rawValue))
+let id = session.id.rawValue
+let command = "display-message 'renamed'"
+try await server.setHook("session-renamed", to: command, in: .session(id))
+try await server.hooks(.session(id))
 ```
 
 <a id="window-and-pane-hook-scopes-are-mostly-fiction"></a>
diff --git a/site/src/content/docs/topics/pane-interaction.md b/site/src/content/docs/topics/pane-interaction.md
index 1e3bf8d79..42fb1f899 100644
--- a/site/src/content/docs/topics/pane-interaction.md
+++ b/site/src/content/docs/topics/pane-interaction.md
@@ -196,8 +196,10 @@ pane->send_key("Enter"); // separate command: no combined convenience exists
 ```
 
 ```swift
-try await server.sendKeys(["echo hi"], to: pane) // no Enter
-try await server.run("echo hi", in: pane)        // sugar for sendKeys([text, "Enter"])
+// no Enter
+try await server.sendKeys(["echo hi"], to: pane)
+// sugar for sendKeys([text, "Enter"])
+try await server.run("echo hi", in: pane)
 ```
 
 ## Reading a pane back
diff --git a/site/src/content/docs/topics/socket-and-servers.md b/site/src/content/docs/topics/socket-and-servers.md
index 6b4dace51..312e4d08e 100644
--- a/site/src/content/docs/topics/socket-and-servers.md
+++ b/site/src/content/docs/topics/socket-and-servers.md
@@ -115,7 +115,8 @@ Server named = Server.open(config);
 ```csharp
 using LibTmux;
 
-Server named = await Server.ConnectAsync(new ServerConnectionOptions(socketName: "work"));
+ServerConnectionOptions options = new(socketName: "work");
+Server named = await Server.ConnectAsync(options);
 ```
 
 ```cpp
diff --git a/site/src/content/docs/topics/traversal.md b/site/src/content/docs/topics/traversal.md
index 2e7e0c10f..e8629dd23 100644
--- a/site/src/content/docs/topics/traversal.md
+++ b/site/src/content/docs/topics/traversal.md
@@ -290,14 +290,15 @@ if err != nil {
 for _, session := range sessions {
     windows, captured := session.Windows()
     if !captured {
-        return fmt.Errorf("session %s has no captured window relations", session.ID())
+        return fmt.Errorf("session %s has no windows", session.ID())
     }
     for _, window := range windows {
         back, captured := window.Session()
         if !captured {
             return fmt.Errorf("window %s has no captured session", window.ID())
         }
-        fmt.Println(window.ID(), "belongs to session:", back.ID() == session.ID())
+        same := back.ID() == session.ID()
+        fmt.Println(window.ID(), "belongs to session:", same)
     }
 }
 ```
@@ -329,10 +330,12 @@ back.Equals(session);
 ```
 
 ```cpp
-auto sessions = server.sessions();       // expected<vector<Session>, CommandFailure>
+// expected<vector<Session>, CommandFailure>
+auto sessions = server.sessions();
 const auto& session = sessions->at(0);
 
-auto windows = session.windows();        // expected<vector<Window>, CommandFailure>
+// expected<vector<Window>, CommandFailure>
+auto windows = session.windows();
 const auto& window = windows->at(0);
 
 auto back = window.session();            // expected<Session, CommandFailure>
diff --git a/site/src/content/docs/topics/waiting-and-retry.md b/site/src/content/docs/topics/waiting-and-retry.md
index bb1e56358..2989942ab 100644
--- a/site/src/content/docs/topics/waiting-and-retry.md
+++ b/site/src/content/docs/topics/waiting-and-retry.md
@@ -136,7 +136,8 @@ await live.waitFor((snapshot) => snapshot.windows.exists({ name: "build" }));
 ```go
 waitCtx, cancel := context.WithTimeout(ctx, 5*time.Second)
 defer cancel()
-err := tmuxtest.WaitFor(waitCtx, 50*time.Millisecond, func(ctx context.Context) (bool, error) {
+poll := 50 * time.Millisecond
+err := tmuxtest.WaitFor(waitCtx, poll, func(ctx context.Context) (bool, error) {
 	windows, err := session.SearchWindows(ctx, nil)
 	if err != nil {
 		return false, err
@@ -155,7 +156,8 @@ if err != nil {
 
 ```rust
 libtmux::test::retry_until(std::time::Duration::from_secs(5), async || {
-    session.windows().await.map(|ws| ws.iter().any(|w| w.name() == "build")).unwrap_or(false)
+    let windows = session.windows().await;
+    windows.map(|ws| ws.iter().any(|w| w.name() == "build")).unwrap_or(false)
 })
 .await?;
 ```
@@ -258,14 +260,16 @@ if err := server.WaitFor(ctx, tmux.WaitForRequest{
 }); err != nil {
     return err
 }
-if err := server.WaitFor(ctx, tmux.WaitForRequest{Channel: "built"}); err != nil {
+wait := tmux.WaitForRequest{Channel: "built"}
+if err := server.WaitFor(ctx, wait); err != nil {
     return err
 }
 ```
 
 ```rust
 server.signal_channel("built").await?;
-let outcome = server.wait_for_channel("built", std::time::Duration::from_secs(5)).await?;
+let timeout = std::time::Duration::from_secs(5);
+let outcome = server.wait_for_channel("built", timeout).await?;
 ```
 
 ```java
diff --git a/site/src/data/mentions.json b/site/src/data/mentions.json
index 3fd8a57bb..649da9bcb 100644
--- a/site/src/data/mentions.json
+++ b/site/src/data/mentions.json
@@ -13320,14 +13320,14 @@
    "port": "swift",
    "text": "TmuxWorkspace",
    "page": "/concepts/workspaces/",
-   "line": 153,
+   "line": 160,
    "why": "not defined in the stated port"
   },
   {
    "port": "swift",
    "text": "YAMLWorkspaces",
    "page": "/concepts/workspaces/",
-   "line": 154,
+   "line": 161,
    "why": "not defined in the stated port"
   },
   {
@@ -13404,7 +13404,7 @@
    "port": "ts",
    "text": "[Symbol.asyncDispose]",
    "page": "/topics/context-managers/",
-   "line": 147,
+   "line": 148,
    "why": "not defined in the stated port"
   }
  ]
diff --git a/site/src/db/index.ts b/site/src/db/index.ts
index ec8f35b60..d08d0c11b 100644
--- a/site/src/db/index.ts
+++ b/site/src/db/index.ts
@@ -111,9 +111,7 @@ function connect(): { db: DatabaseSync; statements: Statements } {
       `SELECT port, id, public_id, kind, summary FROM symbol
        WHERE name = ? AND version = ? AND port != ? ORDER BY port`,
     ),
-    mentionsOfSymbol: opened.prepare(
-      'SELECT * FROM mention WHERE port = ? AND symbol_id = ? ORDER BY section, page',
-    ),
+    mentionsOfSymbol: opened.prepare('SELECT * FROM mention WHERE port = ? AND symbol_id = ? ORDER BY section, page'),
     mentionsOnPage: opened.prepare('SELECT * FROM mention WHERE page = ? ORDER BY port, symbol_id'),
     conceptOfSymbol: opened.prepare(
       `SELECT b.concept, c.label FROM concept_binding b
@@ -166,11 +164,7 @@ export function symbolById(port: string, version: string, id: string): SymbolRow
 }
 
 /** One symbol by the path it is imported and anchored by. */
-export function symbolByPublicId(
-  port: string,
-  version: string,
-  publicId: string,
-): SymbolRow | undefined {
+export function symbolByPublicId(port: string, version: string, publicId: string): SymbolRow | undefined {
   return row<SymbolRow>(connect().statements.byPublicId, port, version, publicId)
 }
 
@@ -231,10 +225,7 @@ export function mentionsOn(page: string): MentionRow[] {
  * This is the question a reference page asks once per rendered symbol, which
  * is why it is a seek rather than a scan over every concept's bindings.
  */
-export function conceptOf(
-  port: string,
-  symbolId: string,
-): { concept: string; label: string } | undefined {
+export function conceptOf(port: string, symbolId: string): { concept: string; label: string } | undefined {
   return row<{ concept: string; label: string }>(connect().statements.conceptOfSymbol, port, symbolId)
 }
 
diff --git a/site/src/db/paths.ts b/site/src/db/paths.ts
index 45eeb5ef9..aef296787 100644
--- a/site/src/db/paths.ts
+++ b/site/src/db/paths.ts
@@ -24,9 +24,6 @@ export const MODEL_DIR = join(SITE_ROOT, 'src/data/api')
  * than as the collision it is. A build sets nothing and keeps the plain name.
  */
 const worker = process.env.VITEST_WORKER_ID
-export const DB_PATH = join(
-  SITE_ROOT,
-  `node_modules/.cache/libtmux-api${worker ? `-w${worker}` : ''}.sqlite`,
-)
+export const DB_PATH = join(SITE_ROOT, `node_modules/.cache/libtmux-api${worker ? `-w${worker}` : ''}.sqlite`)
 
 export const SCHEMA_PATH = join(here, 'schema.sql')
diff --git a/site/src/db/seed.ts b/site/src/db/seed.ts
index b66c91e4e..ee2cd7726 100644
--- a/site/src/db/seed.ts
+++ b/site/src/db/seed.ts
@@ -179,14 +179,7 @@ export function seed(options: SeedOptions = {}): SeedResult {
       ports += 1
 
       for (const version of versionsFor(port, manifestPath)) {
-        insertExtraction.run(
-          port,
-          version,
-          model.revision ?? null,
-          model.extractor,
-          model.symbols.length,
-          builtAt,
-        )
+        insertExtraction.run(port, version, model.revision ?? null, model.extractor, model.symbols.length, builtAt)
         for (const s of model.symbols) {
           const result = insertSymbol.run(
             port,
diff --git a/site/src/i18n/locales.ts b/site/src/i18n/locales.ts
index a5b2f3284..9672d9ad7 100644
--- a/site/src/i18n/locales.ts
+++ b/site/src/i18n/locales.ts
@@ -66,8 +66,7 @@ export function localeRoot(locale: string): string {
 /** The page path below its build locale, including Astro's flat error page. */
 export function localeSourcePath(pathname: string, buildLocale: string): string {
   const root = localeRoot(buildLocale)
-  const path = (pathname.startsWith(root) ? pathname.slice(root.length) : pathname)
-    .replace(/^\/+|\/+$/g, '')
+  const path = (pathname.startsWith(root) ? pathname.slice(root.length) : pathname).replace(/^\/+|\/+$/g, '')
   return path.replace(/(^|\/)404$/, '$1404.html')
 }
 
diff --git a/site/src/i18n/resolve.ts b/site/src/i18n/resolve.ts
index 0ce1ac33e..35b9d24d0 100644
--- a/site/src/i18n/resolve.ts
+++ b/site/src/i18n/resolve.ts
@@ -136,9 +136,7 @@ export async function localeStatusesFor(sourceId: string): Promise<Record<string
   const statuses: Record<string, LocaleStatus> = { [DEFAULT_LOCALE]: 'translated' }
   for (const locale of LOCALES) {
     if (locale === DEFAULT_LOCALE) continue
-    const translation = entries.find(
-      (e) => localeOf(e.id) === locale && sourceIdOf(e.id) === sourceId,
-    )
+    const translation = entries.find((e) => localeOf(e.id) === locale && sourceIdOf(e.id) === sourceId)
     if (!translation) {
       statuses[locale] = 'placeholder'
       continue
diff --git a/site/src/i18n/ui.ts b/site/src/i18n/ui.ts
index 79103f5bf..64ceb4725 100644
--- a/site/src/i18n/ui.ts
+++ b/site/src/i18n/ui.ts
@@ -16,8 +16,7 @@ export const ui = {
     'i18n.contribute': 'Help translate it',
     'i18n.translated': 'Japanese translation available',
     'i18n.stale': 'This translation is out of date',
-    'i18n.staleBody':
-      'The English page has changed since this was translated. The English original is authoritative.',
+    'i18n.staleBody': 'The English page has changed since this was translated. The English original is authoritative.',
     'i18n.unreviewed': 'Machine translation, not yet reviewed by a native speaker.',
     'i18n.readEnglish': 'Read the English original',
     'i18n.available': 'Available translations',
@@ -45,8 +44,7 @@ export const ui = {
     'i18n.contribute': '翻訳に協力する',
     'i18n.translated': '日本語版があります',
     'i18n.stale': 'この翻訳は最新ではありません',
-    'i18n.staleBody':
-      '翻訳後に英語版が更新されています。正本は英語版です。',
+    'i18n.staleBody': '翻訳後に英語版が更新されています。正本は英語版です。',
     'i18n.unreviewed': '機械翻訳です。ネイティブによるレビューは未了です。',
     'i18n.readEnglish': '英語の原文を読む',
     'i18n.available': '利用できる言語',
diff --git a/site/src/integrations/dangling-report.ts b/site/src/integrations/dangling-report.ts
index 7258a2380..0913507f2 100644
--- a/site/src/integrations/dangling-report.ts
+++ b/site/src/integrations/dangling-report.ts
@@ -3,7 +3,11 @@ import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import type { AstroIntegration } from 'astro'
 
-interface DanglingReference { port: string; text: string; why: string }
+interface DanglingReference {
+  port: string
+  text: string
+  why: string
+}
 
 /**
  * Report unresolved API mentions at the end of a build, and fail on a
@@ -79,7 +83,10 @@ export function danglingReport(maxDangling = 60): AstroIntegration {
         for (const d of dangling) byPort.set(d.port, (byPort.get(d.port) ?? 0) + 1)
         logger.warn(
           `${dangling.length} dangling API references (` +
-            [...byPort].sort((a, b) => b[1] - a[1]).map(([p, n]) => `${p}:${n}`).join(' ') +
+            [...byPort]
+              .sort((a, b) => b[1] - a[1])
+              .map(([p, n]) => `${p}:${n}`)
+              .join(' ') +
             ')',
         )
         for (const d of dangling.slice(0, 12)) logger.warn(`  ${d.port}  ${d.text}  (${d.why})`)
diff --git a/site/src/integrations/inventory.ts b/site/src/integrations/inventory.ts
index f8a98d8c8..1384225ad 100644
--- a/site/src/integrations/inventory.ts
+++ b/site/src/integrations/inventory.ts
@@ -70,11 +70,14 @@ export function inventory(): AstroIntegration {
           const uri = uriForModel(model, false)
           const path = join(dir.pathname, 'reference', 'objects.inv')
           mkdirSync(dirname(path), { recursive: true })
-          writeFileSync(path, writeInventory(model, {
-            project: `libtmux for ${PORT_NAME[buildPort] ?? buildPort}`,
-            version: model.revision?.slice(0, 7) ?? 'latest',
-            uriFor: uri,
-          }))
+          writeFileSync(
+            path,
+            writeInventory(model, {
+              project: `libtmux for ${PORT_NAME[buildPort] ?? buildPort}`,
+              version: model.revision?.slice(0, 7) ?? 'latest',
+              uriFor: uri,
+            }),
+          )
           logger.info(`objects.inv written for ${buildPort} (${model.symbols.length} symbols)`)
           return
         }
@@ -88,10 +91,14 @@ export function inventory(): AstroIntegration {
           const model = tmuxSourceModel(version)
           const path = join(out, 'tmux', version, 'reference', 'objects.inv')
           mkdirSync(dirname(path), { recursive: true })
-          writeFileSync(path, writeInventory(model, {
-            project: 'tmux C source', version: model.version,
-            uriFor: (symbol) => `${symbol.slug}/`,
-          }))
+          writeFileSync(
+            path,
+            writeInventory(model, {
+              project: 'tmux C source',
+              version: model.version,
+              uriFor: (symbol) => `${symbol.slug}/`,
+            }),
+          )
         }
 
         const uriFor = uriForModel
diff --git a/site/src/integrations/markdown-twins.ts b/site/src/integrations/markdown-twins.ts
index 8fddf7b47..8029e90fa 100644
--- a/site/src/integrations/markdown-twins.ts
+++ b/site/src/integrations/markdown-twins.ts
@@ -42,11 +42,18 @@ export function markdownTwins(): AstroIntegration {
         // MCP exports write schema-preserving twins. Let the generic pass skip them.
         if (buildLocale() === DEFAULT_LOCALE) {
           const defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
-          writeMcpExports(out, base, mcpReferenceRoutes(process.env.LIBTMUX_DOCS_PORT, defaults, buildTarget(process.env).version))
+          writeMcpExports(
+            out,
+            base,
+            mcpReferenceRoutes(process.env.LIBTMUX_DOCS_PORT, defaults, buildTarget(process.env).version),
+          )
         }
-        for (const page of (readdirSync(out, { recursive: true }) as string[]).filter((file) => file.endsWith('.html'))) {
+        for (const page of (readdirSync(out, { recursive: true }) as string[]).filter((file) =>
+          file.endsWith('.html'),
+        )) {
           const html = readFileSync(join(out, page), 'utf8')
-          const link = [...html.matchAll(/<link\b[^>]*>/g)].map((tag) => tag[0])
+          const link = [...html.matchAll(/<link\b[^>]*>/g)]
+            .map((tag) => tag[0])
             .find((tag) => attribute(tag, 'rel') === 'alternate' && attribute(tag, 'type') === 'text/markdown')
           const href = link && attribute(link, 'href')
           const twin = link && attribute(link, 'data-twin')
@@ -63,7 +70,9 @@ export function markdownTwins(): AstroIntegration {
           converted++
         }
         if (missing.length > 0) {
-          throw new Error(`${missing.length} pages link a Markdown twin no route wrote:\n${missing.slice(0, 20).join('\n')}`)
+          throw new Error(
+            `${missing.length} pages link a Markdown twin no route wrote:\n${missing.slice(0, 20).join('\n')}`,
+          )
         }
         logger.info(`${converted} twins converted from rendered pages`)
       },
@@ -85,9 +94,12 @@ export function writeMcpExports(out: string, base: string, routes: ReturnType<ty
     const tool = object?.tool
     if (toolName && !tool) throw new Error(`Missing MCP registration: ${port}/${toolName}`)
     const source = tool?.source ?? {
-      repo: reference.repo, revision: reference.revision, extractedRevision: reference.extractedRevision,
+      repo: reference.repo,
+      revision: reference.revision,
+      extractedRevision: reference.extractedRevision,
     }
-    if (!tool) page.body += `\nSource revision: [${source.repo}@${source.extractedRevision ?? source.revision}](https://github.com/${source.repo}/tree/${source.extractedRevision ?? source.revision}).\n`
+    if (!tool)
+      page.body += `\nSource revision: [${source.repo}@${source.extractedRevision ?? source.revision}](https://github.com/${source.repo}/tree/${source.extractedRevision ?? source.revision}).\n`
     const markdownUrl = markdownPath(page.url, false)
     const target = join(out, decodeURIComponent(new URL(markdownUrl).pathname.slice(base.length)))
     const markdown = markdownDocument(page)
@@ -96,21 +108,39 @@ export function writeMcpExports(out: string, base: string, routes: ReturnType<ty
     const section = `${PORT_BY_SLUG[port].name} MCP ${MCP_SECTIONS[domain].toLowerCase()}`
     // Replacing an existing entry also makes a repeated integration idempotent.
     manifest.pages = manifest.pages.filter((entry: { url: string }) => entry.url !== page.url)
-    manifest.pages.push({ title: page.title, description: page.description ?? '', section,
-      url: page.url, markdownUrl, headings: page.headings, source })
+    manifest.pages.push({
+      title: page.title,
+      description: page.description ?? '',
+      section,
+      url: page.url,
+      markdownUrl,
+      headings: page.headings,
+      source,
+    })
     documents.push({ url: page.url, markdown, title: page.title, section })
   }
   writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`)
   const fullPath = join(out, 'llms-full.txt')
   const urls = new Set(documents.map((page) => page.url))
-  const prose = readFileSync(fullPath, 'utf8').split('\n---\n\n')
-    .filter((section) => !urls.has(/^Source: (\S+)$/m.exec(section)?.[1] ?? '')).join('\n---\n\n').trimEnd()
+  const prose = readFileSync(fullPath, 'utf8')
+    .split('\n---\n\n')
+    .filter((section) => !urls.has(/^Source: (\S+)$/m.exec(section)?.[1] ?? ''))
+    .join('\n---\n\n')
+    .trimEnd()
   writeFileSync(fullPath, `${prose}\n\n${documents.map((page) => `---\n\n${page.markdown}`).join('\n')}\n`)
   const indexPath = join(out, 'llms.txt')
-  const index = readFileSync(indexPath, 'utf8').split('\n## ')
-    .filter((section) => !documents.some((page) => section.startsWith(`${page.section}\n`))).join('\n## ').trimEnd()
-  const sections = [...new Set(documents.map((page) => page.section))]
-    .map((section) => `## ${section}\n\n${documents.filter((page) => page.section === section).map((page) => `- [${page.title}](${page.url})`).join('\n')}`)
+  const index = readFileSync(indexPath, 'utf8')
+    .split('\n## ')
+    .filter((section) => !documents.some((page) => section.startsWith(`${page.section}\n`)))
+    .join('\n## ')
+    .trimEnd()
+  const sections = [...new Set(documents.map((page) => page.section))].map(
+    (section) =>
+      `## ${section}\n\n${documents
+        .filter((page) => page.section === section)
+        .map((page) => `- [${page.title}](${page.url})`)
+        .join('\n')}`,
+  )
   writeFileSync(indexPath, `${index}\n\n${sections.join('\n\n')}\n`)
 }
 
@@ -128,7 +158,19 @@ interface Node {
 }
 
 /** Chrome that is not the page's content, and markup Markdown cannot carry. */
-const DROP = new Set(['script', 'style', 'template', 'noscript', 'svg', 'button', 'nav', 'form', 'input', 'select', 'dialog'])
+const DROP = new Set([
+  'script',
+  'style',
+  'template',
+  'noscript',
+  'svg',
+  'button',
+  'nav',
+  'form',
+  'input',
+  'select',
+  'dialog',
+])
 
 function find(node: Node, test: (element: Node) => boolean): Node | undefined {
   if (node.type === 'element' && test(node)) return node
@@ -151,25 +193,34 @@ function textOf(node: Node | undefined): string {
  */
 function prune(node: Node, origin: string, drop?: Node, preserveSchemas = false, pageUrl?: string): void {
   // A tab set shows one panel until someone clicks; keep the one it opens on.
-  const opening = (node.children ?? []).find((child) => child.properties?.role === 'tabpanel' && child.properties?.dataDefault !== undefined)
+  const opening = (node.children ?? []).find(
+    (child) => child.properties?.role === 'tabpanel' && child.properties?.dataDefault !== undefined,
+  )
   node.children = (node.children ?? []).filter((child) => {
     if (child === drop || child.type === 'comment') return false
     if (child.type !== 'element') return true
     const props = child.properties ?? {}
-    if (DROP.has(child.tagName!) || props.hidden || props.ariaHidden === 'true' ||
-      (props.dataPagefindIgnore !== undefined && !(preserveSchemas && child.tagName === 'details'))) return false
+    if (
+      DROP.has(child.tagName!) ||
+      props.hidden ||
+      props.ariaHidden === 'true' ||
+      (props.dataPagefindIgnore !== undefined && !(preserveSchemas && child.tagName === 'details'))
+    )
+      return false
     if (props.role === 'dialog' || (opening && props.role === 'tabpanel' && child !== opening)) return false
     // A collapsible table of contents: without its `nav`, the summary says nothing.
     return !(child.tagName === 'details' && find(child, (element) => element.tagName === 'nav'))
   })
   for (const child of node.children) {
     if (child.type !== 'element') continue
-    const props = child.properties ??= {}
+    const props = (child.properties ??= {})
     for (const key of ['href', 'src']) {
       if (typeof props[key] !== 'string') continue
       if (preserveSchemas && pageUrl) props[key] = new URL(props[key] as string, pageUrl).href
-      else if ((props[key] as string).startsWith('/') && !(props[key] as string).startsWith('//')) props[key] = `${origin}${props[key]}`
-      else if (pageUrl && (props[key] as string).startsWith('#')) props[key] = new URL(props[key] as string, pageUrl).href
+      else if ((props[key] as string).startsWith('/') && !(props[key] as string).startsWith('//'))
+        props[key] = `${origin}${props[key]}`
+      else if (pageUrl && (props[key] as string).startsWith('#'))
+        props[key] = new URL(props[key] as string, pageUrl).href
     }
     // Shiki and the install widget put the language on the block, not on `code`.
     if (typeof props.dataLanguage === 'string') {
@@ -183,27 +234,47 @@ function prune(node: Node, origin: string, drop?: Node, preserveSchemas = false,
 function renderedPage(html: string, preserveSchemas = false, pathname?: string) {
   const tree = fromHtml(html) as unknown as Node
   const head = find(tree, (element) => element.tagName === 'head')
-  const canonical = find(head ?? tree, (element) => element.tagName === 'link' && String(element.properties?.rel) === 'canonical')?.properties?.href as string | undefined
-  const description = find(head ?? tree, (element) => element.tagName === 'meta' && element.properties?.name === 'description')?.properties?.content as string | undefined
-  const url = pathname ? new URL(pathname, canonical).href : canonical ?? ''
+  const canonical = find(
+    head ?? tree,
+    (element) => element.tagName === 'link' && String(element.properties?.rel) === 'canonical',
+  )?.properties?.href as string | undefined
+  const description = find(
+    head ?? tree,
+    (element) => element.tagName === 'meta' && element.properties?.name === 'description',
+  )?.properties?.content as string | undefined
+  const url = pathname ? new URL(pathname, canonical).href : (canonical ?? '')
   const origin = url ? new URL(url).origin : ''
   // `main` first: the landing page's port cards are `article`s, and on a
   // DocsLayout page `main` holds nothing but the article.
-  const main = find(tree, (element) => (element.properties?.className as string[] | undefined)?.includes('api-reference-content') === true)
-    ?? find(tree, (element) => element.tagName === 'main')
-    ?? find(tree, (element) => element.tagName === 'article')
-    ?? find(tree, (element) => element.properties?.dataPagefindBody !== undefined)
-    ?? find(tree, (element) => element.tagName === 'body')!
+  const main =
+    find(
+      tree,
+      (element) => (element.properties?.className as string[] | undefined)?.includes('api-reference-content') === true,
+    ) ??
+    find(tree, (element) => element.tagName === 'main') ??
+    find(tree, (element) => element.tagName === 'article') ??
+    find(tree, (element) => element.properties?.dataPagefindBody !== undefined) ??
+    find(tree, (element) => element.tagName === 'body')!
   const heading = find(main, (element) => element.tagName === 'h1')
-  const title = textOf(heading).trim() || textOf(find(head ?? tree, (element) => element.tagName === 'title')).replace(/ \| libtmux$/, '').trim()
+  const title =
+    textOf(heading).trim() ||
+    textOf(find(head ?? tree, (element) => element.tagName === 'title'))
+      .replace(/ \| libtmux$/, '')
+      .trim()
   // The title leads the document, so the page's own h1 would repeat it.
   const headings: { id: string; level: number; text: string }[] = []
   const collectHeadings = (node: Node, sectionId?: string) => {
     const id = node.properties?.id ?? sectionId
-    if (/^h[2-6]$/.test(node.tagName ?? '') && typeof id === 'string') headings.push({
-      id, level: Number(node.tagName![1]), text: textOf(node).replace(/[¶#]\s*$/, '').trim(),
-    })
-    for (const child of node.children ?? []) collectHeadings(child, node.tagName === 'section' ? node.properties?.id as string | undefined : undefined)
+    if (/^h[2-6]$/.test(node.tagName ?? '') && typeof id === 'string')
+      headings.push({
+        id,
+        level: Number(node.tagName![1]),
+        text: textOf(node)
+          .replace(/[¶#]\s*$/, '')
+          .trim(),
+      })
+    for (const child of node.children ?? [])
+      collectHeadings(child, node.tagName === 'section' ? (node.properties?.id as string | undefined) : undefined)
   }
   collectHeadings(main)
   prune(main, origin, heading, preserveSchemas, url)
diff --git a/site/src/integrations/pagefind.ts b/site/src/integrations/pagefind.ts
index e78dfd005..ae75b9b24 100644
--- a/site/src/integrations/pagefind.ts
+++ b/site/src/integrations/pagefind.ts
@@ -26,9 +26,7 @@ export function pagefind(): AstroIntegration {
         logger.info(`indexing ${target}`)
         return new Promise<void>((resolve, reject) => {
           const proc = spawn('pnpm', ['exec', 'pagefind', '--site', target], { stdio: 'inherit' })
-          proc.on('close', (code) =>
-            code === 0 ? resolve() : reject(new Error(`pagefind exited ${code}`)),
-          )
+          proc.on('close', (code) => (code === 0 ? resolve() : reject(new Error(`pagefind exited ${code}`))))
           proc.on('error', reject)
         })
       },
diff --git a/site/src/lib/api-glossary.ts b/site/src/lib/api-glossary.ts
index 32ad26b07..221f7dd7c 100644
--- a/site/src/lib/api-glossary.ts
+++ b/site/src/lib/api-glossary.ts
@@ -13,12 +13,14 @@ interface Definition {
 const kinds = {
   module: {
     definition: 'A named scope that groups related declarations for lookup or import.',
-    detail: 'A module can be a Python file, a Julia namespace, or an F# grouping. The label alone does not identify an installable package.',
+    detail:
+      'A module can be a Python file, a Julia namespace, or an F# grouping. The label alone does not identify an installable package.',
     references: [{ title: 'Python modules', url: 'https://docs.python.org/3/tutorial/modules.html' }],
   },
   class: {
     definition: 'A type that groups data and behavior, often with inheritance.',
-    detail: 'The reference uses this category for class declarations and for Julia abstract types. Check the signature and abstract modifier before assuming a type can be constructed.',
+    detail:
+      'The reference uses this category for class declarations and for Julia abstract types. Check the signature and abstract modifier before assuming a type can be constructed.',
     references: [
       { title: 'Python classes', url: 'https://docs.python.org/3/tutorial/classes.html' },
       { title: 'Julia types', url: 'https://docs.julialang.org/en/v1/manual/types/' },
@@ -26,15 +28,20 @@ const kinds = {
   },
   interface: {
     definition: 'A contract describing the members or behavior a conforming type must provide.',
-    detail: 'This category also includes Swift protocols. Conformance rules differ by language: Go interfaces are satisfied implicitly, while other languages can require a declared relationship.',
+    detail:
+      'This category also includes Swift protocols. Conformance rules differ by language: Go interfaces are satisfied implicitly, while other languages can require a declared relationship.',
     references: [
       { title: 'Go interface types', url: 'https://go.dev/ref/spec#Interface_types' },
-      { title: 'Swift protocols', url: 'https://docs.swift.org/swift-book/documentation/the-swift-programming-language/protocols/' },
+      {
+        title: 'Swift protocols',
+        url: 'https://docs.swift.org/swift-book/documentation/the-swift-programming-language/protocols/',
+      },
     ],
   },
   struct: {
     definition: 'A structured type that groups fields and can expose operations on them.',
-    detail: 'Copying, mutation, and inheritance follow the language. A C++ struct is a class with different default access; Julia distinguishes struct from mutable struct. This badge does not promise immutability.',
+    detail:
+      'Copying, mutation, and inheritance follow the language. A C++ struct is a class with different default access; Julia distinguishes struct from mutable struct. This badge does not promise immutability.',
     references: [
       { title: 'C++ class declarations', url: 'https://eel.is/c++draft/class.pre' },
       { title: 'Julia composite types', url: 'https://docs.julialang.org/en/v1/manual/types/#Composite-Types' },
@@ -42,36 +49,50 @@ const kinds = {
   },
   union: {
     definition: 'A type that represents alternative forms of a value.',
-    detail: 'An F# discriminated union has named cases, which can carry data. A C++ union shares storage between members and has rules about which member is active. These have different representation and access rules.',
+    detail:
+      'An F# discriminated union has named cases, which can carry data. A C++ union shares storage between members and has rules about which member is active. These have different representation and access rules.',
     references: [
-      { title: 'F# discriminated unions', url: 'https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions' },
+      {
+        title: 'F# discriminated unions',
+        url: 'https://learn.microsoft.com/en-us/dotnet/fsharp/language-reference/discriminated-unions',
+      },
       { title: 'C++ unions', url: 'https://eel.is/c++draft/class.union' },
     ],
   },
   enum: {
     definition: 'A type with named values or variants.',
-    detail: 'C# enum members name integral values. Rust enum variants can also carry fields. Read the declaration to see which form is used.',
+    detail:
+      'C# enum members name integral values. Rust enum variants can also carry fields. Read the declaration to see which form is used.',
     references: [
-      { title: 'C# enumeration types', url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/enum' },
+      {
+        title: 'C# enumeration types',
+        url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/builtin-types/enum',
+      },
       { title: 'Rust enumerations', url: 'https://doc.rust-lang.org/reference/items/enumerations.html' },
     ],
   },
   trait: {
     definition: 'A named set of behavior that types can implement.',
-    detail: 'Rust traits can declare methods, associated types, and associated constants, with default implementations where the language permits them.',
+    detail:
+      'Rust traits can declare methods, associated types, and associated constants, with default implementations where the language permits them.',
     references: [{ title: 'Rust traits', url: 'https://doc.rust-lang.org/reference/items/traits.html' }],
   },
   function: {
     definition: 'A callable operation documented at module or language scope.',
-    detail: 'A PowerShell function is implemented in the scripting language; an advanced function can support cmdlet-style parameter binding and pipelines. Julia functions can have multiple methods selected by argument types.',
+    detail:
+      'A PowerShell function is implemented in the scripting language; an advanced function can support cmdlet-style parameter binding and pipelines. Julia functions can have multiple methods selected by argument types.',
     references: [
-      { title: 'PowerShell advanced functions', url: 'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions_advanced' },
+      {
+        title: 'PowerShell advanced functions',
+        url: 'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions_advanced',
+      },
       { title: 'Julia methods', url: 'https://docs.julialang.org/en/v1/manual/methods/' },
     ],
   },
   method: {
     definition: 'A callable member associated with a type or object.',
-    detail: 'An instance method works with an instance. Static and class methods use different binding rules, shown by their modifiers. Julia uses method to mean an implementation of a generic function for particular argument types.',
+    detail:
+      'An instance method works with an instance. Static and class methods use different binding rules, shown by their modifiers. Julia uses method to mean an implementation of a generic function for particular argument types.',
     references: [
       { title: 'Python method objects', url: 'https://docs.python.org/3/tutorial/classes.html#method-objects' },
       { title: 'Julia methods', url: 'https://docs.julialang.org/en/v1/manual/methods/' },
@@ -79,38 +100,62 @@ const kinds = {
   },
   property: {
     definition: 'A named value accessed through an object or type, potentially through a getter or setter.',
-    detail: 'The reference also uses this category for some extracted fields, including Julia fields. Reading a property can execute code; the badge alone does not establish whether it is writable or stored.',
+    detail:
+      'The reference also uses this category for some extracted fields, including Julia fields. Reading a property can execute code; the badge alone does not establish whether it is writable or stored.',
     references: [
-      { title: 'C# properties', url: 'https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties' },
+      {
+        title: 'C# properties',
+        url: 'https://learn.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/properties',
+      },
       { title: 'Julia composite types', url: 'https://docs.julialang.org/en/v1/manual/types/#Composite-Types' },
     ],
   },
   attribute: {
     definition: 'A named data attribute or field of an object or type.',
-    detail: 'On these pages, attribute describes member data. .NET attributes that attach metadata to declarations are a separate language feature.',
-    references: [{ title: 'Python class and instance attributes', url: 'https://docs.python.org/3/tutorial/classes.html' }],
+    detail:
+      'On these pages, attribute describes member data. .NET attributes that attach metadata to declarations are a separate language feature.',
+    references: [
+      { title: 'Python class and instance attributes', url: 'https://docs.python.org/3/tutorial/classes.html' },
+    ],
   },
   constant: {
     definition: 'A named value or binding intended to remain fixed.',
-    detail: 'Enforcement depends on the language. A constant binding does not necessarily make the referenced object immutable or require the value to be known at compile time.',
-    references: [{ title: 'Julia constants', url: 'https://docs.julialang.org/en/v1/manual/variables-and-scoping/#Constants' }],
+    detail:
+      'Enforcement depends on the language. A constant binding does not necessarily make the referenced object immutable or require the value to be known at compile time.',
+    references: [
+      { title: 'Julia constants', url: 'https://docs.julialang.org/en/v1/manual/variables-and-scoping/#Constants' },
+    ],
   },
   typealias: {
     definition: 'A name for an existing type or type expression.',
-    detail: 'An alias can make a compound type easier to name. It does not by itself introduce a distinct runtime class.',
-    references: [{ title: 'TypeScript type aliases', url: 'https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-aliases' }],
+    detail:
+      'An alias can make a compound type easier to name. It does not by itself introduce a distinct runtime class.',
+    references: [
+      {
+        title: 'TypeScript type aliases',
+        url: 'https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#type-aliases',
+      },
+    ],
   },
   exception: {
     definition: 'A type used to report an error through the language’s exception mechanism.',
-    detail: 'The API documentation states when it can be raised or thrown and what a caller can catch. The label does not imply that every failure uses exceptions.',
+    detail:
+      'The API documentation states when it can be raised or thrown and what a caller can catch. The label does not imply that every failure uses exceptions.',
     references: [{ title: 'Python exceptions', url: 'https://docs.python.org/3/library/exceptions.html' }],
   },
   cmdlet: {
     definition: 'A compiled .NET command invoked through PowerShell’s command and object-pipeline system.',
-    detail: 'This label records PowerShell’s Cmdlet command type. Advanced script functions can offer similar parameter and pipeline features while retaining the Function command type. A cmdlet is not a standalone executable.',
+    detail:
+      'This label records PowerShell’s Cmdlet command type. Advanced script functions can offer similar parameter and pipeline features while retaining the Function command type. A cmdlet is not a standalone executable.',
     references: [
-      { title: 'PowerShell cmdlet overview', url: 'https://learn.microsoft.com/en-us/powershell/scripting/developer/cmdlet/cmdlet-overview' },
-      { title: 'PowerShell advanced functions', url: 'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions_advanced' },
+      {
+        title: 'PowerShell cmdlet overview',
+        url: 'https://learn.microsoft.com/en-us/powershell/scripting/developer/cmdlet/cmdlet-overview',
+      },
+      {
+        title: 'PowerShell advanced functions',
+        url: 'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_functions_advanced',
+      },
     ],
   },
 } satisfies Record<SymbolKind | 'cmdlet', Definition>
@@ -118,15 +163,20 @@ const kinds = {
 const modifiers = {
   static: {
     definition: 'A member associated with a type rather than bound to a particular instance.',
-    detail: 'A Python staticmethod receives neither an implicit instance nor an implicit class argument. A classmethod receives the class. Static does not mean pure, immutable, or safe for concurrent calls.',
+    detail:
+      'A Python staticmethod receives neither an implicit instance nor an implicit class argument. A classmethod receives the class. Static does not mean pure, immutable, or safe for concurrent calls.',
     references: [
-      { title: 'C# static members', url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/static' },
+      {
+        title: 'C# static members',
+        url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/static',
+      },
       { title: 'Python staticmethod', url: 'https://docs.python.org/3/library/functions.html#staticmethod' },
     ],
   },
   macro: {
     definition: 'A declaration expanded by a language’s macro mechanism rather than called as an ordinary function.',
-    detail: 'Julia macros transform expressions. C and C++ preprocessor macros operate on tokens. Expansion rules, evaluation, and invocation syntax differ.',
+    detail:
+      'Julia macros transform expressions. C and C++ preprocessor macros operate on tokens. Expansion rules, evaluation, and invocation syntax differ.',
     references: [
       { title: 'Julia macros', url: 'https://docs.julialang.org/en/v1/manual/metaprogramming/#man-macros' },
       { title: 'C++ macro replacement', url: 'https://eel.is/c++draft/cpp.replace' },
@@ -134,42 +184,62 @@ const modifiers = {
   },
   classmethod: {
     definition: 'A Python method that receives the calling class as its implicit first argument.',
-    detail: 'It can be called through a class or an instance. A call through a subclass passes that subclass, which is useful for constructors that preserve the requested type.',
+    detail:
+      'It can be called through a class or an instance. A call through a subclass passes that subclass, which is useful for constructors that preserve the requested type.',
     references: [{ title: 'Python classmethod', url: 'https://docs.python.org/3/library/functions.html#classmethod' }],
   },
   abstract: {
     definition: 'A type or member whose complete implementation is supplied by a concrete subtype.',
-    detail: 'An abstract type cannot be constructed directly. An abstract member declares required behavior. Julia abstract types define a place in the type hierarchy rather than a concrete data layout.',
+    detail:
+      'An abstract type cannot be constructed directly. An abstract member declares required behavior. Julia abstract types define a place in the type hierarchy rather than a concrete data layout.',
     references: [
-      { title: 'C# abstract declarations', url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract' },
+      {
+        title: 'C# abstract declarations',
+        url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/abstract',
+      },
       { title: 'Julia abstract types', url: 'https://docs.julialang.org/en/v1/manual/types/#Abstract-Types' },
     ],
   },
   async: {
     definition: 'An operation that participates in the language’s asynchronous or suspending execution model.',
-    detail: 'Use the await or coroutine mechanism required by the signature. Python async functions, .NET task-returning methods, and Kotlin suspend functions have different invocation rules. This label does not promise a new thread or parallel execution.',
+    detail:
+      'Use the await or coroutine mechanism required by the signature. Python async functions, .NET task-returning methods, and Kotlin suspend functions have different invocation rules. This label does not promise a new thread or parallel execution.',
     references: [
-      { title: 'Python coroutine functions', url: 'https://docs.python.org/3/reference/compound_stmts.html#coroutine-function-definition' },
-      { title: 'C# async methods', url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async' },
+      {
+        title: 'Python coroutine functions',
+        url: 'https://docs.python.org/3/reference/compound_stmts.html#coroutine-function-definition',
+      },
+      {
+        title: 'C# async methods',
+        url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/async',
+      },
       { title: 'Kotlin coroutines', url: 'https://kotlinlang.org/docs/coroutines-basics.html' },
     ],
   },
   readonly: {
     definition: 'A declaration with restrictions on assignment or mutation through the documented member.',
-    detail: 'The exact restriction depends on the language and declaration. The C++ extractor also uses this label for const-qualified methods. A read-only field or reference does not necessarily make the object it refers to deeply immutable.',
+    detail:
+      'The exact restriction depends on the language and declaration. The C++ extractor also uses this label for const-qualified methods. A read-only field or reference does not necessarily make the object it refers to deeply immutable.',
     references: [
-      { title: 'C# readonly', url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/readonly' },
+      {
+        title: 'C# readonly',
+        url: 'https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/readonly',
+      },
       { title: 'C++ cv-qualification', url: 'https://eel.is/c++draft/dcl.type.cv' },
     ],
   },
   deprecated: {
     definition: 'An API marked as discouraged for new use by its source documentation or language metadata.',
-    detail: 'Read the entry for its replacement and any removal schedule. Deprecation alone does not mean the API is absent or that calling it always emits a warning.',
-    references: [{ title: 'Python warning categories', url: 'https://docs.python.org/3/library/warnings.html#warning-categories' }],
+    detail:
+      'Read the entry for its replacement and any removal schedule. Deprecation alone does not mean the API is absent or that calling it always emits a warning.',
+    references: [
+      { title: 'Python warning categories', url: 'https://docs.python.org/3/library/warnings.html#warning-categories' },
+    ],
   },
   overload: {
     definition: 'An operation documented with more than one accepted signature.',
-    detail: 'The numbered badge reports the signatures shown by the reference. Python typing overloads describe one implementation to a type checker; other languages can select separate implementations. The badge does not define a common dispatch rule.',
+    detail:
+      'The numbered badge reports the signatures shown by the reference. Python typing overloads describe one implementation to a type checker; other languages can select separate implementations. The badge does not define a common dispatch rule.',
     references: [
       { title: 'Python typing overloads', url: 'https://docs.python.org/3/library/typing.html#typing.overload' },
       { title: 'Julia method dispatch', url: 'https://docs.julialang.org/en/v1/manual/methods/' },
@@ -177,22 +247,31 @@ const modifiers = {
   },
   private: {
     definition: 'A declaration whose intended or enforced accessibility is restricted.',
-    detail: 'The restriction may be a naming convention, a type-checking rule, or a runtime access rule. For example, TypeScript private and JavaScript #private have different enforcement. The badge alone is not a security boundary.',
-    references: [{ title: 'TypeScript private members', url: 'https://www.typescriptlang.org/docs/handbook/2/classes.html#private' }],
+    detail:
+      'The restriction may be a naming convention, a type-checking rule, or a runtime access rule. For example, TypeScript private and JavaScript #private have different enforcement. The badge alone is not a security boundary.',
+    references: [
+      {
+        title: 'TypeScript private members',
+        url: 'https://www.typescriptlang.org/docs/handbook/2/classes.html#private',
+      },
+    ],
   },
   generator: {
     definition: 'A callable that produces a generator or iterator, yielding values as iteration advances.',
-    detail: 'For a Python generator function, calling it creates the generator; iteration runs the body until the next yield. Reading every value can therefore execute work or raise errors later than the initial call.',
+    detail:
+      'For a Python generator function, calling it creates the generator; iteration runs the body until the next yield. Reading every value can therefore execute work or raise errors later than the initial call.',
     references: [{ title: 'Python generators', url: 'https://docs.python.org/3/glossary.html#term-generator' }],
   },
   unsafe: {
     definition: 'A Rust declaration that carries safety obligations the compiler cannot fully check.',
-    detail: 'For an unsafe function, the caller must uphold the documented invariants. For an unsafe trait, implementers must uphold its contract. Read the entry’s safety requirements before using or implementing it.',
+    detail:
+      'For an unsafe function, the caller must uphold the documented invariants. For an unsafe trait, implementers must uphold its contract. Read the entry’s safety requirements before using or implementing it.',
     references: [{ title: 'Rust unsafe', url: 'https://doc.rust-lang.org/reference/unsafe-keyword.html' }],
   },
   inherited: {
     definition: 'A member available on a type through a declaration supplied by a base type.',
-    detail: 'The reference identifies the declaring type. Follow that declaration for its signature and documentation; inheritance and overriding rules depend on the language.',
+    detail:
+      'The reference identifies the declaring type. Follow that declaration for its signature and documentation; inheritance and overriding rules depend on the language.',
     references: [{ title: 'Python inheritance', url: 'https://docs.python.org/3/tutorial/classes.html#inheritance' }],
   },
 } satisfies Record<Modifier | 'inherited', Definition>
@@ -200,8 +279,14 @@ const modifiers = {
 const context = {
   package: {
     definition: 'The library package that supplies the documented declaration.',
-    detail: 'The badge displays the package’s name rather than the word package. Package, import, module, and namespace names can differ; use the port’s installation and import instructions.',
-    references: [{ title: 'Python distribution and import packages', url: 'https://packaging.python.org/en/latest/discussions/distribution-package-vs-import-package/' }],
+    detail:
+      'The badge displays the package’s name rather than the word package. Package, import, module, and namespace names can differ; use the port’s installation and import instructions.',
+    references: [
+      {
+        title: 'Python distribution and import packages',
+        url: 'https://packaging.python.org/en/latest/discussions/distribution-package-vs-import-package/',
+      },
+    ],
   },
 } satisfies Record<'package', Definition>
 
@@ -210,51 +295,121 @@ export interface ApiGlossaryTerm extends Definition {
 }
 
 export const API_GLOSSARY_TITLE = 'API glossary'
-export const API_GLOSSARY_DESCRIPTION = 'What the kind, modifier, and package labels in the API reference mean, with language-specific distinctions.'
+export const API_GLOSSARY_DESCRIPTION =
+  'What the kind, modifier, and package labels in the API reference mean, with language-specific distinctions.'
 export const API_GLOSSARY_PATH = `${localeRoot(DEFAULT_LOCALE)}reference/glossary/`
 
 export const API_GLOSSARY_GROUPS: { id: string; title: string; description: string; terms: ApiGlossaryTerm[] }[] = [
-  { id: 'symbol-kinds', title: 'Symbol kinds', description: 'Kinds identify the declaration being documented. Some categories group equivalent language constructs under one label.', terms: Object.entries(kinds).map(([id, definition]) => ({ id, ...definition })) },
-  { id: 'modifiers', title: 'Modifiers', description: 'Modifiers add information about calling, implementing, or accessing a declaration. Their precise effect follows the language and the signature.', terms: Object.entries(modifiers).map(([id, definition]) => ({ id, ...definition })) },
-  { id: 'package-context', title: 'Package context', description: 'Package labels identify where an API is supplied.', terms: Object.entries(context).map(([id, definition]) => ({ id, ...definition })) },
+  {
+    id: 'symbol-kinds',
+    title: 'Symbol kinds',
+    description:
+      'Kinds identify the declaration being documented. Some categories group equivalent language constructs under one label.',
+    terms: Object.entries(kinds).map(([id, definition]) => ({ id, ...definition })),
+  },
+  {
+    id: 'modifiers',
+    title: 'Modifiers',
+    description:
+      'Modifiers add information about calling, implementing, or accessing a declaration. Their precise effect follows the language and the signature.',
+    terms: Object.entries(modifiers).map(([id, definition]) => ({ id, ...definition })),
+  },
+  {
+    id: 'package-context',
+    title: 'Package context',
+    description: 'Package labels identify where an API is supplied.',
+    terms: Object.entries(context).map(([id, definition]) => ({ id, ...definition })),
+  },
 ]
 
 export const MCP_GLOSSARY_TITLE = 'MCP API glossary'
 export const MCP_GLOSSARY_DESCRIPTION = 'What MCP tool annotations tell clients about a tool.'
-const annotationReference = [{ title: 'MCP ToolAnnotations', url: 'https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations' }]
-export const MCP_GLOSSARY_GROUPS: typeof API_GLOSSARY_GROUPS = [{
-  id: 'mcp-tool-annotations', title: 'MCP tool annotations',
-  description: 'These are server-supplied hints, not enforced guarantees. Clients must not base tool-use decisions on annotations from untrusted servers.',
-  terms: [
-    { id: 'readOnlyHint', definition: 'True indicates that the tool leaves its environment unchanged.', detail: 'Defaults to false when omitted.', references: annotationReference },
-    { id: 'destructiveHint', definition: 'True indicates potentially destructive changes; false indicates additive changes only.', detail: 'Defaults to true. Meaningful only when readOnlyHint is false.', references: annotationReference },
-    { id: 'idempotentHint', definition: 'True indicates that repeating a call with identical arguments adds no further effects.', detail: 'Defaults to false. Meaningful only when readOnlyHint is false. It does not promise identical responses.', references: annotationReference },
-    { id: 'openWorldHint', definition: 'True indicates possible interaction with external entities; false indicates a closed interaction domain.', detail: 'Defaults to true. This describes the interaction domain, not whether the tool writes data.', references: annotationReference },
-    { id: 'title', definition: 'A display title for the tool.', detail: 'The tool’s top-level title takes precedence, followed by annotations.title, then name.', references: annotationReference },
-  ],
-}]
+const annotationReference = [
+  {
+    title: 'MCP ToolAnnotations',
+    url: 'https://modelcontextprotocol.io/specification/2025-11-25/schema#toolannotations',
+  },
+]
+export const MCP_GLOSSARY_GROUPS: typeof API_GLOSSARY_GROUPS = [
+  {
+    id: 'mcp-tool-annotations',
+    title: 'MCP tool annotations',
+    description:
+      'These are server-supplied hints, not enforced guarantees. Clients must not base tool-use decisions on annotations from untrusted servers.',
+    terms: [
+      {
+        id: 'readOnlyHint',
+        definition: 'True indicates that the tool leaves its environment unchanged.',
+        detail: 'Defaults to false when omitted.',
+        references: annotationReference,
+      },
+      {
+        id: 'destructiveHint',
+        definition: 'True indicates potentially destructive changes; false indicates additive changes only.',
+        detail: 'Defaults to true. Meaningful only when readOnlyHint is false.',
+        references: annotationReference,
+      },
+      {
+        id: 'idempotentHint',
+        definition: 'True indicates that repeating a call with identical arguments adds no further effects.',
+        detail:
+          'Defaults to false. Meaningful only when readOnlyHint is false. It does not promise identical responses.',
+        references: annotationReference,
+      },
+      {
+        id: 'openWorldHint',
+        definition:
+          'True indicates possible interaction with external entities; false indicates a closed interaction domain.',
+        detail: 'Defaults to true. This describes the interaction domain, not whether the tool writes data.',
+        references: annotationReference,
+      },
+      {
+        id: 'title',
+        definition: 'A display title for the tool.',
+        detail: 'The tool’s top-level title takes precedence, followed by annotations.title, then name.',
+        references: annotationReference,
+      },
+    ],
+  },
+]
 export const ALL_GLOSSARY_GROUPS = [...API_GLOSSARY_GROUPS, ...MCP_GLOSSARY_GROUPS]
 const terms = new Map(ALL_GLOSSARY_GROUPS.flatMap((group) => group.terms.map((term) => [term.id, term] as const)))
 
 /** Unknown labels remain plain text rather than linking to an absent definition. */
 export function apiGlossaryHref(term: string, contextPath?: string): string | undefined {
   const mcp = contextPath?.match(/^(\/[^?#]*?\/([^/]+)\/[^/]+\/mcp\/)/)
-  const reference = mcp && PORT_BY_SLUG[mcp[2]] ? `${mcp[1]}reference/`
-    : contextPath?.match(/^(\/[^?#]*?\/reference\/|\/reference\/)/)?.[0]
+  const reference =
+    mcp && PORT_BY_SLUG[mcp[2]]
+      ? `${mcp[1]}reference/`
+      : contextPath?.match(/^(\/[^?#]*?\/reference\/|\/reference\/)/)?.[0]
   const port = reference?.match(/\/([^/]+)\/[^/]+\/(?:mcp\/|workspace\/)?reference\/$/)?.[1]
   const annotation = MCP_GLOSSARY_GROUPS.some((group) => group.terms.some((entry) => entry.id === term))
-  return terms.has(term) ? `${reference && port && PORT_BY_SLUG[port] && (!annotation || mcp) ? `${reference}glossary/` : API_GLOSSARY_PATH}#${term}` : undefined
+  return terms.has(term)
+    ? `${reference && port && PORT_BY_SLUG[port] && (!annotation || mcp) ? `${reference}glossary/` : API_GLOSSARY_PATH}#${term}`
+    : undefined
 }
 
 /** The Markdown twin uses the same definitions and references as the HTML page. */
 export function apiGlossaryMarkdown(origin: string): string {
   const body = ALL_GLOSSARY_GROUPS.flatMap((group) => [
-    `## ${group.title}`, '', group.description, '',
+    `## ${group.title}`,
+    '',
+    group.description,
+    '',
     ...group.terms.flatMap((term) => [
-      `### ${term.id}`, '', term.definition, '',
+      `### ${term.id}`,
+      '',
+      term.definition,
+      '',
       ...(term.detail ? [term.detail, ''] : []),
-      `References: ${term.references.map((ref) => `[${ref.title}](${ref.url})`).join('; ')}.`, '',
+      `References: ${term.references.map((ref) => `[${ref.title}](${ref.url})`).join('; ')}.`,
+      '',
     ]),
   ]).join('\n')
-  return markdownDocument({ title: API_GLOSSARY_TITLE, description: API_GLOSSARY_DESCRIPTION, url: new URL(API_GLOSSARY_PATH, origin).href, body })
+  return markdownDocument({
+    title: API_GLOSSARY_TITLE,
+    description: API_GLOSSARY_DESCRIPTION,
+    url: new URL(API_GLOSSARY_PATH, origin).href,
+    body,
+  })
 }
diff --git a/site/src/lib/api-labels.ts b/site/src/lib/api-labels.ts
index f890d0cec..e5435e607 100644
--- a/site/src/lib/api-labels.ts
+++ b/site/src/lib/api-labels.ts
@@ -2,9 +2,20 @@ import type { SymbolKind } from '@libtmux/api-model'
 
 /** Compact marks retain the documented kind, including module versus method. */
 const KIND_MARKS: Record<SymbolKind, string> = {
-  class: 'C', interface: 'I', struct: 'S', union: 'U', enum: 'E', trait: 'T',
-  module: 'M', function: 'f', method: 'm', property: 'p', attribute: 'a',
-  constant: 'k', typealias: 'A', exception: '!',
+  class: 'C',
+  interface: 'I',
+  struct: 'S',
+  union: 'U',
+  enum: 'E',
+  trait: 'T',
+  module: 'M',
+  function: 'f',
+  method: 'm',
+  property: 'p',
+  attribute: 'a',
+  constant: 'k',
+  typealias: 'A',
+  exception: '!',
 }
 
 const PROTOCOL_MARKS: Record<string, string> = { tool: 't', prompt: 'P', resource: 'r', 'resource-template': 'R' }
@@ -17,6 +28,11 @@ const FULL_NAMESPACE_LENGTH = 48
 export function abbreviateNamespace(namespace: string): string {
   if ([...namespaceSegments.segment(namespace)].length <= FULL_NAMESPACE_LENGTH) return namespace
   const parts = namespace.split(/(::|[./])/)
-  return parts.map((part, index) => index % 2 === 0 && index < parts.length - 1
-    ? namespaceSegments.segment(part)[Symbol.iterator]().next().value?.segment ?? '' : part).join('')
+  return parts
+    .map((part, index) =>
+      index % 2 === 0 && index < parts.length - 1
+        ? (namespaceSegments.segment(part)[Symbol.iterator]().next().value?.segment ?? '')
+        : part,
+    )
+    .join('')
 }
diff --git a/site/src/lib/api-models.ts b/site/src/lib/api-models.ts
index 118f48662..7f641afa1 100644
--- a/site/src/lib/api-models.ts
+++ b/site/src/lib/api-models.ts
@@ -1,4 +1,14 @@
-import { conceptsFor, parameterId, parentInventory, sourceUrl, SymbolIndex, type ApiModel, type ApiModelBase, type ApiSymbol, type InventoryEntry } from '@libtmux/api-model'
+import {
+  conceptsFor,
+  parameterId,
+  parentInventory,
+  sourceUrl,
+  SymbolIndex,
+  type ApiModel,
+  type ApiModelBase,
+  type ApiSymbol,
+  type InventoryEntry,
+} from '@libtmux/api-model'
 import mentionIndex from '../data/mentions.json'
 import domInv from '../data/inventories/dom.entries.json'
 import jdkInv from '../data/inventories/jdk.entries.json'
@@ -189,8 +199,9 @@ export function ownersOf(model: ApiModelBase) {
 /** The types the port index lists: top-level only, so nesting reads as nesting. */
 export function topLevelTypesOf(model: ApiModelBase) {
   const owners = new Set(ownersOf(model).map((symbol) => symbol.id))
-  return model.symbols.filter((s) => !s.parent && OWNER_KINDS.has(s.kind)
-    && (s.kind !== 'typealias' || owners.has(s.id)))
+  return model.symbols.filter(
+    (s) => !s.parent && OWNER_KINDS.has(s.kind) && (s.kind !== 'typealias' || owners.has(s.id)),
+  )
 }
 
 /**
@@ -213,7 +224,6 @@ export function pageSlug(id: string): string {
     .replace(/^-|-$/g, '')
 }
 
-
 /**
  * Inventories this site resolves external names against, intersphinx-style.
  *
@@ -256,7 +266,10 @@ const INVENTORIES: {
     project: 'MDN Web Docs',
   },
   ...dependencyInv.map((data) => ({
-    data, baseUrl: data.baseUrl, langs: data.langs, project: data.project,
+    data,
+    baseUrl: data.baseUrl,
+    langs: data.langs,
+    project: data.project,
   })),
 ]
 
@@ -285,12 +298,16 @@ const entriesOf = (inv: InventorySidecar): InventoryEntry[] =>
 /** Parent APIs used by a facade, at the parent's published default version. */
 export function parentApiInventory(port: string): InventoryEntry[] {
   const parent = PORT_BY_SLUG[port]?.parentLibrary
-  return parent ? parentInventory(API_MODELS[parent.slug],
-    (symbol) => referenceHref(parent.slug, symbol.publicId ?? symbol.id)!) : []
+  return parent
+    ? parentInventory(API_MODELS[parent.slug], (symbol) => referenceHref(parent.slug, symbol.publicId ?? symbol.id)!)
+    : []
 }
 
 /** Build an index with this site's language-scoped external inventories. */
-export function createApiIndex(model: ApiModelBase & { port?: string; language?: string }, hrefFor: (s: ApiSymbol) => string): SymbolIndex {
+export function createApiIndex(
+  model: ApiModelBase & { port?: string; language?: string },
+  hrefFor: (s: ApiSymbol) => string,
+): SymbolIndex {
   const index = new SymbolIndex(model.symbols, hrefFor, model.port ?? model.language)
   for (const { data, baseUrl, langs, project } of INVENTORIES) {
     index.addInventory(baseUrl, entriesOf(data), langs, project)
@@ -300,8 +317,12 @@ export function createApiIndex(model: ApiModelBase & { port?: string; language?:
     index.addInventory('', parentApiInventory(model.port), [model.port], `libtmux ${PORT_NAME[parent.slug]}`)
   }
   for (const dependency of (model.port ? PORT_BY_SLUG[model.port]?.apiDependencies : undefined) ?? []) {
-    index.addInventory('', parentInventory(API_MODELS[dependency],
-      (symbol) => referenceHref(dependency, symbol.publicId ?? symbol.id)!), [model.port!], `libtmux ${PORT_NAME[dependency]}`)
+    index.addInventory(
+      '',
+      parentInventory(API_MODELS[dependency], (symbol) => referenceHref(dependency, symbol.publicId ?? symbol.id)!),
+      [model.port!],
+      `libtmux ${PORT_NAME[dependency]}`,
+    )
   }
   const sourceFiles = new Map<string, Map<string, string>>()
   for (const symbol of model.symbols) {
@@ -324,7 +345,8 @@ export function createApiIndex(model: ApiModelBase & { port?: string; language?:
     entries.push({ name, uri: href.slice(base.length), type: 'std:label', priority: 1, dispname: '-' })
     filesByBase.set(base, entries)
   }
-  for (const [base, entries] of filesByBase) index.addInventory(base, entries, [model.port ?? model.language ?? ''], 'Source')
+  for (const [base, entries] of filesByBase)
+    index.addInventory(base, entries, [model.port ?? model.language ?? ''], 'Source')
   return index
 }
 
@@ -406,11 +428,14 @@ export function referenceAlternatives(port: string, publicId: string) {
       const target = API_MODELS[targetPort]?.symbols.find((symbol) => (symbol.publicId ?? symbol.id) === targetId)
       const href = targetId ? referenceHref(targetPort, targetId) : undefined
       // Switches name this cmdlet's parameters, not similarly named .NET types.
-      const note = target?.command && href
-        ? concept.notes?.[targetPort]?.replace(/`-([A-Za-z][A-Za-z0-9]*)`/g, (_, name: string) =>
-          target.signatures.some((signature) => signature.params.some((param) => param.name === name))
-            ? '[`-' + name + '`](' + href + '#' + encodeURIComponent(parameterId(target, name)) + ')' : `-${name}`)
-        : concept.notes?.[targetPort]
+      const note =
+        target?.command && href
+          ? concept.notes?.[targetPort]?.replace(/`-([A-Za-z][A-Za-z0-9]*)`/g, (_, name: string) =>
+              target.signatures.some((signature) => signature.params.some((param) => param.name === name))
+                ? '[`-' + name + '`](' + href + '#' + encodeURIComponent(parameterId(target, name)) + ')'
+                : `-${name}`,
+            )
+          : concept.notes?.[targetPort]
       return {
         port: targetPort,
         name,
diff --git a/site/src/lib/api-relationships.ts b/site/src/lib/api-relationships.ts
index 1b03c698f..564caa9f6 100644
--- a/site/src/lib/api-relationships.ts
+++ b/site/src/lib/api-relationships.ts
@@ -40,7 +40,10 @@ function catalogFor(model: ApiModelBase) {
 }
 function catalog(model: ApiModelBase) {
   let value = catalogs.get(model)
-  if (!value) { value = catalogFor(model); catalogs.set(model, value) }
+  if (!value) {
+    value = catalogFor(model)
+    catalogs.set(model, value)
+  }
   return value
 }
 
@@ -62,22 +65,48 @@ export function apiRelationshipSections(model: ApiModelBase, symbol: ApiSymbol):
   const calls = new Set(outgoing.filter((edge) => edge.kind === 'call').map((edge) => edge.to.id))
   const callers = new Set(incoming.filter((edge) => edge.kind === 'call').map((edge) => edge.from.id))
   const groups: ApiRelationshipSection[] = [
-    { id: 'api-called-by', label: 'Called by', items: incoming.filter((edge) => edge.kind === 'call').map((edge) => edge.from) },
+    {
+      id: 'api-called-by',
+      label: 'Called by',
+      items: incoming.filter((edge) => edge.kind === 'call').map((edge) => edge.from),
+    },
     { id: 'api-calls', label: 'Calls', items: outgoing.filter((edge) => edge.kind === 'call').map((edge) => edge.to) },
-    { id: 'api-function-references', label: 'Other function references', items: outgoing
-      .filter((edge) => edge.kind === 'reference' && edge.to.kind === 'function' && !calls.has(edge.to.id)).map((edge) => edge.to) },
-    { id: 'api-referenced-by', label: 'Referenced by', items: incoming
-      .filter((edge) => edge.kind === 'reference' && !callers.has(edge.from.id)).map((edge) => edge.from) },
-    { id: 'api-referenced-declarations', label: 'Referenced declarations', items: outgoing
-      .filter((edge) => edge.kind !== 'call' && edge.to.kind !== 'function').map((edge) => edge.to) },
+    {
+      id: 'api-function-references',
+      label: 'Other function references',
+      items: outgoing
+        .filter((edge) => edge.kind === 'reference' && edge.to.kind === 'function' && !calls.has(edge.to.id))
+        .map((edge) => edge.to),
+    },
+    {
+      id: 'api-referenced-by',
+      label: 'Referenced by',
+      items: incoming
+        .filter((edge) => edge.kind === 'reference' && !callers.has(edge.from.id))
+        .map((edge) => edge.from),
+    },
+    {
+      id: 'api-referenced-declarations',
+      label: 'Referenced declarations',
+      items: outgoing.filter((edge) => edge.kind !== 'call' && edge.to.kind !== 'function').map((edge) => edge.to),
+    },
   ]
-  return groups.map((group) => ({ ...group, items: [...new Map(group.items.map((item) => [item.id, item])).values()]
-    .sort((left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id)) }))
+  return groups
+    .map((group) => ({
+      ...group,
+      items: [...new Map(group.items.map((item) => [item.id, item])).values()].sort(
+        (left, right) => left.name.localeCompare(right.name) || left.id.localeCompare(right.id),
+      ),
+    }))
     .filter((group) => group.items.length > 0)
 }
 
 /** A reading path is available only when every edge exists in this version. */
-export function apiRelationshipPath(model: ApiModelBase, title: string, ids: string[]): ApiRelationshipPath | undefined {
+export function apiRelationshipPath(
+  model: ApiModelBase,
+  title: string,
+  ids: string[],
+): ApiRelationshipPath | undefined {
   const graph = catalog(model)
   const symbols = ids.map((id) => graph.symbols.get(id))
   if (symbols.length < 2 || symbols.some((symbol) => !symbol || symbol.kind !== 'function')) return undefined
diff --git a/site/src/lib/api-search.ts b/site/src/lib/api-search.ts
index 94f822fe1..91bf135fa 100644
--- a/site/src/lib/api-search.ts
+++ b/site/src/lib/api-search.ts
@@ -27,11 +27,18 @@ export interface ApiTreeJson {
   members: Record<string, [string, string, string?, string?, string?, string?, string?][]>
   /** Canonical destinations for declarations documented in another port. */
   hrefs?: Record<string, string>
-  relationships?: Record<string, { target: string; kind: 'type' | 'call' | 'reference'; sites?: { file: string; line: number }[] }[]>
+  relationships?: Record<
+    string,
+    { target: string; kind: 'type' | 'call' | 'reference'; sites?: { file: string; line: number }[] }[]
+  >
 }
 
 /** Initial markup, lazy branches and search use the same declaration URL. */
-export function apiTreeHref(base: string, entry: { id?: string; slug: string }, hrefs?: Record<string, string>): string {
+export function apiTreeHref(
+  base: string,
+  entry: { id?: string; slug: string },
+  hrefs?: Record<string, string>,
+): string {
   return (entry.id ? hrefs?.[entry.id] : undefined) ?? `${base}${entry.slug}/`
 }
 
@@ -46,10 +53,13 @@ export interface ApiSearchResult {
   summary: string
 }
 
-const words = (value: string) => value
-  .replace(/([a-z\d])([A-Z])/g, '$1 $2')
-  .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
-  .toLowerCase().split(/[^\p{L}\p{N}]+/u).filter(Boolean)
+const words = (value: string) =>
+  value
+    .replace(/([a-z\d])([A-Z])/g, '$1 $2')
+    .replace(/([A-Z])([A-Z][a-z])/g, '$1 $2')
+    .toLowerCase()
+    .split(/[^\p{L}\p{N}]+/u)
+    .filter(Boolean)
 
 /** Exact symbols lead; other matches retain the reference's semantic order. */
 export function searchApi(json: ApiTreeJson, query: string, category = 'all'): ApiSearchResult[] {
@@ -60,14 +70,29 @@ export function searchApi(json: ApiTreeJson, query: string, category = 'all'): A
     seen.add(entry.id)
     records.push(entry)
     for (const [name, slug, id, kind, category, summary, qualifiedName] of json.members[entry.id] ?? []) {
-      append({ name, symbolName: name, slug, id: id ?? `${entry.id}.${name}`, kind: kind ?? 'member',
-        category: category ?? 'members', summary: summary ?? '', qualifiedName: qualifiedName ?? id ?? `${entry.id}.${name}` })
+      append({
+        name,
+        symbolName: name,
+        slug,
+        id: id ?? `${entry.id}.${name}`,
+        kind: kind ?? 'member',
+        category: category ?? 'members',
+        summary: summary ?? '',
+        qualifiedName: qualifiedName ?? id ?? `${entry.id}.${name}`,
+      })
     }
   }
   const visit = (buckets: ApiTreeBucket[]) => {
     for (const bucket of buckets) {
-      for (const entry of bucket.types) append({ ...entry, symbolName: entry.symbolName ?? entry.name, kind: entry.kind ?? 'symbol',
-        category: entry.category ?? 'types', summary: entry.summary ?? '', qualifiedName: entry.qualifiedName ?? entry.id })
+      for (const entry of bucket.types)
+        append({
+          ...entry,
+          symbolName: entry.symbolName ?? entry.name,
+          kind: entry.kind ?? 'symbol',
+          category: entry.category ?? 'types',
+          summary: entry.summary ?? '',
+          qualifiedName: entry.qualifiedName ?? entry.id,
+        })
       visit(bucket.children)
     }
   }
@@ -77,18 +102,29 @@ export function searchApi(json: ApiTreeJson, query: string, category = 'all'): A
   const literal = query.trim().toLowerCase()
   const symbolic = /[.:/]/.test(query)
   const rank = (entry: ApiSearchResult) => {
-    if (entry.symbolName === query.trim() || entry.qualifiedName === query.trim() || entry.id === query.trim()) return -1
-    if (entry.symbolName.toLowerCase() === literal || entry.qualifiedName.toLowerCase() === literal || entry.id.toLowerCase() === literal) return 0
+    if (entry.symbolName === query.trim() || entry.qualifiedName === query.trim() || entry.id === query.trim())
+      return -1
+    if (
+      entry.symbolName.toLowerCase() === literal ||
+      entry.qualifiedName.toLowerCase() === literal ||
+      entry.id.toLowerCase() === literal
+    )
+      return 0
     if (phrase && words(entry.symbolName).join(' ') === phrase) return 1
     const identity = words(entry.qualifiedName).join(' ')
     if (terms.length > 1 && (identity === phrase || identity.endsWith(` ${phrase}`))) return 2
     return 3
   }
-  return records.filter((entry) => {
-    if (category !== 'all' && category !== entry.category) return false
-    if (literal && !terms.length) return `${entry.symbolName} ${entry.qualifiedName} ${entry.id}`.toLowerCase().includes(literal)
-    const tokens = words(`${entry.qualifiedName} ${entry.id} ${entry.name} ${entry.symbolName} ${symbolic ? '' : entry.summary}`)
-    const identity = words(entry.qualifiedName).join('')
-    return terms.every((term) => tokens.some((token) => token.startsWith(term)) || identity.includes(term))
-  }).sort((left, right) => rank(left) - rank(right))
+  return records
+    .filter((entry) => {
+      if (category !== 'all' && category !== entry.category) return false
+      if (literal && !terms.length)
+        return `${entry.symbolName} ${entry.qualifiedName} ${entry.id}`.toLowerCase().includes(literal)
+      const tokens = words(
+        `${entry.qualifiedName} ${entry.id} ${entry.name} ${entry.symbolName} ${symbolic ? '' : entry.summary}`,
+      )
+      const identity = words(entry.qualifiedName).join('')
+      return terms.every((term) => tokens.some((token) => token.startsWith(term)) || identity.includes(term))
+    })
+    .sort((left, right) => rank(left) - rank(right))
 }
diff --git a/site/src/lib/api-sections.ts b/site/src/lib/api-sections.ts
index 67e96ad71..d775e8b8a 100644
--- a/site/src/lib/api-sections.ts
+++ b/site/src/lib/api-sections.ts
@@ -1,5 +1,13 @@
 import { createHash } from 'node:crypto'
-import { builtinHref, memberTier, type ApiSymbol, type MemberSignals, type Param, type Signature, type SymbolIndex } from '@libtmux/api-model'
+import {
+  builtinHref,
+  memberTier,
+  type ApiSymbol,
+  type MemberSignals,
+  type Param,
+  type Signature,
+  type SymbolIndex,
+} from '@libtmux/api-model'
 import { apiGlossaryHref } from './api-glossary'
 
 export interface ApiSection {
@@ -17,13 +25,18 @@ export function signatureParameterText(param: Param, port?: string): string {
 
 export function signatureMultiline(symbol: ApiSymbol, signature: Signature, port?: string): boolean {
   const params = signature.params.map((param) => signatureParameterText(param, port)).join(', ')
-  return params.includes('\n') || (params.length > 0 && symbol.name.length + params.length + (signature.returns?.length ?? 0) + 6 > 88)
+  return (
+    params.includes('\n') ||
+    (params.length > 0 && symbol.name.length + params.length + (signature.returns?.length ?? 0) + 6 > 88)
+  )
 }
 
 /** Keep native declaration syntax consistent in HTML and copied Markdown. */
 export function usesNativeSignatures(symbol: ApiSymbol, port?: string): boolean {
-  return ['kotlin', 'scala', 'fsharp', 'c', 'powershell', 'julia'].includes(port ?? '') ||
+  return (
+    ['kotlin', 'scala', 'fsharp', 'c', 'powershell', 'julia'].includes(port ?? '') ||
     (port === 'cxx' && symbol.signatures.length > 0 && symbol.signatures.every((signature) => Boolean(signature.raw)))
+  )
 }
 
 /** Break only the outer argument list; Julia types and defaults can contain commas. */
@@ -38,16 +51,27 @@ function juliaSignatureText(raw: string): string {
     const frame = stack.at(-1)
     if (frame?.interpolate !== undefined) {
       if (char === '\\') i++
-      else if (raw.startsWith(frame.delimiter, i)) { stack.pop(); i += frame.delimiter.length - 1 }
+      else if (raw.startsWith(frame.delimiter, i)) {
+        stack.pop()
+        i += frame.delimiter.length - 1
+      }
       // Interpolation may contain nested strings, calls and punctuation.
-      else if (frame.interpolate && raw.startsWith('$(', i)) { stack.push({ delimiter: ')' }); i++ }
+      else if (frame.interpolate && raw.startsWith('$(', i)) {
+        stack.push({ delimiter: ')' })
+        i++
+      }
       continue
     }
     if (raw.startsWith('#=', i)) {
       let depth = 1
       for (i += 2; i < raw.length && depth; i++) {
-        if (raw.startsWith('#=', i)) { depth++; i++ }
-        else if (raw.startsWith('=#', i)) { depth--; i++ }
+        if (raw.startsWith('#=', i)) {
+          depth++
+          i++
+        } else if (raw.startsWith('=#', i)) {
+          depth--
+          i++
+        }
       }
       i--
       continue
@@ -69,20 +93,34 @@ function juliaSignatureText(raw: string): string {
       const prefix = raw.slice(0, i)
       const word = /[\p{L}\p{N}\p{M}\p{Pc}!]+$/u.exec(prefix)?.[0]
       // Julia permits adjacent literals after prefix keywords, e.g. return')'.
-      const keyword = word && /^(?:baremodule|begin|break|const|continue|do|export|for|function|global|if|import|let|local|macro|module|quote|return|struct|try|using|while|catch|finally|else|elseif)$/.test(word)
+      const keyword =
+        word &&
+        /^(?:baremodule|begin|break|const|continue|do|export|for|function|global|if|import|let|local|macro|module|quote|return|struct|try|using|while|catch|finally|else|elseif)$/.test(
+          word,
+        )
       if ((word && !keyword) || /[)\]}'"`.]$/.test(prefix)) continue
       const literal = /^'(?:\\(?:[0-7]{1,3}|[xuU][0-9a-fA-F]+|.)|[^'\\])'/u.exec(raw.slice(i))
-      if (literal) { i += literal[0].length - 1; continue }
+      if (literal) {
+        i += literal[0].length - 1
+        continue
+      }
     }
     if (char === '(' || char === '[' || char === '{') {
-      if (!stack.length && char === '(') { open = i; start = i + 1; parts = [] }
+      if (!stack.length && char === '(') {
+        open = i
+        start = i + 1
+        parts = []
+      }
       stack.push({ delimiter: char === '(' ? ')' : char === '[' ? ']' : '}' })
     } else if (char === ')' || char === ']' || char === '}') {
       if (frame?.delimiter !== char) return raw
       stack.pop()
       if (!stack.length && open >= 0) {
         // Callable receivers and quoted operator names precede the argument list.
-        if (/^\s*\(/.test(raw.slice(i + 1))) { open = -1; continue }
+        if (/^\s*\(/.test(raw.slice(i + 1))) {
+          open = -1
+          continue
+        }
         const last = raw.slice(start, i).trim()
         if (last) parts.push(last)
         if (!parts.length) return raw
@@ -106,10 +144,12 @@ export function nativeSignatureText(symbol: ApiSymbol, signature: Signature, lan
 
 function signatureLabels(symbol: ApiSymbol, port?: string): string[] {
   const name = port === 'swift' ? symbol.name.replace(/\([^)]*\)$/, '') : symbol.name
-  const labels = symbol.signatures.map((signature) =>
-    signature.label ?? `${name}(${signature.params.map((param) => param.name).join(', ')})`)
-  return labels.map((label, i) => labels.filter((entry) => entry === label).length > 1
-    ? `${label} [overload ${i + 1}]` : label)
+  const labels = symbol.signatures.map(
+    (signature) => signature.label ?? `${name}(${signature.params.map((param) => param.name).join(', ')})`,
+  )
+  return labels.map((label, i) =>
+    labels.filter((entry) => entry === label).length > 1 ? `${label} [overload ${i + 1}]` : label,
+  )
 }
 
 /** The fields shown by ApiEntry, shared with its section navigation. */
@@ -118,8 +158,8 @@ export function apiEntryFields(symbol: ApiSymbol, port?: string) {
   const labels = signatureLabels(symbol, port)
   // Python's extractor merges @overload stubs followed by their implementation.
   // The implementation docstring documents the complete callable, not one stub.
-  const familyDocumentation = port === 'py' && !symbol.modifiers.includes('overload')
-    ? symbol.signatures.length - 1 : -1
+  const familyDocumentation =
+    port === 'py' && !symbol.modifiers.includes('overload') ? symbol.signatures.length - 1 : -1
   const collect = <T>(read: (signature: Signature) => T[]) => {
     const fields = new Map<string, { value: T; signatures: Set<number> }>()
     symbol.signatures.forEach((signature, i) => {
@@ -132,13 +172,15 @@ export function apiEntryFields(symbol: ApiSymbol, port?: string) {
     })
     return [...fields.values()].map(({ value, signatures }) => ({
       ...value,
-      overloads: signatures.size < symbol.signatures.length && !signatures.has(familyDocumentation)
-        ? [...signatures].map((i) => labels[i]) : [],
+      overloads:
+        signatures.size < symbol.signatures.length && !signatures.has(familyDocumentation)
+          ? [...signatures].map((i) => labels[i])
+          : [],
     }))
   }
   return {
     params: collect((signature) => signature.params.filter((param) => native || param.doc)),
-    returns: collect((signature) => signature.returnsDoc ? [{ doc: signature.returnsDoc }] : []),
+    returns: collect((signature) => (signature.returnsDoc ? [{ doc: signature.returnsDoc }] : [])),
     raises: collect((signature) => signature.raises ?? []),
   }
 }
@@ -162,12 +204,18 @@ export function apiEntrySections(symbol: ApiSymbol, port?: string): ApiSection[]
 /** Dispatch methods retain their own documentation and stable fragment identities. */
 export function apiMethodDetails(symbol: ApiSymbol) {
   const labels = signatureLabels(symbol)
-  return symbol.signatures.flatMap((signature, i) => signature.methodKind ? [{
-    signature,
-    id: `${symbol.publicId ?? symbol.id}.method-${createHash('sha256').update(signature.identity!).digest('hex').slice(0, 16)}`,
-    label: signature.raw ?? signature.label ?? symbol.name,
-    overloadLabel: labels[i],
-  }] : [])
+  return symbol.signatures.flatMap((signature, i) =>
+    signature.methodKind
+      ? [
+          {
+            signature,
+            id: `${symbol.publicId ?? symbol.id}.method-${createHash('sha256').update(signature.identity!).digest('hex').slice(0, 16)}`,
+            label: signature.raw ?? signature.label ?? symbol.name,
+            overloadLabel: labels[i],
+          },
+        ]
+      : [],
+  )
 }
 
 /** The same native command facts appear in HTML and copied Markdown. */
@@ -175,15 +223,33 @@ export function apiCommandFacts(symbol: ApiSymbol, contextPath?: string): { labe
   const command = symbol.command
   if (!command) return []
   const kindHelp = apiGlossaryHref(command.kind, contextPath)
-  const facts: { label: string; value: string }[] = [{ label: 'Command type', value: kindHelp ? `[\`${command.kind}\`](${kindHelp})` : `\`${command.kind}\`` }]
-  if (command.defaultParameterSet && command.defaultParameterSet !== '__AllParameterSets') facts.push({ label: 'Default parameter set', value: command.defaultParameterSet })
-  if (command.aliases.length) facts.push({ label: 'Aliases', value: command.aliases.map((alias) => `\`${alias}\``).join(', ') })
-  if (command.supportsShouldProcess) facts.push({ label: 'Confirmation', value: `Supports \`-WhatIf\` and \`-Confirm\`; confirm impact: ${command.confirmImpact}.` })
+  const facts: { label: string; value: string }[] = [
+    { label: 'Command type', value: kindHelp ? `[\`${command.kind}\`](${kindHelp})` : `\`${command.kind}\`` },
+  ]
+  if (command.defaultParameterSet && command.defaultParameterSet !== '__AllParameterSets')
+    facts.push({ label: 'Default parameter set', value: command.defaultParameterSet })
+  if (command.aliases.length)
+    facts.push({ label: 'Aliases', value: command.aliases.map((alias) => `\`${alias}\``).join(', ') })
+  if (command.supportsShouldProcess)
+    facts.push({
+      label: 'Confirmation',
+      value: `Supports \`-WhatIf\` and \`-Confirm\`; confirm impact: ${command.confirmImpact}.`,
+    })
   if (command.supportsPaging) facts.push({ label: 'Paging', value: 'Supports paging parameters.' })
   if (command.supportsTransactions) facts.push({ label: 'Transactions', value: 'Supports transactions.' })
-  facts.push({ label: 'Positional binding', value: command.positionalBinding ? 'Enabled.' : 'Disabled; use named parameters unless a position is declared.' })
-  if (command.inputTypes.length) facts.push({ label: 'Pipeline inputs', value: command.inputTypes.map((entry) => `\`${entry.type}\`${entry.description ? `: ${entry.description}` : ''}`).join('; ') })
-  if (command.outputTypes.length) facts.push({ label: 'Outputs', value: command.outputTypes.map((type) => `\`${type}\``).join(', ') })
+  facts.push({
+    label: 'Positional binding',
+    value: command.positionalBinding ? 'Enabled.' : 'Disabled; use named parameters unless a position is declared.',
+  })
+  if (command.inputTypes.length)
+    facts.push({
+      label: 'Pipeline inputs',
+      value: command.inputTypes
+        .map((entry) => `\`${entry.type}\`${entry.description ? `: ${entry.description}` : ''}`)
+        .join('; '),
+    })
+  if (command.outputTypes.length)
+    facts.push({ label: 'Outputs', value: command.outputTypes.map((type) => `\`${type}\``).join(', ') })
   return facts
 }
 
@@ -191,18 +257,29 @@ export function apiCommandFacts(symbol: ApiSymbol, contextPath?: string): { labe
 export function apiCommandRelatedLinks(symbol: ApiSymbol, index?: SymbolIndex) {
   const links = (symbol.command?.relatedLinks ?? []).flatMap((link) => {
     if (!link.href) return []
-    const native = /^https:\/\/github\.com\/libtmux\/libtmux-powershell\/blob\/[^/]+\/docs\/reference\/([^/]+)\/([^/]+)\.md$/.exec(link.href)
+    const native =
+      /^https:\/\/github\.com\/libtmux\/libtmux-powershell\/blob\/[^/]+\/docs\/reference\/([^/]+)\/([^/]+)\.md$/.exec(
+        link.href,
+      )
     const target = native ? index?.resolve(`${native[1]}\\${native[2]}`, 'any', symbol) : undefined
     if (target?.symbol?.id === symbol.id) return []
-    return [{ text: target?.symbol?.name ?? link.text ?? link.href,
-      href: target?.symbol ? target.href : link.href, symbol: target?.symbol }]
+    return [
+      {
+        text: target?.symbol?.name ?? link.text ?? link.href,
+        href: target?.symbol ? target.href : link.href,
+        symbol: target?.symbol,
+      },
+    ]
   })
   return links.filter((link, i) => links.findIndex((entry) => entry.href === link.href) === i)
 }
 
 /** Preserve the reflected attribute type even when its display name is short. */
 function parameterAttributeText(attribute: NonNullable<Param['binding']>['attributes'][number]): string {
-  const name = attribute.type.split('.').at(-1)!.replace(/Attribute$/, '')
+  const name = attribute.type
+    .split('.')
+    .at(-1)!
+    .replace(/Attribute$/, '')
   const call = `${name}(${attribute.arguments.map((value) => JSON.stringify(value)).join(', ')})`
   const fence = '`'.repeat(Math.max(1, ...[...call.matchAll(/`+/g)].map((match) => match[0].length + 1)))
   const label = `${fence}${call}${fence}`
@@ -213,16 +290,24 @@ function parameterAttributeText(attribute: NonNullable<Param['binding']>['attrib
 export function parameterBindingText(param: Param): string | undefined {
   const binding = param.binding
   if (!binding) return undefined
-  const facts = [binding.mandatory ? 'Required.' : 'Optional.', binding.position === undefined ? 'Named parameter.' : `Position ${binding.position}.`]
+  const facts = [
+    binding.mandatory ? 'Required.' : 'Optional.',
+    binding.position === undefined ? 'Named parameter.' : `Position ${binding.position}.`,
+  ]
   if (binding.switch) facts.push('Switch parameter.')
   if (binding.common) facts.push('Common parameter.')
   if (binding.dynamic) facts.push('Dynamic parameter.')
-  const pipeline = [binding.pipeline.byValue && 'by value', binding.pipeline.byPropertyName && 'by property name'].filter(Boolean)
+  const pipeline = [
+    binding.pipeline.byValue && 'by value',
+    binding.pipeline.byPropertyName && 'by property name',
+  ].filter(Boolean)
   facts.push(pipeline.length ? `Accepts pipeline input ${pipeline.join(' and ')}.` : 'Does not accept pipeline input.')
   if (binding.pipeline.remainingArguments) facts.push('Accepts remaining arguments.')
   if (binding.aliases.length) facts.push(`Aliases: ${binding.aliases.map((alias) => `\`${alias}\``).join(', ')}.`)
   if (binding.documentedDefault) facts.push(`Documented default: \`${binding.documentedDefault}\`.`)
-  for (const attribute of binding.attributes.filter((entry) => /\.(Validate\w+|ArgumentCompleter)Attribute$/.test(entry.type))) {
+  for (const attribute of binding.attributes.filter((entry) =>
+    /\.(Validate\w+|ArgumentCompleter)Attribute$/.test(entry.type),
+  )) {
     facts.push(`${parameterAttributeText(attribute)}.`)
   }
   return facts.join(' ')
@@ -243,14 +328,23 @@ export function parameterBindingFacts(param: Param): { label: string; value: str
   if (b.pipeline.remainingArguments) facts.push({ label: 'Remaining arguments', value: 'Yes' })
   if (b.aliases.length) facts.push({ label: 'Aliases', value: b.aliases.map((alias) => `\`${alias}\``).join(', ') })
   if (b.documentedDefault) facts.push({ label: 'Default', value: `\`${b.documentedDefault}\`` })
-  for (const attribute of b.attributes.filter((entry) => /\.(Validate\w+|ArgumentCompleter)Attribute$/.test(entry.type))) {
-    const name = attribute.type.split('.').at(-1)!.replace(/Attribute$/, '')
-    facts.push({ label: name === 'ArgumentCompleter' ? 'Completion' : 'Validation', value: parameterAttributeText(attribute) })
+  for (const attribute of b.attributes.filter((entry) =>
+    /\.(Validate\w+|ArgumentCompleter)Attribute$/.test(entry.type),
+  )) {
+    const name = attribute.type
+      .split('.')
+      .at(-1)!
+      .replace(/Attribute$/, '')
+    facts.push({
+      label: name === 'ArgumentCompleter' ? 'Completion' : 'Validation',
+      value: parameterAttributeText(attribute),
+    })
   }
   return facts
 }
 
-export const POWER_SHELL_COMMON_HELP = 'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_commonparameters?view=powershell-7.4'
+export const POWER_SHELL_COMMON_HELP =
+  'https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_commonparameters?view=powershell-7.4'
 
 /** Group the existing semantic order without sorting or omitting members. */
 export function apiMemberGroups(members: ApiSymbol[], signals: MemberSignals) {
@@ -262,18 +356,36 @@ export function apiMemberGroups(members: ApiSymbol[], signals: MemberSignals) {
   ]
   for (const member of members) {
     const tier = memberTier(member, signals)
-    const group = tier === 'parent' ? 0 : tier === 'listing' || tier === 'query' ? 1 : tier === 'concept' || tier === 'discussed' ? 2 : 3
+    const group =
+      tier === 'parent'
+        ? 0
+        : tier === 'listing' || tier === 'query'
+          ? 1
+          : tier === 'concept' || tier === 'discussed'
+            ? 2
+            : 3
     groups[group].members.push(member)
   }
   return groups.filter((group) => group.members.length > 0)
 }
 
 /** Related declarations come from ownership, inheritance and return types. */
-export function relatedApiTypes(owner: ApiSymbol, members: ApiSymbol[], index: SymbolIndex, parent?: ApiSymbol, options: { includeInternal?: boolean } = {}) {
+export function relatedApiTypes(
+  owner: ApiSymbol,
+  members: ApiSymbol[],
+  index: SymbolIndex,
+  parent?: ApiSymbol,
+  options: { includeInternal?: boolean } = {},
+) {
   const types = new Map<string, ApiSymbol>()
   const add = (symbol?: ApiSymbol) => {
-    if (!symbol || symbol.id === owner.id || (!options.includeInternal && symbol.apiScope === 'internal') ||
-        !['class', 'struct', 'union', 'interface', 'trait', 'enum', 'typealias'].includes(symbol.kind)) return
+    if (
+      !symbol ||
+      symbol.id === owner.id ||
+      (!options.includeInternal && symbol.apiScope === 'internal') ||
+      !['class', 'struct', 'union', 'interface', 'trait', 'enum', 'typealias'].includes(symbol.kind)
+    )
+      return
     types.set(symbol.publicId ?? symbol.id, symbol)
   }
   add(parent)
@@ -285,7 +397,10 @@ export function relatedApiTypes(owner: ApiSymbol, members: ApiSymbol[], index: S
       for (const span of index.linkType(symbol.type, symbol)) add(span.link?.symbol)
     }
     for (const signature of symbol.signatures) {
-      for (const type of [signature.returns, ...(options.includeInternal ? signature.params.map((param) => param.type) : [])]) {
+      for (const type of [
+        signature.returns,
+        ...(options.includeInternal ? signature.params.map((param) => param.type) : []),
+      ]) {
         if (type) for (const span of index.linkType(type, symbol)) add(span.link?.symbol)
       }
     }
diff --git a/site/src/lib/api-tree.ts b/site/src/lib/api-tree.ts
index e9cd8f800..cb5bbc908 100644
--- a/site/src/lib/api-tree.ts
+++ b/site/src/lib/api-tree.ts
@@ -5,9 +5,27 @@
  * Buckets and their contents are decided once per port in
  * `scripts/gen-api-model.mjs`; this only shapes them for a tree.
  */
-import { membersOf, memberSignals, qualifiedNameOf, symbolsForProduct, type ApiModel, type ApiModelBase, type ApiSymbol } from '@libtmux/api-model'
+import {
+  membersOf,
+  memberSignals,
+  qualifiedNameOf,
+  symbolsForProduct,
+  type ApiModel,
+  type ApiModelBase,
+  type ApiSymbol,
+} from '@libtmux/api-model'
 import mentions from '../data/mentions.json'
-import { API_MODELS, API_NAV, OWNER_KINDS, pageSlug, referenceHref, topLevelTypesOf, type NavEntry, type PortNavData, type NavBucket } from './api-models'
+import {
+  API_MODELS,
+  API_NAV,
+  OWNER_KINDS,
+  pageSlug,
+  referenceHref,
+  topLevelTypesOf,
+  type NavEntry,
+  type PortNavData,
+  type NavBucket,
+} from './api-models'
 import type { ApiTreeBucket, ApiTreeJson } from './api-search'
 import { createHash } from 'node:crypto'
 import { PORT_BY_SLUG, type ApiDependencyNavigation } from './ports'
@@ -33,7 +51,10 @@ const treeVersions = new WeakMap<ApiModelBase, string>()
 export function apiTreeVersion(model: ApiModelBase, tree: TreeBucket[], hrefs?: Record<string, string>): string {
   let version = treeVersions.get(model)
   if (!version) {
-    version = `2:${createHash('sha256').update(JSON.stringify([model, tree, hrefs, mentions])).digest('hex').slice(0, 20)}`
+    version = `2:${createHash('sha256')
+      .update(JSON.stringify([model, tree, hrefs, mentions]))
+      .digest('hex')
+      .slice(0, 20)}`
     treeVersions.set(model, version)
   }
   return version
@@ -47,7 +68,11 @@ export interface NavTreeOptions {
 }
 
 /** Use a declaration's curated bucket before falling back to its nearest owner. */
-export function bucketForSymbol(model: ApiModelBase | undefined, nav: PortNavData | undefined, symbol: ApiSymbol | undefined): string | undefined {
+export function bucketForSymbol(
+  model: ApiModelBase | undefined,
+  nav: PortNavData | undefined,
+  symbol: ApiSymbol | undefined,
+): string | undefined {
   const seen = new Set<string>()
   while (symbol && !seen.has(symbol.id)) {
     seen.add(symbol.id)
@@ -59,8 +84,10 @@ export function bucketForSymbol(model: ApiModelBase | undefined, nav: PortNavDat
   return undefined
 }
 
-const productSymbols = (model: ApiModelBase) =>
-  [...symbolsForProduct(model, 'mcp'), ...symbolsForProduct(model, 'workspace')]
+const productSymbols = (model: ApiModelBase) => [
+  ...symbolsForProduct(model, 'mcp'),
+  ...symbolsForProduct(model, 'workspace'),
+]
 
 /**
  * A bucket's rows, with a name that repeats among them shown as its id.
@@ -74,9 +101,10 @@ const distinct = (entries: NavEntry[], model: ApiModelBase, scope: string): NavE
   for (const e of entries) count.set(e.name, (count.get(e.name) ?? 0) + 1)
   return entries.map((entry) => {
     if ((count.get(entry.name) ?? 0) < 2) return entry
-    const label = scope === 'scala'
-      ? `${entry.name} (${entry.id.includes('.cats.') ? 'Cats Effect' : entry.id.includes('.ox.') ? 'Ox' : 'Direct API'})`
-      : model.symbols.find((symbol) => (symbol.publicId ?? symbol.id) === entry.id)?.qualifiedName ?? entry.id
+    const label =
+      scope === 'scala'
+        ? `${entry.name} (${entry.id.includes('.cats.') ? 'Cats Effect' : entry.id.includes('.ox.') ? 'Ox' : 'Direct API'})`
+        : (model.symbols.find((symbol) => (symbol.publicId ?? symbol.id) === entry.id)?.qualifiedName ?? entry.id)
     return { ...entry, name: label }
   })
 }
@@ -131,9 +159,7 @@ export function navTreeFor(model: ApiModelBase, nav: PortNavData, options: NavTr
   // MCP declaration has a page in its own package's reference, so a row for
   // it here would point out of this tree — and did, at a URL that no longer
   // exists.
-  const products = new Set(options.excludeProducts
-    ? productSymbols(model).map((s) => s.publicId ?? s.id)
-    : [])
+  const products = new Set(options.excludeProducts ? productSymbols(model).map((s) => s.publicId ?? s.id) : [])
   const core = (entries: NavEntry[]) => entries.filter((e) => !products.has(e.id))
   const displayEntries = (bucket: { id: string; label: string }, entries: NavEntry[]) => {
     const distinctEntries = distinct(core(entries), model, options.scope ?? '')
@@ -151,10 +177,17 @@ export function navTreeFor(model: ApiModelBase, nav: PortNavData, options: NavTr
     children: (b.children ?? []).map(bucket).filter((child) => child.entries.length > 0 || child.children.length > 0),
   })
   return [
-    ...nav.buckets.map(bucket)
-      .filter((b) => b.entries.length > 0 || b.children.length > 0),
+    ...nav.buckets.map(bucket).filter((b) => b.entries.length > 0 || b.children.length > 0),
     ...(nav.unplaced.length > 0
-      ? [{ id: '__unplaced', label: 'Other', collapsed: true, entries: displayEntries({ id: '__unplaced', label: 'Other' }, nav.unplaced), children: [] }]
+      ? [
+          {
+            id: '__unplaced',
+            label: 'Other',
+            collapsed: true,
+            entries: displayEntries({ id: '__unplaced', label: 'Other' }, nav.unplaced),
+            children: [],
+          },
+        ]
       : []),
   ]
 }
@@ -170,13 +203,20 @@ export function referenceIndexSections(port: string) {
 export function referenceIndexSectionsFor(model: ApiModelBase, tree: TreeBucket[]) {
   const cards = new Set(topLevelTypesOf(model).map((symbol) => symbol.id))
   const modules = new Set(model.symbols.filter((symbol) => symbol.kind === 'module').map((symbol) => symbol.id))
-  const symbols = new Map(model.symbols.filter((symbol) => !symbol.parent || modules.has(symbol.parent))
-    .map((symbol) => [symbol.publicId ?? symbol.id, symbol]))
+  const symbols = new Map(
+    model.symbols
+      .filter((symbol) => !symbol.parent || modules.has(symbol.parent))
+      .map((symbol) => [symbol.publicId ?? symbol.id, symbol]),
+  )
   const section = (bucket: TreeBucket, name: string, collapsed: boolean) => {
-    const entries = bucket.entries.filter((entry) => !entry.shortcut).map((entry) => symbols.get(entry.id))
+    const entries = bucket.entries
+      .filter((entry) => !entry.shortcut)
+      .map((entry) => symbols.get(entry.id))
       .filter((symbol): symbol is NonNullable<typeof symbol> => symbol !== undefined)
     return {
-      id: bucket.id, name, collapsed,
+      id: bucket.id,
+      name,
+      collapsed,
       types: entries.filter((symbol) => cards.has(symbol.id)),
       free: entries.filter((symbol) => !cards.has(symbol.id)),
     }
@@ -185,7 +225,8 @@ export function referenceIndexSectionsFor(model: ApiModelBase, tree: TreeBucket[
     section(bucket, label, collapsed),
     ...bucket.children.flatMap((child) => sections(child, `${label} — ${child.label}`, collapsed || child.collapsed)),
   ]
-  return tree.flatMap((bucket) => sections(bucket, bucket.label, bucket.collapsed))
+  return tree
+    .flatMap((bucket) => sections(bucket, bucket.label, bucket.collapsed))
     .filter((entry) => entry.types.length || entry.free.length)
 }
 
@@ -200,7 +241,13 @@ export const bucketTotal = (b: TreeBucket): number =>
  * still counts, so Go's Window opens `tmux.Window` before `workspace.Window`.
  */
 export const bucketTarget = <T extends { name: string; slug: string }>(label: string, entries: T[]) =>
-  entries.find((e) => e.name.split(/[.:/]+/).pop()?.toLowerCase() === label.toLowerCase()) ?? entries[0]
+  entries.find(
+    (e) =>
+      e.name
+        .split(/[.:/]+/)
+        .pop()
+        ?.toLowerCase() === label.toLowerCase(),
+  ) ?? entries[0]
 
 /**
  * The entry a bucket's link lands on: a type, from the bucket itself or else
@@ -212,7 +259,9 @@ export const firstEntry = (b: TreeBucket) => {
   if (b.target) return b.target
   const lists = (bucket: TreeBucket): NavEntry[][] => [bucket.entries, ...bucket.children.flatMap(lists)]
   const entries = lists(b)
-  const types = entries.map((list) => list.filter((entry) => OWNER_KINDS.has(entry.kind))).find((list) => list.length > 0)
+  const types = entries
+    .map((list) => list.filter((entry) => OWNER_KINDS.has(entry.kind)))
+    .find((list) => list.length > 0)
   return bucketTarget(b.label, types ?? entries.find((list) => list.length > 0) ?? [])
 }
 
@@ -234,9 +283,15 @@ export function membersByTypeFor(scope: string, model: ApiModelBase): Map<string
   const signals = memberSignals(scope, mentions.mentions)
   for (const owner of model.symbols.filter((symbol) => OWNER_KINDS.has(symbol.kind))) {
     const members = membersOf(model, owner, signals)
-    if (members.length) out.set(owner.publicId ?? owner.id, members.map((symbol) => ({
-      id: symbol.id, name: symbol.name, slug: symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id),
-    })))
+    if (members.length)
+      out.set(
+        owner.publicId ?? owner.id,
+        members.map((symbol) => ({
+          id: symbol.id,
+          name: symbol.name,
+          slug: symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id),
+        })),
+      )
   }
   return out
 }
@@ -255,15 +310,27 @@ export interface ReferenceNavigation {
 }
 
 /** Reject dependency navigation when its reviewed package or source changes. */
-export function validateNavigationDependency(consumer: ApiModel, dependency: ApiModel, selection: ApiDependencyNavigation): void {
+export function validateNavigationDependency(
+  consumer: ApiModel,
+  dependency: ApiModel,
+  selection: ApiDependencyNavigation,
+): void {
   const declaration = consumer.nativeProvenance?.files.find((file) => file.path === selection.declaration.path)
   const source = dependency.sources?.find((entry) => entry.product === 'core' && entry.package === selection.package)
   if (declaration?.sha256 !== selection.declaration.sha256) {
-    throw new Error(`${consumer.port} navigation: review the changed ${selection.declaration.path} dependency declaration`)
+    throw new Error(
+      `${consumer.port} navigation: review the changed ${selection.declaration.path} dependency declaration`,
+    )
   }
-  if (dependency.port !== selection.port || source?.version !== selection.version ||
-    dependency.revision !== selection.revision || (source?.extractedRevision ?? source?.revision) !== selection.revision) {
-    throw new Error(`${consumer.port} navigation requires ${selection.package} ${selection.version} from ${selection.revision}`)
+  if (
+    dependency.port !== selection.port ||
+    source?.version !== selection.version ||
+    dependency.revision !== selection.revision ||
+    (source?.extractedRevision ?? source?.revision) !== selection.revision
+  ) {
+    throw new Error(
+      `${consumer.port} navigation requires ${selection.package} ${selection.version} from ${selection.revision}`,
+    )
   }
 }
 
@@ -279,7 +346,10 @@ export function referenceNavigation(port: string): ReferenceNavigation | undefin
   const symbols = new Map(model.symbols.map((symbol) => [symbol.id, symbol]))
   const buckets = new Map<string, TreeBucket>()
   const visit = (entries: TreeBucket[]) => {
-    for (const bucket of entries) { buckets.set(bucket.id, bucket); visit(bucket.children) }
+    for (const bucket of entries) {
+      buckets.set(bucket.id, bucket)
+      visit(bucket.children)
+    }
   }
   visit(tree)
   for (const selection of metadata?.apiDependencyNavigation ?? []) {
@@ -300,7 +370,14 @@ export function referenceNavigation(port: string): ReferenceNavigation | undefin
       if (OWNER_KINDS.has(symbol.kind)) {
         const children = membersOf(dependency, symbol, signals)
         if (children.length) {
-          members.set(id, children.map((child) => ({ id: child.id, name: child.name, slug: child.slug ?? pageSlug(child.publicId ?? child.id) })))
+          members.set(
+            id,
+            children.map((child) => ({
+              id: child.id,
+              name: child.name,
+              slug: child.slug ?? pageSlug(child.publicId ?? child.id),
+            })),
+          )
           for (const child of children) add(child)
         }
       }
@@ -327,46 +404,88 @@ export function referenceNavigation(port: string): ReferenceNavigation | undefin
 export function referenceTree(port: string): ApiTreeJson {
   const navigation = referenceNavigation(port)
   if (!navigation) return { port, buckets: [], members: {} }
-  return referenceTreeFor(port, navigation.model, navigation.tree, { excludeProducts: true, members: navigation.members, hrefs: navigation.hrefs })
+  return referenceTreeFor(port, navigation.model, navigation.tree, {
+    excludeProducts: true,
+    members: navigation.members,
+    hrefs: navigation.hrefs,
+  })
 }
 
 /** Serialize the same tree consumed by initial HTML, without registry lookups. */
-export function referenceTreeFor(scope: string, model: ApiModelBase, tree: TreeBucket[], options: ReferenceTreeOptions = {}): ApiTreeJson {
+export function referenceTreeFor(
+  scope: string,
+  model: ApiModelBase,
+  tree: TreeBucket[],
+  options: ReferenceTreeOptions = {},
+): ApiTreeJson {
   const products = new Set(options.excludeProducts ? productSymbols(model).map((symbol) => symbol.id) : [])
-  const symbols = new Map(model.symbols.filter((symbol) => !products.has(symbol.id)).flatMap((symbol) =>
-    [[symbol.id, symbol], [symbol.publicId ?? symbol.id, symbol]] as const))
+  const symbols = new Map(
+    model.symbols
+      .filter((symbol) => !products.has(symbol.id))
+      .flatMap(
+        (symbol) =>
+          [
+            [symbol.id, symbol],
+            [symbol.publicId ?? symbol.id, symbol],
+          ] as const,
+      ),
+  )
   // The shared cache includes product declarations; scope only this core inventory.
-  const members = new Map([...(options.members ?? membersByTypeFor(scope, model))].flatMap(([id, list]) => {
-    if (!symbols.has(id)) return []
-    const core = list.filter((member) => symbols.has(member.id))
-    return core.length ? [[id, core] as const] : []
-  }))
-  const category = (kind: string) => OWNER_KINDS.has(kind) ? 'types' as const : 'members' as const
+  const members = new Map(
+    [...(options.members ?? membersByTypeFor(scope, model))].flatMap(([id, list]) => {
+      if (!symbols.has(id)) return []
+      const core = list.filter((member) => symbols.has(member.id))
+      return core.length ? [[id, core] as const] : []
+    }),
+  )
+  const category = (kind: string) => (OWNER_KINDS.has(kind) ? ('types' as const) : ('members' as const))
   const bucket = (b: TreeBucket): ApiTreeBucket => ({
     id: b.id,
     label: b.label,
     count: bucketTotal(b),
     slug: firstEntry(b)?.slug ?? null,
-    types: b.entries.map((t) => ({ id: t.id, name: t.name, symbolName: symbols.get(t.id)?.name ?? t.name,
+    types: b.entries.map((t) => ({
+      id: t.id,
+      name: t.name,
+      symbolName: symbols.get(t.id)?.name ?? t.name,
       qualifiedName: symbols.get(t.id) ? qualifiedNameOf(symbols.get(t.id)!) : t.id,
-      slug: t.slug, m: members.has(t.id) ? 1 : 0,
+      slug: t.slug,
+      m: members.has(t.id) ? 1 : 0,
       ...(t.shortcut ? { shortcut: true } : {}),
-      kind: t.kind, category: category(t.kind), summary: symbols.get(t.id)?.doc?.summary ?? '' })),
+      kind: t.kind,
+      category: category(t.kind),
+      summary: symbols.get(t.id)?.doc?.summary ?? '',
+    })),
     children: b.children.map(bucket),
   })
-  const relationships = Object.fromEntries(model.symbols.flatMap((symbol) => {
-    const edges = symbol.references?.filter((edge) => symbols.has(edge.target)) ?? []
-    return symbols.has(symbol.id) && edges.length ? [[symbol.id, edges]] : []
-  }))
+  const relationships = Object.fromEntries(
+    model.symbols.flatMap((symbol) => {
+      const edges = symbol.references?.filter((edge) => symbols.has(edge.target)) ?? []
+      return symbols.has(symbol.id) && edges.length ? [[symbol.id, edges]] : []
+    }),
+  )
   return {
     port: scope,
     buckets: tree.map(bucket),
     ...(Object.keys(options.hrefs ?? {}).length ? { hrefs: options.hrefs } : {}),
     ...(Object.keys(relationships).length ? { relationships } : {}),
-    members: Object.fromEntries([...members].map(([id, list]) => [id, list.map((m) => {
-      const symbol = symbols.get(m.id)
-      const kind = symbol?.kind ?? 'member'
-      return [m.name, m.slug, m.id, kind, category(kind), symbol?.doc?.summary ?? '', symbol ? qualifiedNameOf(symbol) : m.id]
-    })])),
+    members: Object.fromEntries(
+      [...members].map(([id, list]) => [
+        id,
+        list.map((m) => {
+          const symbol = symbols.get(m.id)
+          const kind = symbol?.kind ?? 'member'
+          return [
+            m.name,
+            m.slug,
+            m.id,
+            kind,
+            category(kind),
+            symbol?.doc?.summary ?? '',
+            symbol ? qualifiedNameOf(symbol) : m.id,
+          ]
+        }),
+      ]),
+    ),
   }
 }
diff --git a/site/src/lib/branding.ts b/site/src/lib/branding.ts
index 1c32bc060..cf3272b8f 100644
--- a/site/src/lib/branding.ts
+++ b/site/src/lib/branding.ts
@@ -16,14 +16,19 @@ export const TMUX_WEBSITE = 'https://github.com/tmux/tmux/wiki'
 /** The section disambiguates manual commands from guides and source APIs. */
 export function tmuxDocumentationTitle(title: string, pagePath: string): string {
   const sections: Record<string, string> = {
-    guides: 'Guides', topics: 'Topics', concepts: 'Concepts', examples: 'Examples',
-    manual: 'Manual', reference: 'Reference',
+    guides: 'Guides',
+    topics: 'Topics',
+    concepts: 'Concepts',
+    examples: 'Examples',
+    manual: 'Manual',
+    reference: 'Reference',
   }
   const parts = pagePath.split('/').filter(Boolean)
   const section = sections[parts[1]] ?? sections[parts[2]]
   const page = title === 'tmux' ? '' : title
   return [page, section && page.toLowerCase() !== section.toLowerCase() ? section : '', 'tmux', 'libtmux.org']
-    .filter(Boolean).join(' | ')
+    .filter(Boolean)
+    .join(' | ')
 }
 
 export function branding(portSlug?: string, pagePath = '', root = '') {
@@ -42,7 +47,8 @@ export function documentationTitle(title: string, projectName: string): string {
   const suffix = ` | ${projectName}`
   let page = title
   while (page.endsWith(suffix)) page = page.slice(0, -suffix.length)
-  page = page.replace(/ \| libtmux(?:-[a-z]+)?$/, '')
+  page = page
+    .replace(/ \| libtmux(?:-[a-z]+)?$/, '')
     .replace(/ [-–—] libtmux(?:-[a-z]+)?(?: v?\d[\w.+-]*)? documentation$/, '')
   return page === projectName ? page : `${page} | ${projectName}`
 }
diff --git a/site/src/lib/cva.ts b/site/src/lib/cva.ts
index 2ac259535..83ce33ce8 100644
--- a/site/src/lib/cva.ts
+++ b/site/src/lib/cva.ts
@@ -134,43 +134,40 @@ export const navButtonVariants = cva(
  * </div>
  * ```
  */
-export const cardVariants = cva(
-  'relative rounded-lg border border-edge bg-surface shadow-sm',
-  {
-    variants: {
-      variant: {
-        // Default card style (ProjectCard)
-        default: 'p-6',
-        // Compact card style (Badge)
-        compact: 'p-4',
-      },
-      interactive: {
-        true: '',
-        false: '',
-      },
-      layout: {
-        // Vertical layout (ProjectCard)
-        vertical: 'flex flex-col items-center gap-3',
-        // Horizontal layout (Badge)
-        horizontal: 'flex items-start gap-3',
-      },
+export const cardVariants = cva('relative rounded-lg border border-edge bg-surface shadow-sm', {
+  variants: {
+    variant: {
+      // Default card style (ProjectCard)
+      default: 'p-6',
+      // Compact card style (Badge)
+      compact: 'p-4',
     },
-    compoundVariants: [
-      {
-        interactive: true,
-        class:
-          'cursor-pointer hover:bg-surface-hover focus:outline-none focus:ring-2 focus:ring-theme-primary/40 focus:ring-offset-2',
-      },
-      {
-        interactive: true,
-        variant: 'default',
-        class: 'hover:shadow-md',
-      },
-    ],
-    defaultVariants: {
+    interactive: {
+      true: '',
+      false: '',
+    },
+    layout: {
+      // Vertical layout (ProjectCard)
+      vertical: 'flex flex-col items-center gap-3',
+      // Horizontal layout (Badge)
+      horizontal: 'flex items-start gap-3',
+    },
+  },
+  compoundVariants: [
+    {
+      interactive: true,
+      class:
+        'cursor-pointer hover:bg-surface-hover focus:outline-none focus:ring-2 focus:ring-theme-primary/40 focus:ring-offset-2',
+    },
+    {
+      interactive: true,
       variant: 'default',
-      interactive: false,
-      layout: 'vertical',
+      class: 'hover:shadow-md',
     },
+  ],
+  defaultVariants: {
+    variant: 'default',
+    interactive: false,
+    layout: 'vertical',
   },
-)
+})
diff --git a/site/src/lib/docs-paths.ts b/site/src/lib/docs-paths.ts
index 33ed888ce..920daad44 100644
--- a/site/src/lib/docs-paths.ts
+++ b/site/src/lib/docs-paths.ts
@@ -54,11 +54,7 @@ export function docsPath(entry: DocsPage): string {
 }
 
 /** Root builds expose product pages at the same URLs as assembled port builds. */
-export function docsRoutePath(
-  entry: DocsPage,
-  buildPort?: string,
-  defaults: Record<string, string> = {},
-): string {
+export function docsRoutePath(entry: DocsPage, buildPort?: string, defaults: Record<string, string> = {}): string {
   const path = docsPath(entry)
   if (buildPort) return path
   if (!entry.data.port) return tmuxProsePath(path)
@@ -79,7 +75,8 @@ export function sourceGuideRedirects(buildPort?: string, defaults: Record<string
     sourceGuideRedirectsFor(port).map(({ path, target }) => {
       const project = (route: string) => docsRoutePath({ id: route, data: { port, route } }, buildPort, defaults)
       return { path: project(path), target: project(target) }
-    }))
+    }),
+  )
 }
 
 /**
@@ -122,6 +119,8 @@ export function workspaceRedirects(paths: string[]): { path: string; target: str
 /** Old section roots redirect; nested user references have their own content. */
 export function workspaceRedirectPath(path: string, publishedPaths: ReadonlySet<string>): boolean {
   const normalized = path.replace(/\/$/, '')
-  return !publishedPaths.has(normalized)
-    && (/^workspace\/api(?:\/|$)/.test(normalized) || /^workspace\/(?:topics|guides|examples)$/.test(normalized))
+  return (
+    !publishedPaths.has(normalized) &&
+    (/^workspace\/api(?:\/|$)/.test(normalized) || /^workspace\/(?:topics|guides|examples)$/.test(normalized))
+  )
 }
diff --git a/site/src/lib/documentation-navigation.ts b/site/src/lib/documentation-navigation.ts
index 87368a8c6..4d8a9a0b5 100644
--- a/site/src/lib/documentation-navigation.ts
+++ b/site/src/lib/documentation-navigation.ts
@@ -28,100 +28,161 @@ export interface DocumentationSurface {
 }
 
 const labels: Record<string, string> = {
-  home: 'Home', guides: 'Guides', tutorials: 'Tutorials', topics: 'Topics', concepts: 'Concepts',
-  examples: 'Examples', reference: 'API Reference', configuration: 'Configuration', internals: 'Internals',
-  async: 'Async', runtimes: 'Runtimes', manual: 'CLI Manual',
+  home: 'Home',
+  guides: 'Guides',
+  tutorials: 'Tutorials',
+  topics: 'Topics',
+  concepts: 'Concepts',
+  examples: 'Examples',
+  reference: 'API Reference',
+  configuration: 'Configuration',
+  internals: 'Internals',
+  async: 'Async',
+  runtimes: 'Runtimes',
+  manual: 'CLI Manual',
   ...MCP_SECTIONS,
 }
-const standardSections = ['home', 'guides', 'tutorials', 'topics', 'concepts', 'examples', 'manual', 'tools', 'prompts', 'resources', 'reference']
-const linksOf = (items: SidebarItem[]): SidebarLinkItem[] => items.flatMap((item) => item.type === 'link'
-  ? [item] : [...(item.href ? [{ type: 'link' as const, label: item.label, href: item.href }] : []), ...linksOf(item.items)])
+const standardSections = [
+  'home',
+  'guides',
+  'tutorials',
+  'topics',
+  'concepts',
+  'examples',
+  'manual',
+  'tools',
+  'prompts',
+  'resources',
+  'reference',
+]
+const linksOf = (items: SidebarItem[]): SidebarLinkItem[] =>
+  items.flatMap((item) =>
+    item.type === 'link'
+      ? [item]
+      : [...(item.href ? [{ type: 'link' as const, label: item.label, href: item.href }] : []), ...linksOf(item.items)],
+  )
 
 /** Group actual published destinations, not a guessed matrix of app routes. */
 export function buildDocumentationSurfaces(
-  port: string, version: string, menus: Partial<Record<'core' | DocProduct, SidebarItem[]>>,
+  port: string,
+  version: string,
+  menus: Partial<Record<'core' | DocProduct, SidebarItem[]>>,
 ): DocumentationSurface[] {
   const info = PORT_BY_SLUG[port]
   const base = portPageUrl(info, version)
-  return documentationAreas(port).filter((domain) => domain.kind !== 'unavailable' && (domain.id === 'core' || domain.product))
-    .sort((a, b) => ['core', 'mcp', 'workspace'].indexOf(a.product ?? 'core') - ['core', 'mcp', 'workspace'].indexOf(b.product ?? 'core'))
+  return documentationAreas(port)
+    .filter((domain) => domain.kind !== 'unavailable' && (domain.id === 'core' || domain.product))
+    .sort(
+      (a, b) =>
+        ['core', 'mcp', 'workspace'].indexOf(a.product ?? 'core') -
+        ['core', 'mcp', 'workspace'].indexOf(b.product ?? 'core'),
+    )
     .map((domain) => {
-    const id = domain.product ?? 'core'
-    const prefix = domain.product ? `${domain.product}/` : ''
-    const href = portPageUrl(info, version, domain.route)
-    const home: DocumentationSection = { id: 'home', label: 'Home', href, items: [] }
-    const sections = new Map<string, DocumentationSection>([['home', home]])
-    const seen = new Set<string>()
-    for (const link of linksOf(menus[id] ?? [])) {
-      if (seen.has(link.href)) continue
-      seen.add(link.href)
-      const route = link.href.startsWith(base) ? link.href.slice(base.length).replace(/\/$/, '') : undefined
-      const relative = route === domain.route ? '' : route?.startsWith(prefix) ? route.slice(prefix.length) : undefined
-      let key = relative?.split('/')[0] || 'home'
-      if (key === 'third-party-notices') continue
-      if (key === 'source-guide') key = 'guides'
-      if (id === 'workspace' && (key === 'cli' || /^reference\/(?:exit-codes|output)$/.test(relative ?? ''))) key = 'manual'
-      else if (link.external || key === 'cli' || key === 'api') key = 'reference'
-      const section = sections.get(key) ?? { id: key, label: labels[key] ?? link.label, items: [] }
-      if (!section.href && (relative === key || (key === 'manual' && relative === 'cli')) && !link.external) section.href = link.href
-      section.items.push(link)
-      sections.set(key, section)
-    }
-    const reference: DocumentationSection = sections.get('reference') ?? { id: 'reference', label: 'API Reference', items: [] }
-    reference.href = referenceUrl(info, version, id)
-    if (domain.product) {
-      // Protocol tools and the implementation API retain their native URLs.
-      const groups = new Map<string, SidebarItem[]>([['Language API', []]])
-      for (const item of linksOf(reference.items)) {
-        if (item.href === reference.href) continue
-        const route = item.href.slice(base.length)
-        const label = route.startsWith(`${prefix}cli/`) ? 'CLI reference'
-          : route.startsWith(`${prefix}tools/`) ? 'Tools'
-          : domain.product === 'workspace' && item.href !== reference.href ? 'CLI contracts' : 'Language API'
-        const entries = groups.get(label) ?? []
-        entries.push(item)
-        groups.set(label, entries)
+      const id = domain.product ?? 'core'
+      const prefix = domain.product ? `${domain.product}/` : ''
+      const href = portPageUrl(info, version, domain.route)
+      const home: DocumentationSection = { id: 'home', label: 'Home', href, items: [] }
+      const sections = new Map<string, DocumentationSection>([['home', home]])
+      const seen = new Set<string>()
+      for (const link of linksOf(menus[id] ?? [])) {
+        if (seen.has(link.href)) continue
+        seen.add(link.href)
+        const route = link.href.startsWith(base) ? link.href.slice(base.length).replace(/\/$/, '') : undefined
+        const relative =
+          route === domain.route ? '' : route?.startsWith(prefix) ? route.slice(prefix.length) : undefined
+        let key = relative?.split('/')[0] || 'home'
+        if (key === 'third-party-notices') continue
+        if (key === 'source-guide') key = 'guides'
+        if (id === 'workspace' && (key === 'cli' || /^reference\/(?:exit-codes|output)$/.test(relative ?? '')))
+          key = 'manual'
+        else if (link.external || key === 'cli' || key === 'api') key = 'reference'
+        const section = sections.get(key) ?? { id: key, label: labels[key] ?? link.label, items: [] }
+        if (!section.href && (relative === key || (key === 'manual' && relative === 'cli')) && !link.external)
+          section.href = link.href
+        section.items.push(link)
+        sections.set(key, section)
       }
-      const api = groups.get('Language API') ?? []
-      if (API_MODELS[port]) {
-        const symbols = productApiNavigation(API_MODELS[port], domain.product, version)
-        api.push(...symbols)
-        // Keep glossary visits in the same expanded reference tree, with their
-        // own active entry rather than falsely selecting the reference index.
-        if (symbols.length) api.push({ type: 'link', label: API_GLOSSARY_TITLE, href: `${reference.href}glossary/` })
+      const reference: DocumentationSection = sections.get('reference') ?? {
+        id: 'reference',
+        label: 'API Reference',
+        items: [],
       }
-      groups.set('Language API', api)
-      reference.items = [...groups].map(([label, items]) => ({ type: 'group', label,
-        ...(label === 'Language API' ? { href: reference.href } : {}), items }))
-    } else {
-      reference.alternatives = linksOf(reference.items).filter((item) => item.href !== reference.href)
-    }
-    sections.set('reference', reference)
-    if (id === 'mcp') for (const [key, label] of Object.entries(MCP_SECTIONS)) {
-      const section = sections.get(key)
-      if (!section) continue
-      section.label = label
-      const objects = mcpObjects(port).filter((object) => object.section === key as McpSection)
-      section.disabled = objects.length === 0
-      section.items.push(...objects.map((object) => ({
-        type: 'link' as const, label: object.name, kind: object.kind, href: portPageUrl(info, version, object.path),
-      })))
-    }
-    // Some named areas have no overview. Their first real page is a useful
-    // destination without inventing an overview route.
-    for (const section of sections.values()) section.href ??= linksOf(section.items)[0]?.href
-    const ordered = [...sections.values()].filter((section) => section.href).sort((a, b) => {
-      const rank = (key: string) => standardSections.includes(key) ? standardSections.indexOf(key) : standardSections.length
-      return rank(a.id) - rank(b.id)
+      reference.href = referenceUrl(info, version, id)
+      if (domain.product) {
+        // Protocol tools and the implementation API retain their native URLs.
+        const groups = new Map<string, SidebarItem[]>([['Language API', []]])
+        for (const item of linksOf(reference.items)) {
+          if (item.href === reference.href) continue
+          const route = item.href.slice(base.length)
+          const label = route.startsWith(`${prefix}cli/`)
+            ? 'CLI reference'
+            : route.startsWith(`${prefix}tools/`)
+              ? 'Tools'
+              : domain.product === 'workspace' && item.href !== reference.href
+                ? 'CLI contracts'
+                : 'Language API'
+          const entries = groups.get(label) ?? []
+          entries.push(item)
+          groups.set(label, entries)
+        }
+        const api = groups.get('Language API') ?? []
+        if (API_MODELS[port]) {
+          const symbols = productApiNavigation(API_MODELS[port], domain.product, version)
+          api.push(...symbols)
+          // Keep glossary visits in the same expanded reference tree, with their
+          // own active entry rather than falsely selecting the reference index.
+          if (symbols.length) api.push({ type: 'link', label: API_GLOSSARY_TITLE, href: `${reference.href}glossary/` })
+        }
+        groups.set('Language API', api)
+        reference.items = [...groups].map(([label, items]) => ({
+          type: 'group',
+          label,
+          ...(label === 'Language API' ? { href: reference.href } : {}),
+          items,
+        }))
+      } else {
+        reference.alternatives = linksOf(reference.items).filter((item) => item.href !== reference.href)
+      }
+      sections.set('reference', reference)
+      if (id === 'mcp')
+        for (const [key, label] of Object.entries(MCP_SECTIONS)) {
+          const section = sections.get(key)
+          if (!section) continue
+          section.label = label
+          const objects = mcpObjects(port).filter((object) => object.section === (key as McpSection))
+          section.disabled = objects.length === 0
+          section.items.push(
+            ...objects.map((object) => ({
+              type: 'link' as const,
+              label: object.name,
+              kind: object.kind,
+              href: portPageUrl(info, version, object.path),
+            })),
+          )
+        }
+      // Some named areas have no overview. Their first real page is a useful
+      // destination without inventing an overview route.
+      for (const section of sections.values()) section.href ??= linksOf(section.items)[0]?.href
+      const ordered = [...sections.values()]
+        .filter((section) => section.href)
+        .sort((a, b) => {
+          const rank = (key: string) =>
+            standardSections.includes(key) ? standardSections.indexOf(key) : standardSections.length
+          return rank(a.id) - rank(b.id)
+        })
+      home.items = [
+        { type: 'link', label: 'Overview', href },
+        ...ordered
+          .filter((section) => section.id !== 'home' && section.href)
+          .map((section): SidebarLinkItem => ({
+            type: 'link',
+            label: section.label,
+            href: section.href!,
+            ...(section.disabled ? { disabled: true } : {}),
+          })),
+      ]
+      return { id, label: domain.id === 'core' ? 'Core Library' : domain.label, href, sections: ordered }
     })
-    home.items = [
-      { type: 'link', label: 'Overview', href },
-      ...ordered.filter((section) => section.id !== 'home' && section.href)
-        .map((section): SidebarLinkItem => ({ type: 'link', label: section.label, href: section.href!,
-          ...(section.disabled ? { disabled: true } : {}) })),
-    ]
-    return { id, label: domain.id === 'core' ? 'Core Library' : domain.label, href, sections: ordered }
-  })
 }
 
 const cache = new Map<string, Promise<DocumentationSurface[]>>()
@@ -135,19 +196,38 @@ export function getDocumentationSurfaces(port: string | undefined, version: stri
       const current = version === 'latest'
       const sections: DocumentationSection[] = [
         { id: 'home', label: current ? 'Home' : 'Current docs →', href: withPortRoot('/tmux/'), items: [] },
-        ...(current ? menus : []).flatMap((item) => item.type === 'group' && item.href
-          ? [{ id: item.label.toLowerCase(), label: item.label, href: item.href, items: item.items }] : []),
+        ...(current ? menus : []).flatMap((item) =>
+          item.type === 'group' && item.href
+            ? [{ id: item.label.toLowerCase(), label: item.label, href: item.href, items: item.items }]
+            : [],
+        ),
         { id: 'manual', label: 'CLI Manual', href: tmuxManualUrl(version), items: [] },
-        { id: 'reference', label: 'C source reference', shortLabel: 'C reference', href: tmuxReferenceUrl(version), items: [] },
+        {
+          id: 'reference',
+          label: 'C source reference',
+          shortLabel: 'C reference',
+          href: tmuxReferenceUrl(version),
+          items: [],
+        },
       ]
-      sections[0].items = sections.filter((section) => section.href).map((section) => ({
-        type: 'link', label: section.label, href: section.href!,
-      }))
+      sections[0].items = sections
+        .filter((section) => section.href)
+        .map((section) => ({
+          type: 'link',
+          label: section.label,
+          href: section.href!,
+        }))
       return [{ id: 'tmux', label: 'tmux', href: withPortRoot('/tmux/'), sections }]
     }
-    const products = documentationAreas(port).flatMap((domain) => domain.kind !== 'unavailable' && domain.product ? [domain.product] : [])
-    const menus = await Promise.all(['core' as const, ...products].map(async (product) =>
-      [product, await getSidebar(port, version, locale, product === 'core' ? undefined : product)] as const))
+    const products = documentationAreas(port).flatMap((domain) =>
+      domain.kind !== 'unavailable' && domain.product ? [domain.product] : [],
+    )
+    const menus = await Promise.all(
+      ['core' as const, ...products].map(
+        async (product) =>
+          [product, await getSidebar(port, version, locale, product === 'core' ? undefined : product)] as const,
+      ),
+    )
     return buildDocumentationSurfaces(port, version, Object.fromEntries(menus))
   }
   if (import.meta.env.DEV) return build()
@@ -157,19 +237,31 @@ export function getDocumentationSurfaces(port: string | undefined, version: stri
 
 /** URL-derived selection also works on direct loads, reloads and browser history. */
 export function currentDocumentation(surfaces: DocumentationSurface[], currentPath: string) {
-  const surface = surfaces.filter((entry) => currentPath.startsWith(entry.href))
-    .sort((a, b) => b.href.length - a.href.length)[0] ?? surfaces[0]
+  const surface =
+    surfaces.filter((entry) => currentPath.startsWith(entry.href)).sort((a, b) => b.href.length - a.href.length)[0] ??
+    surfaces[0]
   const path = currentPath.slice(surface.href.length).split('/')[0] || 'home'
-  const key = path === 'source-guide' ? 'guides'
-    : path === 'cli' && surface.id === 'workspace' ? 'manual'
-    : path === 'cli' || path === 'api' ? 'reference' : path
-  const section = surface.sections.filter((entry) => entry.id !== 'home').flatMap((entry) =>
-    [entry.href, ...linksOf(entry.items).map((item) => item.href)]
-      .filter((href): href is string => Boolean(href && currentPath.startsWith(href)))
-      .map((href) => ({ entry, href })))
-    .sort((a, b) => b.href.length - a.href.length)[0]?.entry
-    ?? surface.sections.find((entry) => entry.id === key) ?? surface.sections[0]
-  const alternative = section.alternatives?.filter((item) => !item.external && currentPath.startsWith(item.href))
+  const key =
+    path === 'source-guide'
+      ? 'guides'
+      : path === 'cli' && surface.id === 'workspace'
+        ? 'manual'
+        : path === 'cli' || path === 'api'
+          ? 'reference'
+          : path
+  const section =
+    surface.sections
+      .filter((entry) => entry.id !== 'home')
+      .flatMap((entry) =>
+        [entry.href, ...linksOf(entry.items).map((item) => item.href)]
+          .filter((href): href is string => Boolean(href && currentPath.startsWith(href)))
+          .map((href) => ({ entry, href })),
+      )
+      .sort((a, b) => b.href.length - a.href.length)[0]?.entry ??
+    surface.sections.find((entry) => entry.id === key) ??
+    surface.sections[0]
+  const alternative = section.alternatives
+    ?.filter((item) => !item.external && currentPath.startsWith(item.href))
     .sort((a, b) => b.href.length - a.href.length)[0]
   return { surface, section, alternative }
 }
diff --git a/site/src/lib/highlight.ts b/site/src/lib/highlight.ts
index e77c4a374..8ff1b5a87 100644
--- a/site/src/lib/highlight.ts
+++ b/site/src/lib/highlight.ts
@@ -27,12 +27,32 @@ let instance: Promise<Highlighter> | undefined
  * A grammar that is never used is a megabyte of startup for nothing.
  */
 const LANGS = [
-  'python', 'ruby', 'lua', 'rust', 'ts', 'js', 'bash', 'console', 'json', 'yaml', 'text',
+  'python',
+  'ruby',
+  'lua',
+  'rust',
+  'ts',
+  'js',
+  'bash',
+  'console',
+  'json',
+  'yaml',
+  'text',
   // The install widget's build-file panels: a Gradle script, a Maven POM
   // fragment, a Package.swift dependency and a CMakeLists block. Three of the
   // eight ports cannot be installed from a command line at all, so without
   // these their only install instructions render as flat grey.
-  'kotlin', 'scala', 'fsharp', 'csharp', 'xml', 'swift', 'cmake', 'toml', 'nix', 'powershell', 'julia',
+  'kotlin',
+  'scala',
+  'fsharp',
+  'csharp',
+  'xml',
+  'swift',
+  'cmake',
+  'toml',
+  'nix',
+  'powershell',
+  'julia',
 ] as const
 
 /**
@@ -46,15 +66,18 @@ const THEMES = { light: 'github-light', dark: 'github-dark' }
 
 /** Give the dynamic prompt tokens the same palette as the code highlighter. */
 export function promptThemeRules(): string {
-  return shellThemes().map((theme) => {
-    const foreground = theme.colors?.['editor.foreground']
-    const background = theme.colors?.['editor.background']
-    if (!foreground || !background) throw new Error(`Prompt theme ${theme.name} has no editor colors`)
-    const token = (scope: string) => [...theme.tokenColors].reverse().find((rule) =>
-      (Array.isArray(rule.scope) ? rule.scope : [rule.scope]).includes(scope),
-    )?.settings.foreground ?? foreground
-    const selector = theme.type === 'dark' ? 'html[data-theme-mode="dark"]' : 'html:not([data-theme-mode="dark"])'
-    return `${selector} .lm-agent-prompt {
+  return shellThemes()
+    .map((theme) => {
+      const foreground = theme.colors?.['editor.foreground']
+      const background = theme.colors?.['editor.background']
+      if (!foreground || !background) throw new Error(`Prompt theme ${theme.name} has no editor colors`)
+      const token = (scope: string) =>
+        [...theme.tokenColors]
+          .reverse()
+          .find((rule) => (Array.isArray(rule.scope) ? rule.scope : [rule.scope]).includes(scope))?.settings
+          .foreground ?? foreground
+      const selector = theme.type === 'dark' ? 'html[data-theme-mode="dark"]' : 'html:not([data-theme-mode="dark"])'
+      return `${selector} .lm-agent-prompt {
       --lm-agent-prompt-code-bg: ${background};
       --lm-agent-prompt-code-fg: ${foreground};
       --lm-agent-prompt-url: ${token('support')};
@@ -63,7 +86,8 @@ export function promptThemeRules(): string {
       --lm-agent-prompt-key: ${token('entity')};
       --lm-agent-prompt-marker: ${token('keyword')};
     }`
-  }).join('\n')
+    })
+    .join('\n')
 }
 
 async function highlighter(): Promise<Highlighter> {
@@ -101,13 +125,17 @@ export async function highlight(code: string, lang: string): Promise<string | un
       themes: THEMES,
       defaultColor: false,
       cssVariablePrefix: '--shiki-',
-      transformers: session ? [{
-        line(node, line) {
-          const { kind, text } = session[line - 1] ?? {}
-          if (kind === 'prompt') node.children.unshift(promptElement())
-          else if (kind === 'output') node.children = [{ type: 'text', value: text ?? '' }]
-        },
-      }] : [],
+      transformers: session
+        ? [
+            {
+              line(node, line) {
+                const { kind, text } = session[line - 1] ?? {}
+                if (kind === 'prompt') node.children.unshift(promptElement())
+                else if (kind === 'output') node.children = [{ type: 'text', value: text ?? '' }]
+              },
+            },
+          ]
+        : [],
     })
   } catch {
     return undefined
@@ -132,9 +160,37 @@ export async function highlight(code: string, lang: string): Promise<string | un
  * there.
  */
 const EC_LANGS = new Set([
-  'python', 'ruby', 'lua', 'rust', 'ts', 'tsx', 'js', 'jsx', 'java', 'kotlin', 'scala', 'fsharp', 'swift',
-  'csharp', 'cpp', 'c', 'go', 'bash', 'shell', 'console', 'json', 'yaml',
-  'toml', 'xml', 'diff', 'text', 'tmux-usage', 'tmux-shell', 'tmux-config', 'powershell', 'julia',
+  'python',
+  'ruby',
+  'lua',
+  'rust',
+  'ts',
+  'tsx',
+  'js',
+  'jsx',
+  'java',
+  'kotlin',
+  'scala',
+  'fsharp',
+  'swift',
+  'csharp',
+  'cpp',
+  'c',
+  'go',
+  'bash',
+  'shell',
+  'console',
+  'json',
+  'yaml',
+  'toml',
+  'xml',
+  'diff',
+  'text',
+  'tmux-usage',
+  'tmux-shell',
+  'tmux-config',
+  'powershell',
+  'julia',
 ])
 
 const EC_ALIASES: Record<string, string> = {
diff --git a/site/src/lib/home-hover-preview.ts b/site/src/lib/home-hover-preview.ts
index ecddfc21b..0b7428e86 100644
--- a/site/src/lib/home-hover-preview.ts
+++ b/site/src/lib/home-hover-preview.ts
@@ -3,7 +3,12 @@ export const HOME_PREVIEW_FADE = 180
 export const HOME_PORT_PREVIEW_EVENT = 'lm-home-port:preview'
 
 /** A hover is provisional until its control is clicked. Touch keeps click behavior. */
-export function bindHomeHoverPreview({ options, show, restore, signal }: {
+export function bindHomeHoverPreview({
+  options,
+  show,
+  restore,
+  signal,
+}: {
   options: HTMLElement[]
   show: (option: HTMLElement) => void
   restore: () => void
@@ -22,26 +27,38 @@ export function bindHomeHoverPreview({ options, show, restore, signal }: {
     if (wasActive) restore()
   }
   for (const option of options) {
-    option.addEventListener('pointerenter', (event) => {
-      if (event.pointerType !== 'mouse' && event.pointerType !== 'pen') return
-      if (!window.matchMedia('(any-hover: hover)').matches) return
-      cancel()
-      timer = setTimeout(() => {
-        timer = undefined
-        if (!option.isConnected || signal.aborted) return
-        active = true
-        show(option)
-      }, HOME_PREVIEW_DELAY)
-    }, { signal })
+    option.addEventListener(
+      'pointerenter',
+      (event) => {
+        if (event.pointerType !== 'mouse' && event.pointerType !== 'pen') return
+        if (!window.matchMedia('(any-hover: hover)').matches) return
+        cancel()
+        timer = setTimeout(() => {
+          timer = undefined
+          if (!option.isConnected || signal.aborted) return
+          active = true
+          show(option)
+        }, HOME_PREVIEW_DELAY)
+      },
+      { signal },
+    )
     option.addEventListener('pointerleave', cancel, { signal })
     option.addEventListener('pointercancel', cancel, { signal })
   }
-  document.addEventListener('keydown', (event) => {
-    if (event.key === 'Escape') cancel()
-  }, { signal, capture: true })
-  document.addEventListener('visibilitychange', () => {
-    if (document.hidden) cancel()
-  }, { signal })
+  document.addEventListener(
+    'keydown',
+    (event) => {
+      if (event.key === 'Escape') cancel()
+    },
+    { signal, capture: true },
+  )
+  document.addEventListener(
+    'visibilitychange',
+    () => {
+      if (document.hidden) cancel()
+    },
+    { signal },
+  )
   window.addEventListener('blur', cancel, { signal })
   window.addEventListener('pagehide', cancel, { signal })
   document.addEventListener('astro:before-swap', cancel, { signal })
diff --git a/site/src/lib/install-matrix.ts b/site/src/lib/install-matrix.ts
index 331ab325e..ba6209d18 100644
--- a/site/src/lib/install-matrix.ts
+++ b/site/src/lib/install-matrix.ts
@@ -352,12 +352,14 @@ export const SERVERS: Readonly<Record<string, ServerSpec>> = {
     resolve(method) {
       const command = {
         command: method.id === 'bundler' ? 'bundle' : 'libtmux-mcp',
-        args: method.id === 'bundler'
-          ? ['exec', 'libtmux-mcp', '--socket-name', 'libtmux-docs', '--endpoint', 'local']
-          : ['--socket-name', 'libtmux-docs', '--endpoint', 'local'],
-        prereq: method.id === 'bundler'
-          ? 'bundle add libtmux-mcp --version 0.1.0.alpha.1'
-          : 'gem install --version 0.1.0.alpha.1 libtmux-mcp',
+        args:
+          method.id === 'bundler'
+            ? ['exec', 'libtmux-mcp', '--socket-name', 'libtmux-docs', '--endpoint', 'local']
+            : ['--socket-name', 'libtmux-docs', '--endpoint', 'local'],
+        prereq:
+          method.id === 'bundler'
+            ? 'bundle add libtmux-mcp --version 0.1.0.alpha.1'
+            : 'gem install --version 0.1.0.alpha.1 libtmux-mcp',
         note: 'The server borrows an existing named socket. Start it first with `tmux -L libtmux-docs new-session -d`; `--endpoint` is only its public alias.',
       }
       return command
@@ -379,9 +381,10 @@ export const SERVERS: Readonly<Record<string, ServerSpec>> = {
           args: ['-y', '@libtmux/mcp'],
           // npx resolves the package before it reads the exclusion, so a
           // cooldown would hold back @libtmux/mcp itself.
-          note: cooldown.id === 'days'
-            ? 'npx ignores --min-release-age-exclude, so a cooldown here would also hold back the release it runs; this runs without one. The Global install tab applies a cooldown to the server\'s dependencies.'
-            : undefined,
+          note:
+            cooldown.id === 'days'
+              ? "npx ignores --min-release-age-exclude, so a cooldown here would also hold back the release it runs; this runs without one. The Global install tab applies a cooldown to the server's dependencies."
+              : undefined,
         }
       }
       const note = 'The package installs a `libtmux-mcp` binary. Requires Node 22 or newer, or Bun 1.3.14 or newer.'
@@ -398,7 +401,12 @@ export const SERVERS: Readonly<Record<string, ServerSpec>> = {
         }
       }
       if (cooldown.id === 'bypass') {
-        return { command: 'libtmux-mcp', args: [], prereq: 'npm install --global --min-release-age=0 @libtmux/mcp', note }
+        return {
+          command: 'libtmux-mcp',
+          args: [],
+          prereq: 'npm install --global --min-release-age=0 @libtmux/mcp',
+          note,
+        }
       }
       return { command: 'libtmux-mcp', args: [], prereq: 'npm install --global @libtmux/mcp', note }
     },
@@ -566,9 +574,7 @@ function jsonBody(server: ServerCommand): string {
   }
   const env = Object.entries(server.env ?? {})
   if (env.length > 0) {
-    serverLines.push(
-      `${serverIndent}"env": { ${env.map(([k, v]) => `"${k}": "${v}"`).join(', ')} }`,
-    )
+    serverLines.push(`${serverIndent}"env": { ${env.map(([k, v]) => `"${k}": "${v}"`).join(', ')} }`)
   }
   const serverBlock = serverLines.join(',\n')
   return (
@@ -757,8 +763,7 @@ function panelActiveSelectors(spec: ServerSpec): string {
           `[data-mcp-install-client="${client.id}"]` +
           `[data-mcp-install-method="${method.id}"]` +
           `[data-mcp-install-scope="${scope.id}"]`
-        const panel =
-          ` .lm-mcp-install__panel[data-client="${client.id}"][data-method="${method.id}"][data-scope="${scope.id}"]`
+        const panel = ` .lm-mcp-install__panel[data-client="${client.id}"][data-method="${method.id}"][data-scope="${scope.id}"]`
         if (!hasCooldowns) {
           selectors.push(`html${htmlAttrs}${panel}[data-cooldown="off"]`)
           continue
diff --git a/site/src/lib/link-hint-readiness.ts b/site/src/lib/link-hint-readiness.ts
index d98b5378a..867cd8fcb 100644
--- a/site/src/lib/link-hint-readiness.ts
+++ b/site/src/lib/link-hint-readiness.ts
@@ -11,7 +11,11 @@ export function initializeLinkHintReadiness() {
     timer: ReturnType<typeof setTimeout>
   }
   let current: Gate
-  const pageHref = (href: string) => { const url = new URL(href); url.hash = ''; return url.href }
+  const pageHref = (href: string) => {
+    const url = new URL(href)
+    url.hash = ''
+    return url.href
+  }
   const roots = (gate: Gate) => {
     const live = document.documentElement
     return live.dataset.linkHintsGeneration === gate.token ? [gate.root, live] : [gate.root]
@@ -32,8 +36,12 @@ export function initializeLinkHintReadiness() {
     if (current) clearTimeout(current.timer)
     const root = doc.documentElement
     const gate: Gate = {
-      token: String(++generation), root, href: pageHref(href),
-      decorated: false, maskReady: false, settled: false,
+      token: String(++generation),
+      root,
+      href: pageHref(href),
+      decorated: false,
+      maskReady: false,
+      settled: false,
       timer: setTimeout(() => finish(gate, false), 3000),
     }
     current = gate
@@ -41,7 +49,10 @@ export function initializeLinkHintReadiness() {
     root.classList.remove('link-hints-suppressed')
     root.classList.add('link-hints-pending')
     const mask = doc.querySelector<HTMLLinkElement>('link[data-link-hints-mask]')
-    if (!mask) { finish(gate, false); return }
+    if (!mask) {
+      finish(gate, false)
+      return
+    }
     const image = new Image()
     // CSS masks use CORS fetches; share their decoded cache entry.
     image.crossOrigin = 'anonymous'
@@ -49,7 +60,13 @@ export function initializeLinkHintReadiness() {
     image.onload = () => {
       // Loading the bytes is not sufficient: wait until the mask can paint.
       const decoded = typeof image.decode === 'function' ? image.decode() : Promise.resolve()
-      decoded.then(() => { gate.maskReady = true; revealIfReady(gate) }, () => finish(gate, false))
+      decoded.then(
+        () => {
+          gate.maskReady = true
+          revealIfReady(gate)
+        },
+        () => finish(gate, false),
+      )
     }
     image.src = new URL(mask.getAttribute('href')!, href).href
   }
@@ -59,9 +76,18 @@ export function initializeLinkHintReadiness() {
     current.decorated = true
     revealIfReady(current)
   })
-  document.addEventListener('error', (event) => {
-    if (event.target instanceof HTMLScriptElement && event.target.isConnected && event.target.hasAttribute('data-link-hints-module')) finish(current, false)
-  }, true)
+  document.addEventListener(
+    'error',
+    (event) => {
+      if (
+        event.target instanceof HTMLScriptElement &&
+        event.target.isConnected &&
+        event.target.hasAttribute('data-link-hints-module')
+      )
+        finish(current, false)
+    },
+    true,
+  )
   document.addEventListener('astro:before-swap', (event) => begin(event.newDocument, event.to.href))
   begin(document, location.href)
 }
diff --git a/site/src/lib/link-preview-browser.ts b/site/src/lib/link-preview-browser.ts
index 13a66eaf3..75864c3a8 100644
--- a/site/src/lib/link-preview-browser.ts
+++ b/site/src/lib/link-preview-browser.ts
@@ -10,59 +10,93 @@ let dispose = () => {}
 /** Keep keyword help and fetched previews inside the same viewport gutter. */
 export function positionLinkPreview(panel: HTMLElement, trigger: HTMLElement) {
   if (!trigger.isConnected || !panel.matches(':popover-open')) return
-  const anchor = trigger.getBoundingClientRect(), box = panel.getBoundingClientRect()
-  const viewport = document.documentElement.getBoundingClientRect(), gap = 8
+  const anchor = trigger.getBoundingClientRect(),
+    box = panel.getBoundingClientRect()
+  const viewport = document.documentElement.getBoundingClientRect(),
+    gap = 8
   const left = Math.max(viewport.left + gap, Math.min(anchor.left, viewport.right - box.width - gap))
   const below = anchor.bottom + gap
-  const top = Math.max(gap, Math.min(below + box.height <= innerHeight - gap ? below : anchor.top - box.height - gap, innerHeight - box.height - gap))
+  const top = Math.max(
+    gap,
+    Math.min(
+      below + box.height <= innerHeight - gap ? below : anchor.top - box.height - gap,
+      innerHeight - box.height - gap,
+    ),
+  )
   Object.assign(panel.style, { inset: 'auto', margin: '0', left: `${left}px`, top: `${top}px` })
 }
 
 function validPreview(value: unknown): value is LinkPreview {
   if (!value || typeof value !== 'object') return false
   const data = value as Partial<LinkPreview>
-  return data.schema === 1 && typeof data.title === 'string' && typeof data.description === 'string'
-    && typeof data.href === 'string' && (!data.detail || typeof data.detail === 'string')
-    && (!data.signature || typeof data.signature === 'string')
+  return (
+    data.schema === 1 &&
+    typeof data.title === 'string' &&
+    typeof data.description === 'string' &&
+    typeof data.href === 'string' &&
+    (!data.detail || typeof data.detail === 'string') &&
+    (!data.signature || typeof data.signature === 'string')
+  )
 }
 
-export function disposeLinkPreviews() { dispose(); dispose = () => {} }
+export function disposeLinkPreviews() {
+  dispose()
+  dispose = () => {}
+}
 
 /** One cached card follows the current intent; late responses cannot replace it. */
 export function initLinkPreviews() {
   disposeLinkPreviews()
   const panel = document.getElementById('reference-link-preview')
   if (!panel || !panel.showPopover) return
-  const controller = new AbortController(), { signal } = controller
+  const controller = new AbortController(),
+    { signal } = controller
   const pending = new Map<string, Promise<LinkPreview>>()
   let current: HTMLAnchorElement | undefined
   let intent = 0
   let timer: ReturnType<typeof setTimeout> | undefined
   let closeTimer: ReturnType<typeof setTimeout> | undefined
-  let pinned = false, restoringFocus = false, shown = false
-  let fullTitle = '', shortTitle = ''
+  let pinned = false,
+    restoringFocus = false,
+    shown = false
+  let fullTitle = '',
+    shortTitle = ''
   const title = panel.querySelector<HTMLElement>('[data-preview-title]')!
   const expandTitle = panel.querySelector<HTMLButtonElement>('[data-preview-expand]')!
   const renderTitle = (expanded: boolean) => {
-    title.replaceChildren(...wordBreak(expanded ? fullTitle : shortTitle).flatMap((part, index) =>
-      index ? [document.createElement('wbr'), document.createTextNode(part)] : [document.createTextNode(part)]))
+    title.replaceChildren(
+      ...wordBreak(expanded ? fullTitle : shortTitle).flatMap((part, index) =>
+        index ? [document.createElement('wbr'), document.createTextNode(part)] : [document.createTextNode(part)],
+      ),
+    )
     title.title = fullTitle
     expandTitle.hidden = fullTitle === shortTitle
     expandTitle.setAttribute('aria-expanded', String(expanded))
     expandTitle.textContent = expanded ? 'Collapse' : 'Show full name'
   }
   const close = (restoreFocus = false) => {
-    clearTimeout(timer); clearTimeout(closeTimer); intent++
+    clearTimeout(timer)
+    clearTimeout(closeTimer)
+    intent++
     const trigger = current
-    current = undefined; pinned = false; shown = false
+    current = undefined
+    pinned = false
+    shown = false
     if (panel.matches(':popover-open')) panel.hidePopover()
     trigger?.removeAttribute('aria-details')
     if (restoreFocus && trigger?.isConnected) {
-      restoringFocus = true; trigger.focus({ preventScroll: true }); restoringFocus = false
+      restoringFocus = true
+      trigger.focus({ preventScroll: true })
+      restoringFocus = false
     }
   }
-  dispose = () => { close(); controller.abort() }
-  const place = () => { if (current) positionLinkPreview(panel, current) }
+  dispose = () => {
+    close()
+    controller.abort()
+  }
+  const place = () => {
+    if (current) positionLinkPreview(panel, current)
+  }
   const candidate = (target: EventTarget | null) => linkPreviewCandidate(target, location.href)
   // Signal the same preview behavior on every eligible link without fetching it.
   for (const link of document.querySelectorAll<HTMLAnchorElement>('a[href]')) {
@@ -75,16 +109,18 @@ export function initLinkPreviews() {
   const load = (endpoint: string) => {
     if (cache.has(endpoint)) return Promise.resolve(cache.get(endpoint)!)
     if (pending.has(endpoint)) return pending.get(endpoint)!
-    const request = fetch(endpoint, { signal }).then(async (response) => {
-      if (!response.ok) throw new Error('Preview unavailable')
-      const value: unknown = await response.json()
-      if (!validPreview(value)) throw new Error('Invalid preview')
-      if (!signal.aborted) {
-        cache.set(endpoint, value)
-        if (cache.size > 64) cache.delete(cache.keys().next().value!)
-      }
-      return value
-    }).finally(() => pending.delete(endpoint))
+    const request = fetch(endpoint, { signal })
+      .then(async (response) => {
+        if (!response.ok) throw new Error('Preview unavailable')
+        const value: unknown = await response.json()
+        if (!validPreview(value)) throw new Error('Invalid preview')
+        if (!signal.aborted) {
+          cache.set(endpoint, value)
+          if (cache.size > 64) cache.delete(cache.keys().next().value!)
+        }
+        return value
+      })
+      .finally(() => pending.delete(endpoint))
     pending.set(endpoint, request)
     return request
   }
@@ -94,7 +130,8 @@ export function initLinkPreviews() {
     markLinkPreview(link)
     close()
     const ticket = ++intent
-    current = link; pinned = focus
+    current = link
+    pinned = focus
     try {
       let preview = await load(target.endpoint)
       const fragment = decodeURIComponent(target.url.hash.slice(1))
@@ -107,17 +144,24 @@ export function initLinkPreviews() {
       fullTitle = preview.title
       shortTitle = abbreviateNamespace(fullTitle)
       renderTitle(false)
-      panel.querySelector('[data-preview-description]')!.textContent = preview.description || 'Read the reference for this declaration.'
+      panel.querySelector('[data-preview-description]')!.textContent =
+        preview.description || 'Read the reference for this declaration.'
       for (const field of ['detail', 'signature'] as const) {
         const element = panel.querySelector<HTMLElement>(`[data-preview-${field}]`)!
-        const text = field === 'detail' ? [link.dataset.previewContext, preview.detail].filter(Boolean).join(' ') : preview.signature
-        element.textContent = text ?? ''; element.hidden = !text
+        const text =
+          field === 'detail'
+            ? [link.dataset.previewContext, preview.detail].filter(Boolean).join(' ')
+            : preview.signature
+        element.textContent = text ?? ''
+        element.hidden = !text
       }
       const open = panel.querySelector<HTMLAnchorElement>('[data-preview-open]')!
       open.href = destination.href
       panel.setAttribute('aria-label', `${preview.title} preview`)
       link.setAttribute('aria-details', panel.id)
-      panel.showPopover({ source: link }); shown = true; place()
+      panel.showPopover({ source: link })
+      shown = true
+      place()
       if (focus) open.focus()
     } catch {
       if (ticket !== intent || signal.aborted) return
@@ -128,11 +172,14 @@ export function initLinkPreviews() {
   }
   const schedule = (link: HTMLAnchorElement | undefined) => {
     if (!link || pinned || restoringFocus) return
-    clearTimeout(timer); clearTimeout(closeTimer)
+    clearTimeout(timer)
+    clearTimeout(closeTimer)
     if (current === link) return
     // A new target owns the intent immediately, even while its dwell timer runs.
     close()
-    timer = setTimeout(() => { void show(link) }, 180)
+    timer = setTimeout(() => {
+      void show(link)
+    }, 180)
   }
   const dismissUnused = () => {
     clearTimeout(closeTimer)
@@ -140,43 +187,85 @@ export function initLinkPreviews() {
       if (!pinned && !panel.matches(':hover, :focus-within') && !current?.matches(':hover, :focus')) close()
     }, 180)
   }
-  document.addEventListener('pointerover', (event) => {
-    if (event.pointerType === 'mouse' || event.pointerType === 'pen') schedule(candidate(event.target))
-  }, { signal })
-  document.addEventListener('focusin', (event) => {
-    if (restoringFocus || (event.target instanceof Node && panel.contains(event.target))) return
-    const link = candidate(event.target)
-    if (link) schedule(link)
-    else close()
-  }, { signal })
-  document.addEventListener('beforetoggle', (event) => {
-    if ((event as ToggleEvent).newState === 'open' && event.target instanceof Element
-      && event.target !== panel && event.target.matches('.reference-link-preview')) close()
-  }, { signal, capture: true })
-  document.addEventListener('pointerout', (event) => {
-    const link = candidate(event.target)
-    if (link && !(event.relatedTarget instanceof Node && link.contains(event.relatedTarget))) clearTimeout(timer)
-    dismissUnused()
-  }, { signal })
+  document.addEventListener(
+    'pointerover',
+    (event) => {
+      if (event.pointerType === 'mouse' || event.pointerType === 'pen') schedule(candidate(event.target))
+    },
+    { signal },
+  )
+  document.addEventListener(
+    'focusin',
+    (event) => {
+      if (restoringFocus || (event.target instanceof Node && panel.contains(event.target))) return
+      const link = candidate(event.target)
+      if (link) schedule(link)
+      else close()
+    },
+    { signal },
+  )
+  document.addEventListener(
+    'beforetoggle',
+    (event) => {
+      if (
+        (event as ToggleEvent).newState === 'open' &&
+        event.target instanceof Element &&
+        event.target !== panel &&
+        event.target.matches('.reference-link-preview')
+      )
+        close()
+    },
+    { signal, capture: true },
+  )
+  document.addEventListener(
+    'pointerout',
+    (event) => {
+      const link = candidate(event.target)
+      if (link && !(event.relatedTarget instanceof Node && link.contains(event.relatedTarget))) clearTimeout(timer)
+      dismissUnused()
+    },
+    { signal },
+  )
   document.addEventListener('focusout', dismissUnused, { signal })
-  document.addEventListener('click', (event) => {
-    const link = candidate(event.target)
-    if (!link || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return
-    if (linkPreviewTarget(link.href, location.origin)?.glossary) { event.preventDefault(); void show(link, true) }
-    else close()
-  // Intercept glossary activation before Astro's document-level navigation handler.
-  }, { signal, capture: true })
+  document.addEventListener(
+    'click',
+    (event) => {
+      const link = candidate(event.target)
+      if (!link || event.button !== 0 || event.ctrlKey || event.metaKey || event.shiftKey || event.altKey) return
+      if (linkPreviewTarget(link.href, location.origin)?.glossary) {
+        event.preventDefault()
+        void show(link, true)
+      } else close()
+      // Intercept glossary activation before Astro's document-level navigation handler.
+    },
+    { signal, capture: true },
+  )
   panel.querySelector('[data-preview-close]')!.addEventListener('click', () => close(true), { signal })
-  expandTitle.addEventListener('click', () => {
-    renderTitle(expandTitle.getAttribute('aria-expanded') !== 'true')
-    place()
-  }, { signal })
-  document.addEventListener('keydown', (event) => {
-    if (event.key === 'Escape' && (current || panel.matches(':popover-open'))) { event.preventDefault(); close(pinned) }
-  }, { signal, capture: true })
-  panel.addEventListener('toggle', (event) => {
-    if ((event as ToggleEvent).newState === 'closed' && shown && !panel.matches(':popover-open')) close()
-  }, { signal })
+  expandTitle.addEventListener(
+    'click',
+    () => {
+      renderTitle(expandTitle.getAttribute('aria-expanded') !== 'true')
+      place()
+    },
+    { signal },
+  )
+  document.addEventListener(
+    'keydown',
+    (event) => {
+      if (event.key === 'Escape' && (current || panel.matches(':popover-open'))) {
+        event.preventDefault()
+        close(pinned)
+      }
+    },
+    { signal, capture: true },
+  )
+  panel.addEventListener(
+    'toggle',
+    (event) => {
+      if ((event as ToggleEvent).newState === 'closed' && shown && !panel.matches(':popover-open')) close()
+    },
+    { signal },
+  )
   window.addEventListener('resize', place, { signal })
   window.addEventListener('scroll', place, { signal, passive: true, capture: true })
 }
diff --git a/site/src/lib/link-preview-paint.ts b/site/src/lib/link-preview-paint.ts
index 5b7c03b52..6f2a58b8d 100644
--- a/site/src/lib/link-preview-paint.ts
+++ b/site/src/lib/link-preview-paint.ts
@@ -2,21 +2,36 @@
 export function createLinkPreviewPolicy() {
   function target(href: string, origin: string) {
     let url: URL
-    try { url = new URL(href, origin) } catch { return undefined }
+    try {
+      url = new URL(href, origin)
+    } catch {
+      return undefined
+    }
     const reference = /\/reference\/[^/]+\/$/.test(url.pathname)
-    const protocolObject = /\/mcp\/(?:tools\/[^/]+|prompts\/[^/]+|resources\/(?:templates\/)?[^/]+)\/$/.test(url.pathname)
-      && !url.pathname.endsWith('/mcp/resources/templates/')
+    const protocolObject =
+      /\/mcp\/(?:tools\/[^/]+|prompts\/[^/]+|resources\/(?:templates\/)?[^/]+)\/$/.test(url.pathname) &&
+      !url.pathname.endsWith('/mcp/resources/templates/')
     if (url.origin !== origin || url.search || (!reference && !protocolObject)) return undefined
-    return { url, endpoint: `${url.pathname.slice(0, -1)}.preview.json`, glossary: url.pathname.endsWith('/reference/glossary/') }
+    return {
+      url,
+      endpoint: `${url.pathname.slice(0, -1)}.preview.json`,
+      glossary: url.pathname.endsWith('/reference/glossary/'),
+    }
   }
   function candidate(eventTarget: EventTarget | null, base: string): HTMLAnchorElement | undefined {
     const link = eventTarget instanceof Element ? eventTarget.closest<HTMLAnchorElement>('a[href]') : null
-    if (!link || link.matches('[data-preview-skip], [href^="#"], .api-heading-link, .api-index-card__link, .headerlink')
-      || link.closest('nav, footer, [data-doc-picker], .api-index-card, .reference-link-preview')) return undefined
+    if (
+      !link ||
+      link.matches('[data-preview-skip], [href^="#"], .api-heading-link, .api-index-card__link, .headerlink') ||
+      link.closest('nav, footer, [data-doc-picker], .api-index-card, .reference-link-preview')
+    )
+      return undefined
     try {
       const url = new URL(link.getAttribute('href')!, base)
       return target(url.href, new URL(base).origin) ? link : undefined
-    } catch { return undefined }
+    } catch {
+      return undefined
+    }
   }
   function mark(link: HTMLAnchorElement) {
     link.dataset.linkPreview = ''
@@ -28,7 +43,11 @@ export function createLinkPreviewPolicy() {
   return { target, candidate, mark }
 }
 
-export const { target: linkPreviewTarget, candidate: linkPreviewCandidate, mark: markLinkPreview } = createLinkPreviewPolicy()
+export const {
+  target: linkPreviewTarget,
+  candidate: linkPreviewCandidate,
+  mark: markLinkPreview,
+} = createLinkPreviewPolicy()
 
 /** Serialized into the shared head; keep dependencies in the supplied policy. */
 export function initializeLinkPreviewPaint(policy: ReturnType<typeof createLinkPreviewPolicy>) {
@@ -49,9 +68,10 @@ export function initializeLinkPreviewPaint(policy: ReturnType<typeof createLinkP
       // Observe parsed subtrees, without rescanning anchors already encountered.
       const observe = (records: MutationRecord[]) => {
         const added = new Set<Element>()
-        for (const record of records) for (const node of record.addedNodes) {
-          if (node instanceof Element) added.add(node)
-        }
+        for (const record of records)
+          for (const node of record.addedNodes) {
+            if (node instanceof Element) added.add(node)
+          }
         for (const node of added) {
           let ancestor = node.parentElement
           while (ancestor && !added.has(ancestor)) ancestor = ancestor.parentElement
@@ -60,10 +80,14 @@ export function initializeLinkPreviewPaint(policy: ReturnType<typeof createLinkP
       }
       const observer = new MutationObserver(observe)
       observer.observe(document.documentElement, { childList: true, subtree: true })
-      document.addEventListener('DOMContentLoaded', () => {
-        observe(observer.takeRecords())
-        observer.disconnect()
-      }, { once: true })
+      document.addEventListener(
+        'DOMContentLoaded',
+        () => {
+          observe(observer.takeRecords())
+          observer.disconnect()
+        },
+        { once: true },
+      )
     }
   }
   // NativeShell shares this startup script but does not enable previews itself.
diff --git a/site/src/lib/link-preview.ts b/site/src/lib/link-preview.ts
index 025189534..48290a831 100644
--- a/site/src/lib/link-preview.ts
+++ b/site/src/lib/link-preview.ts
@@ -1,6 +1,12 @@
 import { docSummaryText, qualifiedNameOf, sourceUrl, type ApiModel, type ApiSymbol } from '@libtmux/api-model'
 import { productApiHref } from './product-api'
-import { API_GLOSSARY_GROUPS, ALL_GLOSSARY_GROUPS, API_GLOSSARY_PATH, MCP_GLOSSARY_TITLE, MCP_GLOSSARY_DESCRIPTION } from './api-glossary'
+import {
+  API_GLOSSARY_GROUPS,
+  ALL_GLOSSARY_GROUPS,
+  API_GLOSSARY_PATH,
+  MCP_GLOSSARY_TITLE,
+  MCP_GLOSSARY_DESCRIPTION,
+} from './api-glossary'
 
 /** Small, inert metadata shared by reference links and their preview cards. */
 export interface LinkPreview {
@@ -18,21 +24,39 @@ export interface LinkPreview {
 export function symbolPreview(model: ApiModel, symbol: ApiSymbol, version: string): LinkPreview {
   const summary = symbol.doc?.summary ?? symbol.signatures.find((signature) => signature.doc?.summary)?.doc?.summary
   return {
-    schema: 1, title: qualifiedNameOf(symbol), kind: symbol.command?.kind ?? symbol.kind,
+    schema: 1,
+    title: qualifiedNameOf(symbol),
+    kind: symbol.command?.kind ?? symbol.kind,
     description: summary ? docSummaryText(summary, model.port) : '',
     signature: symbol.signatures[0]?.raw,
     detail: symbol.signatures.length > 1 ? `${symbol.signatures.length} signatures in the full reference.` : undefined,
-    href: productApiHref(model, symbol, version), source: sourceUrl(model, symbol),
+    href: productApiHref(model, symbol, version),
+    source: sourceUrl(model, symbol),
   }
 }
 
 export function glossaryPreview(href: string): LinkPreview {
   const mcp = href.includes('/mcp/reference/')
   const groups = mcp || href === API_GLOSSARY_PATH ? ALL_GLOSSARY_GROUPS : API_GLOSSARY_GROUPS
-  return { schema: 1, title: mcp ? MCP_GLOSSARY_TITLE : 'API glossary', description: mcp ? MCP_GLOSSARY_DESCRIPTION : 'Definitions of API kinds, modifiers, packages, and MCP annotations.', href,
-    terms: Object.fromEntries(groups.flatMap((group) => group.terms.map((term) => [term.id, {
-      schema: 1, title: term.id, kind: term.id, description: term.definition, detail: term.detail,
-      href: `${href}#${term.id}`,
-    } satisfies LinkPreview]))),
+  return {
+    schema: 1,
+    title: mcp ? MCP_GLOSSARY_TITLE : 'API glossary',
+    description: mcp ? MCP_GLOSSARY_DESCRIPTION : 'Definitions of API kinds, modifiers, packages, and MCP annotations.',
+    href,
+    terms: Object.fromEntries(
+      groups.flatMap((group) =>
+        group.terms.map((term) => [
+          term.id,
+          {
+            schema: 1,
+            title: term.id,
+            kind: term.id,
+            description: term.definition,
+            detail: term.detail,
+            href: `${href}#${term.id}`,
+          } satisfies LinkPreview,
+        ]),
+      ),
+    ),
   }
 }
diff --git a/site/src/lib/llms.ts b/site/src/lib/llms.ts
index 3417bb47b..a90a0e62c 100644
--- a/site/src/lib/llms.ts
+++ b/site/src/lib/llms.ts
@@ -6,7 +6,16 @@ import { getCollection } from 'astro:content'
 import { qualifiedNameOf } from '@libtmux/api-model'
 import type { CollectionEntry } from 'astro:content'
 import { resolvePortCode } from '../plugins/remark-port-code.mjs'
-import { PORTS, PORT_BY_SLUG, hasReference, portPageUrl, productApiPath, productAvailable, referenceUrl, workspaceOverviewNotice } from './ports.ts'
+import {
+  PORTS,
+  PORT_BY_SLUG,
+  hasReference,
+  portPageUrl,
+  productApiPath,
+  productAvailable,
+  referenceUrl,
+  workspaceOverviewNotice,
+} from './ports.ts'
 import { DEFAULT_LOCALE } from '../i18n/locales.ts'
 import { buildLocale, localeOf, sourceIdOf } from '../i18n/resolve.ts'
 import { buildTarget } from './versions.ts'
@@ -35,7 +44,8 @@ export interface LlmsPage {
 function sectionOf(entry: CollectionEntry<'docs'>): string {
   const group = entry.data.sidebar?.group
   if (group) return group
-  if (entry.data.product) return `${PORT_BY_SLUG[entry.data.port!].name} ${entry.data.product === 'mcp' ? 'MCP' : 'Workspace Manager'}`
+  if (entry.data.product)
+    return `${PORT_BY_SLUG[entry.data.port!].name} ${entry.data.product === 'mcp' ? 'MCP' : 'Workspace Manager'}`
   const [first] = docsPath(entry).split('/')
   return first === entry.id ? 'Overview' : first[0].toUpperCase() + first.slice(1)
 }
@@ -50,19 +60,30 @@ export async function llmsPages(origin: string, base: string): Promise<LlmsPage[
   // Default locale only. A translation is a different document at a different
   // URL, and listing `ja/concepts` beside `concepts` in one file would hand an
   // agent the same page twice in two languages.
-  const entries = docsEntriesAvailable(await getCollection(
-    'docs',
-    (entry) =>
-      localeOf(entry.id) === DEFAULT_LOCALE &&
-      (locale === DEFAULT_LOCALE || Boolean(port) || entry.data.port === undefined),
-  ), port)
+  const entries = docsEntriesAvailable(
+    await getCollection(
+      'docs',
+      (entry) =>
+        localeOf(entry.id) === DEFAULT_LOCALE &&
+        (locale === DEFAULT_LOCALE || Boolean(port) || entry.data.port === undefined),
+    ),
+    port,
+  )
   // The same page the routes serve: a translation where this locale has one,
   // so a section and that page's `.md` twin stay one text rather than two.
   let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
-  const translations = new Map(locale === DEFAULT_LOCALE ? []
-    : localeProse(await getCollection('docs'), locale, port, defaults)
-      .map(({ entry, route }) => [route, entry] as const))
+  try {
+    defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  } catch {
+    /* Local defaults are latest. */
+  }
+  const translations = new Map(
+    locale === DEFAULT_LOCALE
+      ? []
+      : localeProse(await getCollection('docs'), locale, port, defaults).map(
+          ({ entry, route }) => [route, entry] as const,
+        ),
+  )
   return entries
     .map((entry) => llmsPage(translations.get(docsRoutePath(entry, port, defaults)) ?? entry, origin, base))
     .sort((a, b) => a.section.localeCompare(b.section) || a.order - b.order || a.title.localeCompare(b.title))
@@ -80,16 +101,27 @@ export async function llmsPages(origin: string, base: string): Promise<LlmsPage[
 export function llmsPage(entry: CollectionEntry<'docs'>, origin: string, base: string): LlmsPage & { order: number } {
   const port = process.env.LIBTMUX_DOCS_PORT || undefined
   let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
+  try {
+    defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  } catch {
+    /* Local defaults are latest. */
+  }
   const entryPort = entry.data.port
   const version = port ? buildTarget(process.env).version : (defaults[entryPort ?? ''] ?? 'latest')
   const path = docsRoutePath(entry, port, defaults)
   const url = `${origin}${entry.data.product && !port ? `${PORT_ROOT}/` : base}${path ? `${path}/` : ''}`
-  let body = resolvePortCode(linkProseMarkdown(entry.body ?? '', entryPort ?? port, entry.data.product, {
-    resolved: (href) => new URL(href, url).href,
-    authored: (href, owner) => new URL(proseHref(href, SITE_ROOT, owner,
-      owner === port ? version : defaults[owner ?? ''] ?? 'latest', PORT_ROOT), url).href,
-  }), port, entryPort)
+  let body = resolvePortCode(
+    linkProseMarkdown(entry.body ?? '', entryPort ?? port, entry.data.product, {
+      resolved: (href) => new URL(href, url).href,
+      authored: (href, owner) =>
+        new URL(
+          proseHref(href, SITE_ROOT, owner, owner === port ? version : (defaults[owner ?? ''] ?? 'latest'), PORT_ROOT),
+          url,
+        ).href,
+    }),
+    port,
+    entryPort,
+  )
   const cards = selectPortCards(entry.data.cards, entryPort ?? port)
   if (cards.length) {
     body += `\n\n${cards.map((card) => `- [${card.label}](${new URL(proseHref(card.href, SITE_ROOT, entryPort ?? port, version), url).href}): ${card.body}`).join('\n')}\n`
@@ -98,12 +130,17 @@ export function llmsPage(entry: CollectionEntry<'docs'>, origin: string, base: s
     const notice = workspaceOverviewNotice(PORT_BY_SLUG[entryPort])
     if (notice) body = `**${notice.title}** ${notice.body}\n\n${body}`
   }
-  if (entryPort && entry.data.product && productAvailable(PORT_BY_SLUG[entryPort], entry.data.product)
-    && docsPath(entry) === productApiPath(entry.data.product)) {
+  if (
+    entryPort &&
+    entry.data.product &&
+    productAvailable(PORT_BY_SLUG[entryPort], entry.data.product) &&
+    docsPath(entry) === productApiPath(entry.data.product)
+  ) {
     const model = API_MODELS[entryPort]
     const symbols = productApiRoots(model, entry.data.product)
     body += `\n\n## API declarations\n\n${symbols.map((symbol) => `- [${qualifiedNameOf(symbol)}](${origin}${productApiHref(model, symbol, version)})`).join('\n')}\n`
-    if (entry.data.product === 'mcp' && MCP_REFERENCE[entryPort]) body += `\n[Protocol catalog](${origin}${portPageUrl(PORT_BY_SLUG[entryPort], version, 'mcp/tools').replace(/\/$/, '.json')})\n`
+    if (entry.data.product === 'mcp' && MCP_REFERENCE[entryPort])
+      body += `\n[Protocol catalog](${origin}${portPageUrl(PORT_BY_SLUG[entryPort], version, 'mcp/tools').replace(/\/$/, '.json')})\n`
   }
   // A locale's landing entry routes to '', which is the root itself.
   return {
@@ -129,11 +166,13 @@ export function localeProse<T extends DocsPage>(
   port?: string,
   defaults: Record<string, string> = {},
 ): { entry: T; route: string }[] {
-  return docsEntriesAvailable(entries.filter((entry) => localeOf(entry.id) === locale), port)
-    .map((entry) => {
-      const source = { ...entry, id: sourceIdOf(entry.id) } as T
-      return { entry: source, route: docsRoutePath(source, port, defaults) }
-    })
+  return docsEntriesAvailable(
+    entries.filter((entry) => localeOf(entry.id) === locale),
+    port,
+  ).map((entry) => {
+    const source = { ...entry, id: sourceIdOf(entry.id) } as T
+    return { entry: source, route: docsRoutePath(source, port, defaults) }
+  })
 }
 
 /** The one-line header both files share, naming the port when there is one. */
@@ -161,7 +200,8 @@ export function llmsHeader(): { title: string; blurb: string } {
  * ecosystem host, so only the former needs the origin.
  */
 export function referenceLine(origin: string): string | null {
-  if (buildsTmuxDocumentation()) return `- [tmux manual](${origin}${tmuxManualUrl()}): versioned command syntax and the tmux manual.\n- [tmux C source reference](${origin}${tmuxReferenceUrl()}): internal C declarations, members and source links by tmux version.`
+  if (buildsTmuxDocumentation())
+    return `- [tmux manual](${origin}${tmuxManualUrl()}): versioned command syntax and the tmux manual.\n- [tmux C source reference](${origin}${tmuxReferenceUrl()}): internal C declarations, members and source links by tmux version.`
   const port = process.env.LIBTMUX_DOCS_PORT || undefined
   const p = port ? PORT_BY_SLUG[port] : undefined
   if (!p || !hasReference(p)) return null
diff --git a/site/src/lib/markdown-twins.ts b/site/src/lib/markdown-twins.ts
index 0f9fd9975..8366b0269 100644
--- a/site/src/lib/markdown-twins.ts
+++ b/site/src/lib/markdown-twins.ts
@@ -26,7 +26,14 @@ export function symbolSource(model: ApiModel | SourceApiModel, symbol?: ApiSymbo
   const ref = symbol?.source.revision ?? model.revision
   return symbol?.source.file && !model.generatedSources?.[symbol?.source.file] && repo && ref
     ? { repo, path: symbol?.source.file, ref }
-    : { repo: CONTRIBUTE_REPO, path: 'port' in model ? `site/src/data/api/${model.port}.json` : `site/src/data/${model.project}/api/${model.version}.json`, ref: CONTRIBUTE_BRANCH }
+    : {
+        repo: CONTRIBUTE_REPO,
+        path:
+          'port' in model
+            ? `site/src/data/api/${model.port}.json`
+            : `site/src/data/${model.project}/api/${model.version}.json`,
+        ref: CONTRIBUTE_BRANCH,
+      }
 }
 
 /**
diff --git a/site/src/lib/mcp-catalog.ts b/site/src/lib/mcp-catalog.ts
index 0078abb92..b308645e0 100644
--- a/site/src/lib/mcp-catalog.ts
+++ b/site/src/lib/mcp-catalog.ts
@@ -69,20 +69,36 @@ export function mcpObjects(port: string): McpObject[] {
     const section = kind === 'tool' ? 'tools' : kind === 'prompt' ? 'prompts' : 'resources'
     for (const entry of entries) {
       const name = 'wireName' in entry ? entry.wireName : entry.name
-      const identity = 'uriTemplate' in entry && entry.uriTemplate || 'uri' in entry && entry.uri || name
-      const segment = kind === 'tool' ? name : name.toLowerCase().replace(/[^a-z0-9_-]+/g, '-').replace(/^-|-$/g, '')
+      const identity = ('uriTemplate' in entry && entry.uriTemplate) || ('uri' in entry && entry.uri) || name
+      const segment =
+        kind === 'tool'
+          ? name
+          : name
+              .toLowerCase()
+              .replace(/[^a-z0-9_-]+/g, '-')
+              .replace(/^-|-$/g, '')
       if (!segment) throw new Error(`MCP object needs a route: ${port}/${kind}/${name}`)
       const slug = `${kind === 'resource-template' ? 'templates/' : ''}${segment}`
-      rows.push({ id: `mcp.${kind}.${identity}`, name, kind, section, slug,
-        path: `mcp/${section}/${slug}`, description: entry.description ?? '',
-        ...('wireName' in entry ? { tool: entry } : { item: entry }) })
+      rows.push({
+        id: `mcp.${kind}.${identity}`,
+        name,
+        kind,
+        section,
+        slug,
+        path: `mcp/${section}/${slug}`,
+        description: entry.description ?? '',
+        ...('wireName' in entry ? { tool: entry } : { item: entry }),
+      })
     }
   }
   add('tool', reference.registrations)
   add('prompt', reference.protocol.prompts)
   add('resource', reference.protocol.resources)
   add('resource-template', reference.protocol.resourceTemplates)
-  if (new Set(rows.map((row) => row.path)).size !== rows.length || new Set(rows.map((row) => row.id)).size !== rows.length) {
+  if (
+    new Set(rows.map((row) => row.path)).size !== rows.length ||
+    new Set(rows.map((row) => row.id)).size !== rows.length
+  ) {
     throw new Error(`Duplicate MCP object identity or route in ${port}`)
   }
   objects.set(port, rows)
@@ -94,13 +110,17 @@ export function resolveMcpObject(port: string, text: string, kind?: McpKind): Mc
   const explicit = /^mcp:(tool|prompt|resource|resource-template):(.+)$/.exec(text)
   const target = explicit?.[2] ?? text
   const family = explicit?.[1] ?? kind
-  const matches = mcpObjects(port).filter((entry) => (!family || entry.kind === family) &&
-    [entry.name, entry.item?.uri, entry.item?.uriTemplate].includes(target))
+  const matches = mcpObjects(port).filter(
+    (entry) =>
+      (!family || entry.kind === family) && [entry.name, entry.item?.uri, entry.item?.uriTemplate].includes(target),
+  )
   return matches.length === 1 ? matches[0] : undefined
 }
 
 export function mcpObjectAt(port: string, section: McpSection, slug?: string): McpObject | undefined {
-  return slug === undefined ? undefined : mcpObjects(port).find((entry) => entry.section === section && entry.slug === slug)
+  return slug === undefined
+    ? undefined
+    : mcpObjects(port).find((entry) => entry.section === section && entry.slug === slug)
 }
 
 export type McpMentionDecision =
@@ -109,7 +129,10 @@ export type McpMentionDecision =
   | { kind: 'unresolved'; why: string; tried: string[] }
 
 /** Shared by the renderer and source lint; undefined delegates to the language API. */
-export function decideMcpMention(text: string, context: Pick<MentionContext, 'pagePort' | 'before' | 'product'>): McpMentionDecision | undefined {
+export function decideMcpMention(
+  text: string,
+  context: Pick<MentionContext, 'pagePort' | 'before' | 'product'>,
+): McpMentionDecision | undefined {
   const explicit = text.startsWith('mcp:')
   if (!explicit && context.product !== 'mcp') return undefined
   const owner = (context.before && portFromSentence(context.before)) || context.pagePort
@@ -119,13 +142,22 @@ export function decideMcpMention(text: string, context: Pick<MentionContext, 'pa
     return object ? [{ port, object }] : []
   })
   if (matches.length === 1) return { kind: 'link', ...matches[0]! }
-  if (explicit) return { kind: 'unresolved',
-    why: matches.length ? 'MCP reference needs a port' : 'MCP object not advertised in the stated port', tried: ports }
+  if (explicit)
+    return {
+      kind: 'unresolved',
+      why: matches.length ? 'MCP reference needs a port' : 'MCP object not advertised in the stated port',
+      tried: ports,
+    }
   if (matches.length > 1) return { kind: 'skip', why: 'MCP reference needs a port' }
   // A same-name tool and prompt need an explicit kind, even if a language
   // declaration also has that name.
-  if (ports.some((port) => mcpObjects(port).filter((object) =>
-    [object.name, object.item?.uri, object.item?.uriTemplate].includes(text)).length > 1)) {
+  if (
+    ports.some(
+      (port) =>
+        mcpObjects(port).filter((object) => [object.name, object.item?.uri, object.item?.uriTemplate].includes(text))
+          .length > 1,
+    )
+  ) {
     return { kind: 'skip', why: 'MCP reference needs an object kind' }
   }
   return undefined
diff --git a/site/src/lib/mcp-preview.ts b/site/src/lib/mcp-preview.ts
index 30e1e6bb7..d7937bc82 100644
--- a/site/src/lib/mcp-preview.ts
+++ b/site/src/lib/mcp-preview.ts
@@ -7,13 +7,20 @@ import { PORT_BY_SLUG, portPageUrl } from './ports'
 export function mcpObjectPreview(port: string, version: string, object: McpObject): LinkPreview {
   const source = object.tool?.source
   return {
-    schema: 1, title: object.name, kind: object.kind,
+    schema: 1,
+    title: object.name,
+    kind: object.kind,
     description: docSummaryText(object.description.split(/\n\s*\n/, 1)[0], port),
     signature: object.item?.uriTemplate ?? object.item?.uri,
-    detail: object.tool?.enabledByDefault === false
-      ? object.tool.enableOption ? `Enable with ${object.tool.enableOption}.` : 'Disabled in the default configuration.'
-      : undefined,
+    detail:
+      object.tool?.enabledByDefault === false
+        ? object.tool.enableOption
+          ? `Enable with ${object.tool.enableOption}.`
+          : 'Disabled in the default configuration.'
+        : undefined,
     href: portPageUrl(PORT_BY_SLUG[port], version, object.path),
-    source: source ? `https://github.com/${source.repo}/blob/${source.revision}/${source.file}${source.line ? `#L${source.line}` : ''}` : undefined,
+    source: source
+      ? `https://github.com/${source.repo}/blob/${source.revision}/${source.file}${source.line ? `#L${source.line}` : ''}`
+      : undefined,
   }
 }
diff --git a/site/src/lib/mcp-reference.ts b/site/src/lib/mcp-reference.ts
index 023625e8e..2682c389f 100644
--- a/site/src/lib/mcp-reference.ts
+++ b/site/src/lib/mcp-reference.ts
@@ -1,4 +1,12 @@
-import { MCP_REFERENCE, MCP_SECTIONS, mcpObjects, resolveMcpObject, type McpRegistration, type McpObject, type McpSection } from './mcp-catalog'
+import {
+  MCP_REFERENCE,
+  MCP_SECTIONS,
+  mcpObjects,
+  resolveMcpObject,
+  type McpRegistration,
+  type McpObject,
+  type McpSection,
+} from './mcp-catalog'
 import { createMarkdownProcessor } from '@astrojs/markdown-remark'
 import { PORT_BY_SLUG, portPageUrl } from './ports'
 import { createHash } from 'node:crypto'
@@ -21,8 +29,13 @@ const TOOL_GROUPS = [
   ['Server', /(?:server|^list_sessions$|^create_session$|^tmux_capabilities$|^tmux_snapshot$)/],
   ['Session', /(?:session|^list_windows$|^create_window$)/],
   ['Window', /(?:window|layout|^list_panes$)/],
-  ['Pane', /(?:pane|capture|snapshot|keys|paste_text|run_(?:shell_)?command|^tmux_(?:capture|wait|create|send|close|run)$)/],
-  ['Buffers', /buffer/], ['Hooks', /hook/], ['Options and environment', /option|environment|history_limit|mouse|synchronize/],
+  [
+    'Pane',
+    /(?:pane|capture|snapshot|keys|paste_text|run_(?:shell_)?command|^tmux_(?:capture|wait|create|send|close|run)$)/,
+  ],
+  ['Buffers', /buffer/],
+  ['Hooks', /hook/],
+  ['Options and environment', /option|environment|history_limit|mouse|synchronize/],
   ['Coordination', /channel/],
 ] as const
 export function mcpObjectGroup(object: McpObject): string {
@@ -37,24 +50,47 @@ export function mcpNavigation(port: string): { tree: TreeBucket[]; json: ApiTree
   const entries = mcpObjects(port)
   const tree: TreeBucket[] = Object.entries(MCP_SECTIONS).map(([section, label]) => {
     const selected = entries.filter((entry) => entry.section === section)
-    const order: string[] = [...TOOL_GROUPS.map(([name]) => name), 'Other tools', 'Workflows', 'Fixed resources', 'Resource templates']
+    const order: string[] = [
+      ...TOOL_GROUPS.map(([name]) => name),
+      'Other tools',
+      'Workflows',
+      'Fixed resources',
+      'Resource templates',
+    ]
     const groups = [...new Set(selected.map(mcpObjectGroup))].sort((a, b) => order.indexOf(a) - order.indexOf(b))
-    return { id: section, label, collapsed: false, entries: [],
+    return {
+      id: section,
+      label,
+      collapsed: false,
+      entries: [],
       target: { id: `mcp.${section}`, name: label, slug: section, kind: 'mcp-section' },
-      children: groups.map((group) => ({ id: `${section}-${group.toLowerCase().replaceAll(' ', '-')}`, label: group,
-        collapsed: false, children: [], entries: selected.filter((entry) => mcpObjectGroup(entry) === group)
-          .map((entry) => ({ id: entry.id, name: entry.name, slug: entry.path.slice(4), kind: entry.kind })) })) }
+      children: groups.map((group) => ({
+        id: `${section}-${group.toLowerCase().replaceAll(' ', '-')}`,
+        label: group,
+        collapsed: false,
+        children: [],
+        entries: selected
+          .filter((entry) => mcpObjectGroup(entry) === group)
+          .map((entry) => ({ id: entry.id, name: entry.name, slug: entry.path.slice(4), kind: entry.kind })),
+      })),
+    }
   })
   const bucket = (entry: TreeBucket): ApiTreeJson['buckets'][number] => ({
-    id: entry.id, label: entry.label, count: entry.entries.length + entry.children.reduce((n, child) => n + child.entries.length, 0),
+    id: entry.id,
+    label: entry.label,
+    count: entry.entries.length + entry.children.reduce((n, child) => n + child.entries.length, 0),
     slug: entry.target?.slug ?? entry.entries[0]?.slug ?? null,
     types: entry.entries.map((row) => {
       const object = entries.find((entry) => entry.id === row.id)!
       return { ...row, m: 0, category: object.section, summary: toolSummary(object.description) }
-    }), children: entry.children.map(bucket),
+    }),
+    children: entry.children.map(bucket),
   })
   const json = { port, buckets: tree.map(bucket), members: {} }
-  const version = `mcp-1:${createHash('sha256').update(JSON.stringify([MCP_REFERENCE[port], json])).digest('hex').slice(0, 20)}`
+  const version = `mcp-1:${createHash('sha256')
+    .update(JSON.stringify([MCP_REFERENCE[port], json]))
+    .digest('hex')
+    .slice(0, 20)}`
   return { tree, json, version }
 }
 
@@ -65,27 +101,59 @@ const TOOL_OPERATIONS: Record<string, Record<string, string>> = {
 }
 
 /** Resolve an equivalent operation to the target port's actual wire registration. */
-export function equivalentMcpTool(sourcePort: string, wireName: string, targetPort: string): McpRegistration | undefined {
+export function equivalentMcpTool(
+  sourcePort: string,
+  wireName: string,
+  targetPort: string,
+): McpRegistration | undefined {
   const source = MCP_REFERENCE[sourcePort]?.registrations.find((tool) => tool.wireName === wireName)
   if (!source) return undefined
   const operation = TOOL_OPERATIONS[sourcePort]?.[source.name] ?? source.name
-  return MCP_REFERENCE[targetPort]?.registrations.find((tool) => (TOOL_OPERATIONS[targetPort]?.[tool.name] ?? tool.name) === operation)
+  return MCP_REFERENCE[targetPort]?.registrations.find(
+    (tool) => (TOOL_OPERATIONS[targetPort]?.[tool.name] ?? tool.name) === operation,
+  )
 }
 
 /** Shared route identity for rendered tools and downloadable protocol data. */
-export function mcpReferenceRoutes(buildPort: string | undefined, defaults: Record<string, string>, buildVersion: string) {
-  return Object.entries(MCP_REFERENCE).filter(([port]) => !buildPort || port === buildPort)
-    .flatMap(([port]) => (Object.keys(MCP_SECTIONS) as McpSection[]).flatMap((section) => [undefined, ...mcpObjects(port).filter((entry) => entry.section === section)].map((object) => {
-      const version = buildPort ? buildVersion : (defaults[port] ?? 'latest')
-      return { path: `${buildPort ? '' : `${port}/${version}/`}${object?.path ?? `mcp/${section}`}`,
-        port, section, itemSlug: object?.slug, toolName: object?.tool?.wireName, version }
-    })))
+export function mcpReferenceRoutes(
+  buildPort: string | undefined,
+  defaults: Record<string, string>,
+  buildVersion: string,
+) {
+  return Object.entries(MCP_REFERENCE)
+    .filter(([port]) => !buildPort || port === buildPort)
+    .flatMap(([port]) =>
+      (Object.keys(MCP_SECTIONS) as McpSection[]).flatMap((section) =>
+        [undefined, ...mcpObjects(port).filter((entry) => entry.section === section)].map((object) => {
+          const version = buildPort ? buildVersion : (defaults[port] ?? 'latest')
+          return {
+            path: `${buildPort ? '' : `${port}/${version}/`}${object?.path ?? `mcp/${section}`}`,
+            port,
+            section,
+            itemSlug: object?.slug,
+            toolName: object?.tool?.wireName,
+            version,
+          }
+        }),
+      ),
+    )
 }
 
 let markdown: ReturnType<typeof createMarkdownProcessor> | undefined
 
-interface ToolDescriptionContext { port: string; version: string; toolName?: string; objectId?: string }
-interface HtmlNode { type: string; tagName?: string; value?: string; properties?: Record<string, unknown>; children?: HtmlNode[] }
+interface ToolDescriptionContext {
+  port: string
+  version: string
+  toolName?: string
+  objectId?: string
+}
+interface HtmlNode {
+  type: string
+  tagName?: string
+  value?: string
+  properties?: Record<string, unknown>
+  children?: HtmlNode[]
+}
 
 function rehypeMcpToolLinks() {
   return (tree: unknown, file: { data: { astro?: { frontmatter?: { mcp?: ToolDescriptionContext } } } }) => {
@@ -93,15 +161,35 @@ function rehypeMcpToolLinks() {
     if (!context || !PORT_BY_SLUG[context.port]) return
     const target = (name: string) => {
       const object = resolveMcpObject(context.port, name)
-      return object && object.id !== context.objectId && !(object.kind === 'tool' && object.name === context.toolName) ? object : undefined
+      return object && object.id !== context.objectId && !(object.kind === 'tool' && object.name === context.toolName)
+        ? object
+        : undefined
     }
     const link = (object: McpObject, node: HtmlNode): HtmlNode => ({
-      type: 'element', tagName: 'a',
+      type: 'element',
+      tagName: 'a',
       properties: { href: portPageUrl(PORT_BY_SLUG[context.port], context.version, object.path) },
-      children: [{ type: 'element', tagName: 'span', properties: {
-        className: ['api-link-kind', 'api-nav__kind', `api-badge--kind-${object.kind}`],
-        ariaHidden: 'true', dataApiKind: object.kind, title: object.kind,
-      }, children: [{ type: 'element', tagName: 'span', properties: { className: ['api-badge__label'] }, children: [{ type: 'text', value: kindMark(object.kind) }] }] }, node],
+      children: [
+        {
+          type: 'element',
+          tagName: 'span',
+          properties: {
+            className: ['api-link-kind', 'api-nav__kind', `api-badge--kind-${object.kind}`],
+            ariaHidden: 'true',
+            dataApiKind: object.kind,
+            title: object.kind,
+          },
+          children: [
+            {
+              type: 'element',
+              tagName: 'span',
+              properties: { className: ['api-badge__label'] },
+              children: [{ type: 'text', value: kindMark(object.kind) }],
+            },
+          ],
+        },
+        node,
+      ],
     })
     const walk = (node: HtmlNode) => {
       if (!node.children || ['a', 'pre', 'script', 'style'].includes(node.tagName ?? '')) return
@@ -121,7 +209,10 @@ function rehypeMcpToolLinks() {
         for (const match of text.matchAll(/\b[a-z][a-z0-9]*_[a-z0-9_]+\b/g)) {
           const object = target(match[0])
           if (!object) continue
-          parts.push({ type: 'text', value: text.slice(start, match.index) }, link(object, { type: 'text', value: match[0] }))
+          parts.push(
+            { type: 'text', value: text.slice(start, match.index) },
+            link(object, { type: 'text', value: match[0] }),
+          )
           start = match.index + match[0].length
         }
         return [...parts, { type: 'text', value: text.slice(start) }]
@@ -138,5 +229,8 @@ export async function renderToolDescription(description: string, context?: ToolD
 }
 
 export function toolSummary(description: string): string {
-  return description.split(/\n\s*\n/, 1)[0].replace(/\s+/g, ' ').trim()
+  return description
+    .split(/\n\s*\n/, 1)[0]
+    .replace(/\s+/g, ' ')
+    .trim()
 }
diff --git a/site/src/lib/mcp-schema.ts b/site/src/lib/mcp-schema.ts
index 20f556e39..583878a7d 100644
--- a/site/src/lib/mcp-schema.ts
+++ b/site/src/lib/mcp-schema.ts
@@ -1,39 +1,77 @@
 /** JSON Schema pointers keep nested fields and definitions independently linkable. */
-export type McpSchema = boolean | { [key: string]: unknown; type?: string | string[]; description?: string;
-  properties?: Record<string, McpSchema>; required?: string[]; items?: McpSchema;
-  $ref?: string; $defs?: Record<string, McpSchema>; definitions?: Record<string, McpSchema>;
-  anyOf?: McpSchema[]; oneOf?: McpSchema[]; allOf?: McpSchema[] }
+export type McpSchema =
+  | boolean
+  | {
+      [key: string]: unknown
+      type?: string | string[]
+      description?: string
+      properties?: Record<string, McpSchema>
+      required?: string[]
+      items?: McpSchema
+      $ref?: string
+      $defs?: Record<string, McpSchema>
+      definitions?: Record<string, McpSchema>
+      anyOf?: McpSchema[]
+      oneOf?: McpSchema[]
+      allOf?: McpSchema[]
+    }
 
 export const pointerPart = (name: string) => name.replaceAll('~', '~0').replaceAll('/', '~1')
 export const schemaAnchor = (scope: string, pointer: string) => `${scope}${pointer}`
 
 const SCHEMA_TYPES: Record<string, string> = {
-  object: 'object', array: 'array', string: 'string', integer: 'numeric',
-  number: 'numeric', boolean: 'boolean', null: 'null',
+  object: 'object',
+  array: 'array',
+  string: 'string',
+  integer: 'numeric',
+  number: 'numeric',
+  boolean: 'boolean',
+  null: 'null',
+}
+export interface SchemaTypePart {
+  text: string
+  href?: string
 }
-export interface SchemaTypePart { text: string; href?: string }
 
 /** Link each type token, including references nested inside containers and unions. */
 export function schemaTypeParts(schema: McpSchema, root: McpSchema, scope: string): SchemaTypePart[] {
   const literal = (text: string): SchemaTypePart[] => [{ text }]
-  const primitive = (name: string): SchemaTypePart => ({ text: name,
-    ...(SCHEMA_TYPES[name] ? { href: `https://json-schema.org/understanding-json-schema/reference/${SCHEMA_TYPES[name]}` } : {}) })
-  const join = (parts: SchemaTypePart[][], separator: string) => parts.flatMap((part, i) => i ? [{ text: separator }, ...part] : part)
+  const primitive = (name: string): SchemaTypePart => ({
+    text: name,
+    ...(SCHEMA_TYPES[name]
+      ? { href: `https://json-schema.org/understanding-json-schema/reference/${SCHEMA_TYPES[name]}` }
+      : {}),
+  })
+  const join = (parts: SchemaTypePart[][], separator: string) =>
+    parts.flatMap((part, i) => (i ? [{ text: separator }, ...part] : part))
   if (typeof schema === 'boolean') return literal(schemaType(schema))
   if (schema.$ref) return [{ text: schemaType(schema), href: schemaReference(root, schema.$ref, scope) }]
   if (Object.hasOwn(schema, 'const') || Array.isArray(schema.enum)) return literal(schemaType(schema))
   const alternatives = schema.anyOf ?? schema.oneOf ?? schema.allOf
-  if (alternatives) return join(alternatives.map((part) => schemaTypeParts(part, root, scope)), schema.allOf ? ' & ' : ' | ')
-  const named = (name: string): SchemaTypePart[] => name === 'array'
-    ? [{ ...primitive('array'), text: 'Array' }, { text: '<' }, ...schemaTypeParts(schema.items ?? true, root, scope), { text: '>' }]
-    : [primitive(name)]
+  if (alternatives)
+    return join(
+      alternatives.map((part) => schemaTypeParts(part, root, scope)),
+      schema.allOf ? ' & ' : ' | ',
+    )
+  const named = (name: string): SchemaTypePart[] =>
+    name === 'array'
+      ? [
+          { ...primitive('array'), text: 'Array' },
+          { text: '<' },
+          ...schemaTypeParts(schema.items ?? true, root, scope),
+          { text: '>' },
+        ]
+      : [primitive(name)]
   return Array.isArray(schema.type) ? join(schema.type.map(named), ' | ') : named(schema.type ?? schemaType(schema))
 }
 
 export const isSchemaDefinition = (path: string) => /^\/(?:\$defs|definitions)\//.test(path)
 
 /** Named definitions have their own section while retaining original pointer identities. */
-export function schemaDefinitions(schema: McpSchema, pointer = ''): { name: string; path: string; schema: McpSchema }[] {
+export function schemaDefinitions(
+  schema: McpSchema,
+  pointer = '',
+): { name: string; path: string; schema: McpSchema }[] {
   return schemaChildren(schema).flatMap((child) => [
     ...(isSchemaDefinition(child.path) ? [{ ...child, path: pointer + child.path }] : []),
     ...schemaDefinitions(child.schema, pointer + child.path),
@@ -42,8 +80,11 @@ export function schemaDefinitions(schema: McpSchema, pointer = ''): { name: stri
 
 /** A bare array item is already documented by its linked element type. */
 export function inlineSchemaItem(schema: McpSchema): boolean {
-  return !schemaChildren(schema).length && !schemaConstraints(schema).length &&
+  return (
+    !schemaChildren(schema).length &&
+    !schemaConstraints(schema).length &&
     (typeof schema === 'boolean' || !schema.description)
+  )
 }
 
 export function schemaType(schema: McpSchema): string {
@@ -53,8 +94,11 @@ export function schemaType(schema: McpSchema): string {
   if (Array.isArray(schema.enum)) return schema.enum.map((value) => JSON.stringify(value)).join(' | ')
   const alternatives = schema.anyOf ?? schema.oneOf ?? schema.allOf
   if (alternatives) return alternatives.map(schemaType).join(schema.allOf ? ' & ' : ' | ')
-  const named = (name: string) => name === 'array' ? `Array<${schema.items === undefined ? 'any value' : schemaType(schema.items)}>` : name
-  return Array.isArray(schema.type) ? schema.type.map(named).join(' | ') : named(schema.type ?? (schema.properties ? 'object' : 'any value'))
+  const named = (name: string) =>
+    name === 'array' ? `Array<${schema.items === undefined ? 'any value' : schemaType(schema.items)}>` : name
+  return Array.isArray(schema.type)
+    ? schema.type.map(named).join(' | ')
+    : named(schema.type ?? (schema.properties ? 'object' : 'any value'))
 }
 
 /** A reference links only when its JSON pointer resolves inside this schema. */
@@ -62,39 +106,89 @@ export function schemaReference(root: McpSchema, ref: string, scope: string): st
   if (!ref.startsWith('#/')) return undefined
   let target: unknown = root
   let pointer: string
-  try { pointer = decodeURIComponent(ref.slice(1)) } catch { return undefined }
+  try {
+    pointer = decodeURIComponent(ref.slice(1))
+  } catch {
+    return undefined
+  }
   for (const part of pointer.slice(1).split('/')) {
     const key = part.replaceAll('~1', '/').replaceAll('~0', '~')
     if (!target || typeof target !== 'object' || !Object.hasOwn(target, key)) return undefined
     target = (target as Record<string, unknown>)[key]
   }
-  const rendered = (schema: McpSchema, prefix = ''): boolean => schemaChildren(schema).some((child) =>
-    prefix + child.path === pointer || rendered(child.schema, prefix + child.path))
+  const rendered = (schema: McpSchema, prefix = ''): boolean =>
+    schemaChildren(schema).some(
+      (child) => prefix + child.path === pointer || rendered(child.schema, prefix + child.path),
+    )
   if (!rendered(root)) return undefined
   return `#${encodeURIComponent(schemaAnchor(scope, pointer))}`
 }
 
-const CONSTRAINTS = ['default', 'minimum', 'maximum', 'exclusiveMinimum', 'exclusiveMaximum', 'multipleOf',
-  'minLength', 'maxLength', 'pattern', 'format', 'minItems', 'maxItems', 'uniqueItems', 'minProperties', 'maxProperties',
-  'additionalProperties', 'readOnly', 'writeOnly', 'deprecated', 'contentEncoding', 'contentMediaType', 'x-maxUtf8Bytes']
+const CONSTRAINTS = [
+  'default',
+  'minimum',
+  'maximum',
+  'exclusiveMinimum',
+  'exclusiveMaximum',
+  'multipleOf',
+  'minLength',
+  'maxLength',
+  'pattern',
+  'format',
+  'minItems',
+  'maxItems',
+  'uniqueItems',
+  'minProperties',
+  'maxProperties',
+  'additionalProperties',
+  'readOnly',
+  'writeOnly',
+  'deprecated',
+  'contentEncoding',
+  'contentMediaType',
+  'x-maxUtf8Bytes',
+]
 export function schemaConstraints(schema: McpSchema): [string, string][] {
   if (typeof schema === 'boolean') return []
-  return CONSTRAINTS.filter((key) => Object.hasOwn(schema, key) && (typeof schema[key] !== 'object' || schema[key] === null))
-    .map((key) => [key, JSON.stringify(schema[key])])
+  return CONSTRAINTS.filter(
+    (key) => Object.hasOwn(schema, key) && (typeof schema[key] !== 'object' || schema[key] === null),
+  ).map((key) => [key, JSON.stringify(schema[key])])
 }
 
-export function schemaChildren(schema: McpSchema): { name: string; path: string; schema: McpSchema; required?: boolean }[] {
+export function schemaChildren(
+  schema: McpSchema,
+): { name: string; path: string; schema: McpSchema; required?: boolean }[] {
   if (typeof schema === 'boolean') return []
   return [
-    ...Object.entries(schema.properties ?? {}).map(([name, child]) => ({ name, path: `/properties/${pointerPart(name)}`, schema: child, required: schema.required?.includes(name) ?? false })),
+    ...Object.entries(schema.properties ?? {}).map(([name, child]) => ({
+      name,
+      path: `/properties/${pointerPart(name)}`,
+      schema: child,
+      required: schema.required?.includes(name) ?? false,
+    })),
     ...(schema.items === undefined ? [] : [{ name: 'Items', path: '/items', schema: schema.items }]),
-    ...(['anyOf', 'oneOf', 'allOf'] as const).flatMap((key) => (schema[key] ?? []).map((child, i) => ({
-      name: `${key} ${i + 1}`, path: `/${key}/${i}`, schema: child,
-    }))),
-    ...(['$defs', 'definitions'] as const).flatMap((key) => Object.entries(schema[key] ?? {}).map(([name, child]) => ({
-      name, path: `/${key}/${pointerPart(name)}`, schema: child,
-    }))),
+    ...(['anyOf', 'oneOf', 'allOf'] as const).flatMap((key) =>
+      (schema[key] ?? []).map((child, i) => ({
+        name: `${key} ${i + 1}`,
+        path: `/${key}/${i}`,
+        schema: child,
+      })),
+    ),
+    ...(['$defs', 'definitions'] as const).flatMap((key) =>
+      Object.entries(schema[key] ?? {}).map(([name, child]) => ({
+        name,
+        path: `/${key}/${pointerPart(name)}`,
+        schema: child,
+      })),
+    ),
     ...(schema.additionalProperties && typeof schema.additionalProperties === 'object'
-      ? [{ name: 'Additional properties', path: '/additionalProperties', schema: schema.additionalProperties as McpSchema }] : []),
+      ? [
+          {
+            name: 'Additional properties',
+            path: '/additionalProperties',
+            schema: schema.additionalProperties as McpSchema,
+          },
+        ]
+      : []),
   ]
 }
diff --git a/site/src/lib/native-shell.ts b/site/src/lib/native-shell.ts
index 34d34fd2c..cdf32616c 100644
--- a/site/src/lib/native-shell.ts
+++ b/site/src/lib/native-shell.ts
@@ -36,8 +36,12 @@ export function nativeShellContext(): NativeShellContext | undefined {
   const file = process.env.LIBTMUX_DOCS_NATIVE_CONTEXT
   if (!file) return undefined
   const context: NativeShellContext = JSON.parse(readFileSync(file, 'utf8'))
-  if (context.schema !== 1 || context.port !== process.env.LIBTMUX_DOCS_PORT ||
-      context.version !== process.env.LIBTMUX_DOCS_VERSION || context.base !== `${process.env.LIBTMUX_DOCS_BASE}api/`) {
+  if (
+    context.schema !== 1 ||
+    context.port !== process.env.LIBTMUX_DOCS_PORT ||
+    context.version !== process.env.LIBTMUX_DOCS_VERSION ||
+    context.base !== `${process.env.LIBTMUX_DOCS_BASE}api/`
+  ) {
     throw new Error('Native context does not match the Astro build identity')
   }
   return context
diff --git a/site/src/lib/page-port-links.ts b/site/src/lib/page-port-links.ts
index ff57e4aee..6c250dca2 100644
--- a/site/src/lib/page-port-links.ts
+++ b/site/src/lib/page-port-links.ts
@@ -13,12 +13,13 @@ import { DEFAULT_LOCALE, LOCALES } from '../i18n/locales'
  * so the port comes from the build rather than from the path's second
  * segment.
  */
-const symbolsByRoute = new Map<string, ApiSymbol>(Object.entries(API_MODELS).flatMap(([port, model]) =>
-  model.symbols.map((symbol) => [
-    `${port}/${symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id)}`,
-    symbol,
-  ] as const),
-))
+const symbolsByRoute = new Map<string, ApiSymbol>(
+  Object.entries(API_MODELS).flatMap(([port, model]) =>
+    model.symbols.map(
+      (symbol) => [`${port}/${symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id)}`, symbol] as const,
+    ),
+  ),
+)
 
 /** Static routes emitted in each port build, verified against assembled pages. */
 export const SHARED_PAGE_PATHS = ['mcp', 'mcp/tools', 'parity', 'search', 'translations'] as const
@@ -76,7 +77,9 @@ export function pagePortLinks({
   defaults: Record<string, string>
   docs: DocsPage[]
 }): PagePortLink[] {
-  const path = pagePath.replace(/^\/+|\/+$/g, '').replace(/^tmux\/(?=guides(?:\/|$)|topics(?:\/|$)|concepts(?:\/|$)|examples(?:\/|$))/, '')
+  const path = pagePath
+    .replace(/^\/+|\/+$/g, '')
+    .replace(/^tmux\/(?=guides(?:\/|$)|topics(?:\/|$)|concepts(?:\/|$)|examples(?:\/|$))/, '')
   const isReference = path === 'reference' || path.startsWith('reference/')
   const symbolSlug = isReference ? path.slice('reference/'.length) || undefined : undefined
   const productReference = /^(mcp|workspace)\/reference\/(.+)$/.exec(path)
@@ -89,7 +92,9 @@ export function pagePortLinks({
   const paths = [path, ...(own?.data.aliases ?? [])]
   const entries = own?.data.equivalence
     ? docs.filter((entry) => entry.data.equivalence === own.data.equivalence && entry.data.product === own.data.product)
-    : paths.flatMap((candidate) => docs.filter((entry) => docsPath(entry) === candidate || entry.data.aliases?.includes(candidate)))
+    : paths.flatMap((candidate) =>
+        docs.filter((entry) => docsPath(entry) === candidate || entry.data.aliases?.includes(candidate)),
+      )
   const product = /^(mcp|workspace)\//.exec(path)?.[1] as 'mcp' | 'workspace' | undefined
   const protocol = /^mcp\/(tools|prompts|resources)(?:\/(.+))?$/.exec(path)
   const object = protocol && portSlug ? mcpObjectAt(portSlug, protocol[1] as McpSection, protocol[2]) : undefined
@@ -112,14 +117,17 @@ export function pagePortLinks({
         const match = alternative.ports.find((p) => p.port === port.slug)
         // Resolve against the target port's version, which this caller knows.
         const targetSymbol = match?.publicId
-          ? API_MODELS[port.slug]?.symbols.find((entry) => (entry.publicId ?? entry.id) === match.publicId) : undefined
+          ? API_MODELS[port.slug]?.symbols.find((entry) => (entry.publicId ?? entry.id) === match.publicId)
+          : undefined
         const href = targetSymbol ? productApiHref(API_MODELS[port.slug], targetSymbol, targetVersion) : match?.href
-        if (href && !targets.has(href)) targets.set(href, {
-          label: targetSymbol ? `${targetSymbol.name} (${match?.kind ?? targetSymbol.kind})` : alternative.label,
-          note: match?.note,
-        })
+        if (href && !targets.has(href))
+          targets.set(href, {
+            label: targetSymbol ? `${targetSymbol.name} (${match?.kind ?? targetSymbol.kind})` : alternative.label,
+            note: match?.note,
+          })
       }
-      links = [...targets].map(([href, target]) => ({ href,
+      links = [...targets].map(([href, target]) => ({
+        href,
         ...(targets.size > 1 || target.note ? { label: target.label } : {}),
       }))
       if (port.slug === symbolPort) {
@@ -131,14 +139,23 @@ export function pagePortLinks({
     } else if (object) {
       const target = productAvailable(port, 'mcp') ? equivalentMcpObject(portSlug!, object, port.slug) : undefined
       if (target) links = [{ href: portPageUrl(port, targetVersion, target.path) }]
-      else if (productAvailable(port, 'mcp') && MCP_REFERENCE[port.slug]) links = [{ href: portPageUrl(port, targetVersion, `mcp/${object.section}`), label: `${object.section[0].toUpperCase()}${object.section.slice(1)} overview`, fallback: 'section' }]
+      else if (productAvailable(port, 'mcp') && MCP_REFERENCE[port.slug])
+        links = [
+          {
+            href: portPageUrl(port, targetVersion, `mcp/${object.section}`),
+            label: `${object.section[0].toUpperCase()}${object.section.slice(1)} overview`,
+            fallback: 'section',
+          },
+        ]
     } else if (protocol && !protocol[2]) {
-      if (productAvailable(port, 'mcp') && MCP_REFERENCE[port.slug]) links = [{ href: portPageUrl(port, targetVersion, path) }]
+      if (productAvailable(port, 'mcp') && MCP_REFERENCE[port.slug])
+        links = [{ href: portPageUrl(port, targetVersion, path) }]
     } else if (!port.parentLibrary && (SHARED_PAGE_PATHS as readonly string[]).includes(path)) {
       links = [{ href: portPageUrl(port, targetVersion, path) }]
     } else {
-      const eligible = entries.filter((entry) => docsEntryAvailable(entry, port.slug)
-        && (!product || productAvailable(port, product)))
+      const eligible = entries.filter(
+        (entry) => docsEntryAvailable(entry, port.slug) && (!product || productAvailable(port, product)),
+      )
       const owned = eligible.filter((entry) => entry.data.port === port.slug)
       const targets = owned.length ? owned : eligible
       if (own?.data.equivalence && targets.length) {
@@ -153,17 +170,25 @@ export function pagePortLinks({
       else {
         // A language-specific article may have no counterpart. Keep its
         // section reachable, and label that destination as an overview.
-        const sectionPath = /^((?:(?:mcp|workspace)\/(?:internals\/)?)?)(guides|examples|concepts|topics)(?:\/|$)/.exec(path)
+        const sectionPath = /^((?:(?:mcp|workspace)\/(?:internals\/)?)?)(guides|examples|concepts|topics)(?:\/|$)/.exec(
+          path,
+        )
         const group = own?.data.sidebar?.group?.toLowerCase()
-        const section = sectionPath?.[2] ?? (group && /^(guides|examples|concepts|topics)$/.test(group) ? group : undefined)
+        const section =
+          sectionPath?.[2] ?? (group && /^(guides|examples|concepts|topics)$/.test(group) ? group : undefined)
         const overviewPath = section && `${sectionPath?.[1] ?? (product ? `${product}/` : '')}${section}`
-        const overview = overviewPath && (!product || productAvailable(port, product))
-          && docs.find((entry) => docsPath(entry) === overviewPath && docsEntryAvailable(entry, port.slug))
-        if (overview && section && overviewPath) links = [{
-          href: portPageUrl(port, targetVersion, overviewPath),
-          label: `${section[0].toUpperCase()}${section.slice(1)} overview`,
-          fallback: 'section',
-        }]
+        const overview =
+          overviewPath &&
+          (!product || productAvailable(port, product)) &&
+          docs.find((entry) => docsPath(entry) === overviewPath && docsEntryAvailable(entry, port.slug))
+        if (overview && section && overviewPath)
+          links = [
+            {
+              href: portPageUrl(port, targetVersion, overviewPath),
+              label: `${section[0].toUpperCase()}${section.slice(1)} overview`,
+              fallback: 'section',
+            },
+          ]
       }
     }
     const homeProduct = product && productAvailable(port, product) ? product : undefined
diff --git a/site/src/lib/picker-paint.ts b/site/src/lib/picker-paint.ts
index 36710f7ef..ea1234feb 100644
--- a/site/src/lib/picker-paint.ts
+++ b/site/src/lib/picker-paint.ts
@@ -21,15 +21,22 @@ import { PORTS } from './ports'
  * than rendering an empty body.
  */
 export function pickerPaintRules(): string {
-  return '.home-language-icon{display:inline-flex;align-items:center;justify-content:center;flex:none;width:var(--home-launcher-icon-size,1.5rem);height:var(--home-launcher-icon-size,1.5rem)}'
-    + '.home-language-icon img{display:none;width:var(--home-launcher-icon-size,1.5rem);height:var(--home-launcher-icon-size,1.5rem);object-fit:contain}'
-    + 'html[data-theme-mode="light"] .home-language-icon{color-scheme:light}'
-    + 'html[data-theme-mode="dark"] .home-language-icon{color-scheme:dark}'
-    + '[data-home-port-name]{display:none}'
-    + PORTS.map((p) => paintPort(p.slug, 'lm-pkg-install') + paintPort(p.slug, 'lm-agent-prompt') + paintPortManagers(p)
-      + paintHomePort(p.slug)
-      + `html[data-home-selected-port="${p.slug}"] .home-language-icon [data-home-default-icon]{display:none}`
-      + `html[data-home-selected-port="${p.slug}"] .home-language-icon img[data-home-language-icon="${p.slug}"]{display:block}`).join('')
+  return (
+    '.home-language-icon{display:inline-flex;align-items:center;justify-content:center;flex:none;width:var(--home-launcher-icon-size,1.5rem);height:var(--home-launcher-icon-size,1.5rem)}' +
+    '.home-language-icon img{display:none;width:var(--home-launcher-icon-size,1.5rem);height:var(--home-launcher-icon-size,1.5rem);object-fit:contain}' +
+    'html[data-theme-mode="light"] .home-language-icon{color-scheme:light}' +
+    'html[data-theme-mode="dark"] .home-language-icon{color-scheme:dark}' +
+    '[data-home-port-name]{display:none}' +
+    PORTS.map(
+      (p) =>
+        paintPort(p.slug, 'lm-pkg-install') +
+        paintPort(p.slug, 'lm-agent-prompt') +
+        paintPortManagers(p) +
+        paintHomePort(p.slug) +
+        `html[data-home-selected-port="${p.slug}"] .home-language-icon [data-home-default-icon]{display:none}` +
+        `html[data-home-selected-port="${p.slug}"] .home-language-icon img[data-home-language-icon="${p.slug}"]{display:block}`,
+    ).join('')
+  )
 }
 
 /** The homepage follows the head's selection before its launcher module loads. */
@@ -100,9 +107,8 @@ function paintPort(slug: string, family: string): string {
   // see PackageInstall.astro. It shows one with `inherit`, not `visible`: a
   // visible child paints through a hidden ancestor, so during the fonts gate
   // the saved panel painted alone before the rest of the page.
-  const [hide, show] = family === 'lm-pkg-install'
-    ? ['visibility:hidden', 'visibility:inherit']
-    : ['display:none', 'display:block']
+  const [hide, show] =
+    family === 'lm-pkg-install' ? ['visibility:hidden', 'visibility:inherit'] : ['display:none', 'display:block']
   return (
     `${scope} .${family}__panel{${hide}}` +
     `${scope} .${family}__panel[data-port="${slug}"]{${show}}` +
diff --git a/site/src/lib/port-documentation.ts b/site/src/lib/port-documentation.ts
index 410517fa2..77b79ba8d 100644
--- a/site/src/lib/port-documentation.ts
+++ b/site/src/lib/port-documentation.ts
@@ -61,45 +61,114 @@ const guide = (
 })
 
 const libraryDomain = (description: string): DocumentationDomain => ({
-  id: 'core', label: 'Library', kind: 'core', navGroup: 'Library', route: '', package: 'core', description,
+  id: 'core',
+  label: 'Library',
+  kind: 'core',
+  navGroup: 'Library',
+  route: '',
+  package: 'core',
+  description,
 })
 
 const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
   powershell: {
     domains: [
       libraryDomain('Install LibTmux and use cmdlets to read and control tmux.'),
-      { id: 'workspace', label: 'Workspace Manager', kind: 'product', navGroup: 'Apps', route: 'workspace', package: 'workspace', product: 'workspace',
-        description: 'Read, validate, plan and load workspace files with LibTmux.Workspace.' },
+      {
+        id: 'workspace',
+        label: 'Workspace Manager',
+        kind: 'product',
+        navGroup: 'Apps',
+        route: 'workspace',
+        package: 'workspace',
+        product: 'workspace',
+        description: 'Read, validate, plan and load workspace files with LibTmux.Workspace.',
+      },
     ],
     sourceGuides: [
-      guide('README.md', 'guides/getting-started', 'core', { title: 'Getting started', sidebar: { group: 'Guides', order: 1 } }),
-      ...['read', 'query', 'create', 'remove', 'layout', 'placement', 'input', 'capture', 'commands', 'watch', 'clients', 'environment', 'options', 'hooks', 'compatibility', 'troubleshooting'].map((name) =>
-        guide(`docs/${name}.md`, `guides/${name}`, 'core')),
+      guide('README.md', 'guides/getting-started', 'core', {
+        title: 'Getting started',
+        sidebar: { group: 'Guides', order: 1 },
+      }),
+      ...[
+        'read',
+        'query',
+        'create',
+        'remove',
+        'layout',
+        'placement',
+        'input',
+        'capture',
+        'commands',
+        'watch',
+        'clients',
+        'environment',
+        'options',
+        'hooks',
+        'compatibility',
+        'troubleshooting',
+      ].map((name) => guide(`docs/${name}.md`, `guides/${name}`, 'core')),
       guide('docs/mcp.md', 'guides/mcp', 'core', { title: 'Using the .NET MCP server', aliases: ['mcp'] }),
-      guide('docs/workspace.md', 'workspace/source-guide', 'workspace', { title: 'Workspace guide', product: 'workspace', package: 'workspace', aliases: [] }),
+      guide('docs/workspace.md', 'workspace/source-guide', 'workspace', {
+        title: 'Workspace guide',
+        product: 'workspace',
+        package: 'workspace',
+        aliases: [],
+      }),
     ],
   },
   julia: {
     domains: [
       libraryDomain('Create or connect to tmux servers and work with captured state.'),
-      { id: 'mcp', label: 'MCP', kind: 'product', navGroup: 'Apps', route: 'mcp', package: 'mcp', product: 'mcp',
-        description: 'Configure the LibTmuxMCP stdio server and its tool permissions.' },
-      { id: 'workspace', label: 'Workspace Manager', kind: 'product', navGroup: 'Apps', route: 'workspace', package: 'workspace', product: 'workspace',
-        description: 'Read, validate, plan and load workspace files with LibTmuxWorkspace.' },
+      {
+        id: 'mcp',
+        label: 'MCP',
+        kind: 'product',
+        navGroup: 'Apps',
+        route: 'mcp',
+        package: 'mcp',
+        product: 'mcp',
+        description: 'Configure the LibTmuxMCP stdio server and its tool permissions.',
+      },
+      {
+        id: 'workspace',
+        label: 'Workspace Manager',
+        kind: 'product',
+        navGroup: 'Apps',
+        route: 'workspace',
+        package: 'workspace',
+        product: 'workspace',
+        description: 'Read, validate, plan and load workspace files with LibTmuxWorkspace.',
+      },
     ],
     sourceGuides: [
-      guide('docs/src/index.md', 'guides/getting-started', 'core', { title: 'Getting started', sidebar: { group: 'Guides', order: 1 } }),
-      guide('docs/src/installation.md', 'guides/installation', 'core', { title: 'Installation', sidebar: { group: 'Guides', order: 2 } }),
+      guide('docs/src/index.md', 'guides/getting-started', 'core', {
+        title: 'Getting started',
+        sidebar: { group: 'Guides', order: 1 },
+      }),
+      guide('docs/src/installation.md', 'guides/installation', 'core', {
+        title: 'Installation',
+        sidebar: { group: 'Guides', order: 2 },
+      }),
       guide('docs/src/queries.md', 'concepts/queries', 'core', { title: 'Captured queries', aliases: [] }),
       guide('docs/src/ownership.md', 'topics/ownership', 'core', { title: 'Ownership and I/O', aliases: [] }),
       guide('docs/src/observations.md', 'topics/observations', 'core', { title: 'Observing output', aliases: [] }),
       guide('docs/src/compatibility.md', 'guides/compatibility', 'core', { title: 'Compatibility' }),
       guide('docs/src/troubleshooting.md', 'guides/troubleshooting', 'core', { title: 'Troubleshooting' }),
       guide('docs/src/mcp.md', 'mcp/source-guide', 'mcp', {
-        title: 'MCP server guide', product: 'mcp', package: 'mcp', aliases: [],
-        equivalence: 'mcp-client-setup', sidebar: { group: 'Guides' },
+        title: 'MCP server guide',
+        product: 'mcp',
+        package: 'mcp',
+        aliases: [],
+        equivalence: 'mcp-client-setup',
+        sidebar: { group: 'Guides' },
+      }),
+      guide('docs/src/workspaces.md', 'workspace/source-guide', 'workspace', {
+        title: 'Workspace guide',
+        product: 'workspace',
+        package: 'workspace',
+        aliases: [],
       }),
-      guide('docs/src/workspaces.md', 'workspace/source-guide', 'workspace', { title: 'Workspace guide', product: 'workspace', package: 'workspace', aliases: [] }),
     ],
     redirects: [{ sourcePath: 'docs/src/api.md', path: 'guides/api-overview', target: 'reference' }],
   },
@@ -107,10 +176,13 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
     domains: [libraryDomain('Kotlin coroutine handles, builders and flows over the Java/JVM library.')],
     sourceGuides: [
       guide('libtmux-kotlin/README.md', 'guides/getting-started', 'core', {
-        title: 'Getting started', sidebar: { group: 'Guides', order: 2 },
+        title: 'Getting started',
+        sidebar: { group: 'Guides', order: 2 },
       }),
       guide('docs/guide/kotlin.md', 'guides/coroutines', 'core', {
-        title: 'Coroutines and flows', aliases: ['guides/source/coroutines'], sidebar: { group: 'Guides', order: 4 },
+        title: 'Coroutines and flows',
+        aliases: ['guides/source/coroutines'],
+        sidebar: { group: 'Guides', order: 4 },
       }),
     ],
   },
@@ -118,20 +190,23 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
     domains: [libraryDomain('Scala 3 handles, immutable collections and effects over the Java/JVM library.')],
     sourceGuides: [
       guide('libtmux-scala/README.md', 'guides/overview', 'core', {
-        title: 'Installation and requirements', sidebar: { group: 'Guides', order: 4 },
+        title: 'Installation and requirements',
+        sidebar: { group: 'Guides', order: 4 },
       }),
       ...['getting-started', 'query', 'ownership', 'execution', 'streaming', 'compatibility'].map((name, index) =>
         guide(`docs/guide/scala/${name}.md`, `guides/${name}`, 'core', {
           aliases: [`guides/source/${name}`],
           sidebar: { group: 'Guides', order: name === 'getting-started' ? 2 : index + 4 },
-        })),
+        }),
+      ),
     ],
   },
   fsharp: {
     domains: [libraryDomain('F# sequences, task helpers and typed filters over the C#/.NET library.')],
     sourceGuides: [
       guide('src/LibTmux.FSharp/README.md', 'guides/quickstart', 'core', {
-        title: 'Quick start', description: 'Install the package, capture server state, and choose a read operation.',
+        title: 'Quick start',
+        description: 'Install the package, capture server state, and choose a read operation.',
         sidebar: { group: 'Guides', order: 4 },
       }),
       ...[
@@ -143,40 +218,68 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
         ['supported-query-fields', 'Query fields', 'Browse the fields supported by typed filters.'],
       ].map(([name, title, description], index) =>
         guide(`docs/fsharp/${name}.md`, `guides/${name}`, 'core', {
-          title, description,
+          title,
+          description,
           aliases: [`guides/source/${name}`],
           sidebar: { group: 'Guides', order: name === 'getting-started' ? 2 : index + 4 },
-        })),
+        }),
+      ),
     ],
     redirects: [{ sourcePath: 'docs/fsharp/api.md', path: 'guides/api-overview', target: 'reference' }],
   },
   ruby: {
     domains: [
       {
-        id: 'core', label: 'Core library', kind: 'core', navGroup: 'Library', route: '', package: 'core',
+        id: 'core',
+        label: 'Core library',
+        kind: 'core',
+        navGroup: 'Library',
+        route: '',
+        package: 'core',
         description: 'Install libtmux and work with tmux servers, sessions, windows, and panes.',
       },
       {
-        id: 'async', label: 'Async', kind: 'companion-package', navGroup: 'Companion packages', route: 'guides/async', package: 'async',
+        id: 'async',
+        label: 'Async',
+        kind: 'companion-package',
+        navGroup: 'Companion packages',
+        route: 'guides/async',
+        package: 'async',
         description: 'Use the libtmux-async companion package for asynchronous tmux work.',
       },
       {
-        id: 'mcp', label: 'MCP', kind: 'product', navGroup: 'Apps', route: 'mcp', package: 'mcp', product: 'mcp',
+        id: 'mcp',
+        label: 'MCP',
+        kind: 'product',
+        navGroup: 'Apps',
+        route: 'mcp',
+        package: 'mcp',
+        product: 'mcp',
         description: 'Configure libtmux-mcp and inspect its tmux tool protocol.',
       },
       {
-        id: 'workspace', label: 'Workspace Manager', kind: 'product', navGroup: 'Apps', route: 'workspace', package: 'workspace', product: 'workspace',
+        id: 'workspace',
+        label: 'Workspace Manager',
+        kind: 'product',
+        navGroup: 'Apps',
+        route: 'workspace',
+        package: 'workspace',
+        product: 'workspace',
         description: 'Validate, plan, and load workspace configuration with libtmux-workspace.',
       },
     ],
     sourceGuides: [
       guide('README.md', 'guides/getting-started', 'core', {
-        title: 'Getting started', description: 'Install the gem, create a session, and query a snapshot.',
-        aliases: ['guides/source/overview', 'guides/overview'], sidebar: { group: 'Guides', order: 2 },
+        title: 'Getting started',
+        description: 'Install the gem, create a session, and query a snapshot.',
+        aliases: ['guides/source/overview', 'guides/overview'],
+        sidebar: { group: 'Guides', order: 2 },
       }),
       guide('docs/modes.md', 'concepts/transports', 'core', {
-        title: 'Execution modes', description: 'Choose blocking commands, captured queries, control mode, or Async tasks.',
-        aliases: ['guides/source/execution-modes', 'guides/execution-modes'], sidebar: { group: 'Concepts', order: 3 },
+        title: 'Execution modes',
+        description: 'Choose blocking commands, captured queries, control mode, or Async tasks.',
+        aliases: ['guides/source/execution-modes', 'guides/execution-modes'],
+        sidebar: { group: 'Concepts', order: 3 },
       }),
       guide('docs/ownership-errors.md', 'topics/errors-and-exceptions', 'core', {
         description: 'Understand server ownership, immutable references, and operation failures.',
@@ -184,70 +287,111 @@ const PORT_DOCUMENTATION: Readonly<Record<string, PortDocumentation>> = {
         sidebar: { group: 'Topics', order: 2 },
       }),
       guide('docs/recipes.md', 'examples/recipes', 'core', {
-        title: 'Recipes', description: 'Run programs for queries, linked windows, capture, and cancellation.',
-        aliases: ['examples/source-recipes'], sidebar: { group: 'Examples', order: 3 },
+        title: 'Recipes',
+        description: 'Run programs for queries, linked windows, capture, and cancellation.',
+        aliases: ['examples/source-recipes'],
+        sidebar: { group: 'Examples', order: 3 },
       }),
       guide('gems/libtmux/README.md', 'guides/core', 'core', {
-        title: 'Server bindings', description: 'Own a private server or connect to an existing socket.',
-        package: 'core', sidebar: { group: 'Guides', order: 4 },
+        title: 'Server bindings',
+        description: 'Own a private server or connect to an existing socket.',
+        package: 'core',
+        sidebar: { group: 'Guides', order: 4 },
       }),
       guide('gems/libtmux-async/README.md', 'guides/async', 'async', {
-        title: 'Async', description: 'Run concurrent commands within an owned Async scope.',
-        package: 'async', sidebar: { group: 'Companion packages' },
+        title: 'Async',
+        description: 'Run concurrent commands within an owned Async scope.',
+        package: 'async',
+        sidebar: { group: 'Companion packages' },
       }),
       guide('gems/libtmux-mcp/README.md', 'mcp/source-guide', 'mcp', {
-        title: 'MCP server guide', sidebar: { group: 'Guides', order: 3 },
-        package: 'mcp', product: 'mcp', aliases: [],
+        title: 'MCP server guide',
+        sidebar: { group: 'Guides', order: 3 },
+        package: 'mcp',
+        product: 'mcp',
+        aliases: [],
         equivalence: 'mcp-client-setup',
       }),
       guide('gems/libtmux-workspace/README.md', 'workspace/source-guide', 'workspace', {
-        title: 'Workspace guide', sidebar: { group: 'Guides', order: 3 },
-        package: 'workspace', product: 'workspace', aliases: [],
+        title: 'Workspace guide',
+        sidebar: { group: 'Guides', order: 3 },
+        package: 'workspace',
+        product: 'workspace',
+        aliases: [],
       }),
     ],
   },
   lua: {
     domains: [
       {
-        id: 'core', label: 'Core library', kind: 'core', navGroup: 'Library', route: '', package: 'core',
+        id: 'core',
+        label: 'Core library',
+        kind: 'core',
+        navGroup: 'Library',
+        route: '',
+        package: 'core',
         description: 'Install libtmux and control tmux through the Lua core API.',
       },
       {
-        id: 'runtime', label: 'luv and Neovim', kind: 'runtime', navGroup: 'Runtime adapters', route: 'guides/runtime',
+        id: 'runtime',
+        label: 'luv and Neovim',
+        kind: 'runtime',
+        navGroup: 'Runtime adapters',
+        route: 'guides/runtime',
         description: 'Use the documented libuv and Neovim runtime integrations.',
       },
       {
-        id: 'mcp', label: 'MCP', kind: 'unavailable', navGroup: 'Availability', route: 'mcp', product: 'mcp',
+        id: 'mcp',
+        label: 'MCP',
+        kind: 'unavailable',
+        navGroup: 'Availability',
+        route: 'mcp',
+        product: 'mcp',
         description: 'No published MCP server is available for the Lua port.',
       },
       {
-        id: 'workspace', label: 'Workspace Manager', kind: 'unavailable', navGroup: 'Availability', route: 'workspace', product: 'workspace',
+        id: 'workspace',
+        label: 'Workspace Manager',
+        kind: 'unavailable',
+        navGroup: 'Availability',
+        route: 'workspace',
+        product: 'workspace',
         description: 'No published workspace manager is available for the Lua port.',
       },
     ],
     sourceGuides: [
       guide('README.md', 'guides/overview', 'core', {
-        title: 'Getting started', aliases: ['guides/source/overview', 'guides/getting-started'],
+        title: 'Getting started',
+        aliases: ['guides/source/overview', 'guides/getting-started'],
         sidebar: { group: 'Guides', order: 2 },
       }),
-      guide('docs/runtime.md', 'guides/runtime', 'runtime', { sidebar: { group: 'Runtime adapters', label: 'luv and Neovim' } }),
-      guide('docs/query.md', 'guides/query', 'core', { aliases: ['guides/source/query', 'concepts/queries', 'guides/querying-and-filtering'] }),
+      guide('docs/runtime.md', 'guides/runtime', 'runtime', {
+        sidebar: { group: 'Runtime adapters', label: 'luv and Neovim' },
+      }),
+      guide('docs/query.md', 'guides/query', 'core', {
+        aliases: ['guides/source/query', 'concepts/queries', 'guides/querying-and-filtering'],
+      }),
       guide('docs/snapshots.md', 'guides/snapshots', 'core'),
       guide('docs/creation.md', 'guides/creation', 'core'),
       guide('docs/topology.md', 'guides/topology', 'core'),
-      guide('docs/panes.md', 'guides/panes', 'core', { aliases: ['guides/source/panes', 'topics/pane-interaction', 'guides/capturing-output', 'guides/sending-keys'] }),
+      guide('docs/panes.md', 'guides/panes', 'core', {
+        aliases: ['guides/source/panes', 'topics/pane-interaction', 'guides/capturing-output', 'guides/sending-keys'],
+      }),
       guide('docs/control.md', 'guides/control', 'core', { aliases: ['guides/source/control', 'concepts/transports'] }),
       guide('docs/commands.md', 'guides/commands', 'core'),
       guide('docs/buffers.md', 'guides/buffers', 'core'),
       guide('docs/clients.md', 'guides/clients', 'core'),
       guide('docs/environment.md', 'topics/environment', 'core', {
-        aliases: ['guides/source/environment', 'guides/environment'], sidebar: { group: 'Topics', order: 3 },
+        aliases: ['guides/source/environment', 'guides/environment'],
+        sidebar: { group: 'Topics', order: 3 },
       }),
       guide('docs/settings.md', 'topics/options-and-hooks', 'core', {
-        aliases: ['guides/source/settings', 'guides/settings'], sidebar: { group: 'Topics', order: 2 },
+        aliases: ['guides/source/settings', 'guides/settings'],
+        sidebar: { group: 'Topics', order: 2 },
       }),
       guide('docs/fields.md', 'topics/format-token-fields', 'core', {
-        aliases: ['guides/source/fields', 'guides/fields'], sidebar: { group: 'Topics', order: 4 },
+        aliases: ['guides/source/fields', 'guides/fields'],
+        sidebar: { group: 'Topics', order: 4 },
       }),
       guide('docs/options-reference.md', 'guides/options', 'core'),
       guide('docs/compatibility.md', 'guides/compatibility', 'core'),
@@ -270,24 +414,40 @@ function assertDistinct(label: string, values: readonly string[]): void {
 /** Fail closed if port metadata and reader-facing configuration disagree. */
 function validate(portSlug: string, config: PortDocumentation): void {
   const port = PORT_BY_SLUG[portSlug]
-  assertDistinct(`${portSlug} domain id`, config.domains.map((domain) => domain.id))
-  assertDistinct(`${portSlug} domain route`, config.domains.map((domain) => domain.route))
+  assertDistinct(
+    `${portSlug} domain id`,
+    config.domains.map((domain) => domain.id),
+  )
+  assertDistinct(
+    `${portSlug} domain route`,
+    config.domains.map((domain) => domain.route),
+  )
   const domainById = new Map(config.domains.map((domain) => [domain.id, domain]))
   for (const domain of config.domains) {
-    if (domain.route.startsWith('/') || domain.route.includes('..')) throw new Error(`port-documentation: invalid route ${domain.route}`)
-    if (domain.kind === 'runtime' && (domain.package || domain.product)) throw new Error(`port-documentation: runtime ${domain.id} cannot be a package or product`)
+    if (domain.route.startsWith('/') || domain.route.includes('..'))
+      throw new Error(`port-documentation: invalid route ${domain.route}`)
+    if (domain.kind === 'runtime' && (domain.package || domain.product))
+      throw new Error(`port-documentation: runtime ${domain.id} cannot be a package or product`)
     if (domain.kind === 'unavailable') {
-      if (!domain.product || productAvailable(port, domain.product) || domain.package) throw new Error(`port-documentation: unavailable ${domain.id} must be an unavailable product without a package`)
+      if (!domain.product || productAvailable(port, domain.product) || domain.package)
+        throw new Error(`port-documentation: unavailable ${domain.id} must be an unavailable product without a package`)
       continue
     }
-    if (domain.kind === 'product' && (!domain.product || !productAvailable(port, domain.product))) throw new Error(`port-documentation: product ${domain.id} must be available`)
-    if (domain.kind === 'companion-package' && (!domain.package || domain.package === 'core' || !port.packages?.some((pkg) => pkg.id === domain.package))) throw new Error(`port-documentation: companion ${domain.id} needs a published package`)
+    if (domain.kind === 'product' && (!domain.product || !productAvailable(port, domain.product)))
+      throw new Error(`port-documentation: product ${domain.id} must be available`)
+    if (
+      domain.kind === 'companion-package' &&
+      (!domain.package || domain.package === 'core' || !port.packages?.some((pkg) => pkg.id === domain.package))
+    )
+      throw new Error(`port-documentation: companion ${domain.id} needs a published package`)
   }
   const guidePaths = config.sourceGuides.flatMap((entry) => [entry.route, ...entry.aliases])
   assertDistinct(`${portSlug} source guide route or alias`, guidePaths)
   for (const entry of config.sourceGuides) {
-    if (!domainById.has(entry.domain)) throw new Error(`port-documentation: ${entry.sourcePath} names unknown domain ${entry.domain}`)
-    if (entry.route.startsWith('/') || entry.route.includes('..')) throw new Error(`port-documentation: invalid source guide route ${entry.route}`)
+    if (!domainById.has(entry.domain))
+      throw new Error(`port-documentation: ${entry.sourcePath} names unknown domain ${entry.domain}`)
+    if (entry.route.startsWith('/') || entry.route.includes('..'))
+      throw new Error(`port-documentation: invalid source guide route ${entry.route}`)
   }
 }
 
@@ -295,7 +455,12 @@ function fallbackAreas(portSlug: string): readonly DocumentationDomain[] {
   const port = PORT_BY_SLUG[portSlug]
   return [
     {
-      id: 'core', label: 'Core library', kind: 'core', navGroup: 'Library', route: '', package: 'core',
+      id: 'core',
+      label: 'Core library',
+      kind: 'core',
+      navGroup: 'Library',
+      route: '',
+      package: 'core',
       description: `Install ${port.packageName} and use the ${port.name} tmux API.`,
     },
     ...Object.entries(port.parentLibrary ? {} : DOC_PRODUCTS).map(([id, product]) => {
@@ -304,7 +469,7 @@ function fallbackAreas(portSlug: string): readonly DocumentationDomain[] {
         id,
         label: product.label,
         description: productDescription(port, id as DocProduct),
-        kind: available ? 'product' as const : 'unavailable' as const,
+        kind: available ? ('product' as const) : ('unavailable' as const),
         navGroup: available ? 'Apps' : 'Availability',
         route: id,
         product: id as DocProduct,
diff --git a/site/src/lib/ports.ts b/site/src/lib/ports.ts
index e142a9f0a..5f16bd2f0 100644
--- a/site/src/lib/ports.ts
+++ b/site/src/lib/ports.ts
@@ -13,7 +13,10 @@ export type Renderer = 'sphinx' | 'astro' | 'native-skinned' | 'none'
 
 /** Documentation products layered on each language library. */
 export const DOC_PRODUCTS = {
-  workspace: { label: 'Workspace Manager', description: 'Define and build tmux sessions from workspace configuration.' },
+  workspace: {
+    label: 'Workspace Manager',
+    description: 'Define and build tmux sessions from workspace configuration.',
+  },
   mcp: { label: 'MCP', description: 'Connect an MCP client to tmux tools and inspect the server API.' },
 } as const
 
@@ -119,40 +122,60 @@ export interface InstallCooldown {
 function nugetInstalls(packageName: string, pinCli = false): readonly InstallCommand[] {
   return [
     {
-      label: '.NET CLI', lang: 'console',
+      label: '.NET CLI',
+      lang: 'console',
       code: `dotnet package add ${packageName} ${pinCli ? '--version {version}' : '--prerelease'}`,
       versionedCode: `dotnet package add ${packageName} --version {version}`,
       note: '.NET 10 SDK: run in your project directory. On .NET 8 or 9, use dotnet add package with the same arguments.',
     },
     {
-      label: 'PMC', lang: 'powershell', code: `NuGet\\Install-Package ${packageName} -Version {version}`,
+      label: 'PMC',
+      lang: 'powershell',
+      code: `NuGet\\Install-Package ${packageName} -Version {version}`,
       note: 'Run in Visual Studio on Windows, in Tools > NuGet Package Manager > Package Manager Console. Choose the target project in that console.',
     },
     {
-      label: 'PackageReference', lang: 'xml',
+      label: 'PackageReference',
+      lang: 'xml',
       code: `<PackageReference Include="${packageName}" Version="{version}" />`,
       note: 'Add this inside an ItemGroup in your .csproj or .fsproj, then run dotnet restore. For central version management, use the CPM tab.',
     },
     {
-      label: 'CPM', lang: 'xml', filename: 'Directory.Packages.props',
+      label: 'CPM',
+      lang: 'xml',
+      filename: 'Directory.Packages.props',
       code: `<Project>\n  <PropertyGroup>\n    <ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>\n  </PropertyGroup>\n  <ItemGroup>\n    <PackageVersion Include="${packageName}" Version="{version}" />\n  </ItemGroup>\n</Project>`,
-      additionalBlocks: [{ filename: 'Project file (.csproj or .fsproj)', lang: 'xml', code: `<PackageReference Include="${packageName}" />` }],
+      additionalBlocks: [
+        {
+          filename: 'Project file (.csproj or .fsproj)',
+          lang: 'xml',
+          code: `<PackageReference Include="${packageName}" />`,
+        },
+      ],
       note: 'Save Directory.Packages.props at the solution root, or merge these settings into the existing file. Add the versionless reference inside the project’s ItemGroup, then run dotnet restore.',
     },
     {
-      label: 'Paket CLI', lang: 'console', code: `paket add ${packageName} --version {version} --interactive`,
+      label: 'Paket CLI',
+      lang: 'console',
+      code: `paket add ${packageName} --version {version} --interactive`,
       note: 'Requires Paket and a solution initialized with paket init. The interactive prompt selects the projects that should reference the package.',
     },
     {
-      label: 'Script & Interactive', lang: 'fsharp', code: `#r "nuget: ${packageName}, {version}"`,
+      label: 'Script & Interactive',
+      lang: 'fsharp',
+      code: `#r "nuget: ${packageName}, {version}"`,
       note: 'Use in an F# .fsx script, dotnet fsi, or a Polyglot Notebook with NuGet support, on .NET 8 or later. This is not a directive for an ordinary compiled project.',
     },
     {
-      label: 'File-Based Apps', lang: 'csharp', code: `#:package ${packageName}@{version}`,
+      label: 'File-Based Apps',
+      lang: 'csharp',
+      code: `#:package ${packageName}@{version}`,
       note: 'C# file-based apps require the .NET 10 SDK. Place this at the top of a .cs file, before code, then run dotnet run app.cs. F# scripts use the Script & Interactive tab.',
     },
     {
-      label: 'Cake', lang: 'csharp', code: `#addin nuget:?package=${packageName}&version={version}&loaddependencies=true`,
+      label: 'Cake',
+      lang: 'csharp',
+      code: `#addin nuget:?package=${packageName}&version={version}&loaddependencies=true`,
       note: 'Use Cake.Tool 6 or later for a .cake script on .NET 8 or later, with Cake’s in-process NuGet client enabled. This loads the library and its dependencies; it has no Cake task aliases or executable tool. Cake Frosting projects use PackageReference.',
     },
   ]
@@ -369,16 +392,39 @@ const CORE_PORTS: readonly Port[] = [
     language: 'Python',
     packageName: 'libtmux',
     packages: [
-      { id: 'workspace', name: 'tmuxp', registry: 'https://pypi.org/project/tmuxp/',
+      {
+        id: 'workspace',
+        name: 'tmuxp',
+        registry: 'https://pypi.org/project/tmuxp/',
         source: { repo: 'tmux-python/tmuxp', path: 'src/tmuxp', ref: 'master' },
         executable: 'tmuxp',
         installs: [
-          { label: 'uv tool', lang: 'console', code: 'uv tool install tmuxp', note: 'Installs tmuxp in an isolated Python environment. Run tmuxp load ./workspace.yaml.' },
-          { label: 'uvx', lang: 'console', code: 'uvx tmuxp --help', note: 'Runs without a permanent installation. Replace --help with load ./workspace.yaml to load a workspace.' },
-          { label: 'pipx', lang: 'console', code: 'pipx install tmuxp', note: 'Installs the tmuxp command in an isolated Python environment.' },
-        ] },
-      { id: 'mcp', name: 'libtmux-mcp', registry: 'https://pypi.org/project/libtmux-mcp/',
-        source: { repo: 'tmux-python/libtmux-mcp', path: 'src/libtmux_mcp', ref: 'main' } },
+          {
+            label: 'uv tool',
+            lang: 'console',
+            code: 'uv tool install tmuxp',
+            note: 'Installs tmuxp in an isolated Python environment. Run tmuxp load ./workspace.yaml.',
+          },
+          {
+            label: 'uvx',
+            lang: 'console',
+            code: 'uvx tmuxp --help',
+            note: 'Runs without a permanent installation. Replace --help with load ./workspace.yaml to load a workspace.',
+          },
+          {
+            label: 'pipx',
+            lang: 'console',
+            code: 'pipx install tmuxp',
+            note: 'Installs the tmuxp command in an isolated Python environment.',
+          },
+        ],
+      },
+      {
+        id: 'mcp',
+        name: 'libtmux-mcp',
+        registry: 'https://pypi.org/project/libtmux-mcp/',
+        source: { repo: 'tmux-python/libtmux-mcp', path: 'src/libtmux_mcp', ref: 'main' },
+      },
     ],
     workspaceCli: 'tmuxp load',
     workspaceCliAvailability: 'released',
@@ -443,7 +489,10 @@ const CORE_PORTS: readonly Port[] = [
     packages: [
       { id: 'core', name: 'libtmux', registry: 'https://rubygems.org/gems/libtmux', require: 'libtmux' },
       {
-        id: 'async', name: 'libtmux-async', registry: 'https://rubygems.org/gems/libtmux-async', require: 'libtmux/async',
+        id: 'async',
+        name: 'libtmux-async',
+        registry: 'https://rubygems.org/gems/libtmux-async',
+        require: 'libtmux/async',
         installs: [
           { label: 'gem', lang: 'console', code: 'gem install --version 0.1.0.alpha.1 libtmux-async' },
           { label: 'Bundler', lang: 'ruby', code: 'gem "libtmux-async", "0.1.0.alpha.1"' },
@@ -545,21 +594,35 @@ const CORE_PORTS: readonly Port[] = [
     repo: 'libtmux/libtmux-powershell',
     docsDispatch: { workflow: 'docs.yml' },
     apiDependencies: ['csharp'],
-    apiDependencyNavigation: [{
-      port: 'csharp', label: '.NET', package: 'LibTmux', version: '0.0.0-alpha.20',
-      revision: 'ec8b6ab2a4f65e23664f43fba538ba200d4ae8bc',
-      declaration: { path: 'Directory.Packages.props', sha256: 'ac7abc834ccaf1c8f93b9f9292d6fa7c54ba35fd891e02e53d2fed49f2b41567' },
-      sections: {
-        server: ['LibTmux.Server'],
-        session: ['LibTmux.Session'],
-        window: ['LibTmux.Window'],
-        pane: ['LibTmux.Pane'],
-        client: ['LibTmux.Client', 'LibTmux.ClientAttachment'],
-        snapshots: ['LibTmux.CapturedRelation', 'LibTmux.CapturedValue', 'LibTmux.SnapshotDepth'],
-        queries: ['LibTmux.Query.QueryDocument', 'LibTmux.Query.QueryPlan', 'LibTmux.Query.QueryResult', 'LibTmux.Query.QueryTarget', 'LibTmux.Query.QueryPushdown'],
-        'queries-fields': ['LibTmux.Query.QueryFieldDescriptor'],
+    apiDependencyNavigation: [
+      {
+        port: 'csharp',
+        label: '.NET',
+        package: 'LibTmux',
+        version: '0.0.0-alpha.20',
+        revision: 'ec8b6ab2a4f65e23664f43fba538ba200d4ae8bc',
+        declaration: {
+          path: 'Directory.Packages.props',
+          sha256: 'ac7abc834ccaf1c8f93b9f9292d6fa7c54ba35fd891e02e53d2fed49f2b41567',
+        },
+        sections: {
+          server: ['LibTmux.Server'],
+          session: ['LibTmux.Session'],
+          window: ['LibTmux.Window'],
+          pane: ['LibTmux.Pane'],
+          client: ['LibTmux.Client', 'LibTmux.ClientAttachment'],
+          snapshots: ['LibTmux.CapturedRelation', 'LibTmux.CapturedValue', 'LibTmux.SnapshotDepth'],
+          queries: [
+            'LibTmux.Query.QueryDocument',
+            'LibTmux.Query.QueryPlan',
+            'LibTmux.Query.QueryResult',
+            'LibTmux.Query.QueryTarget',
+            'LibTmux.Query.QueryPushdown',
+          ],
+          'queries-fields': ['LibTmux.Query.QueryFieldDescriptor'],
+        },
       },
-    }],
+    ],
     checkout: '~/work/libtmux/libtmux-powershell',
     worktree: '~/work/libtmux/libtmux-powershell-docs-site',
     source: { path: 'src/LibTmux.PowerShell', ref: 'master' },
@@ -569,32 +632,67 @@ const CORE_PORTS: readonly Port[] = [
     publishesOwnTree: true,
     generator: 'PowerShell command metadata, manifests, PlatyPS and C# source',
     productAvailability: { mcp: 'unpublished' },
-    productDescriptions: { workspace: 'Read, validate, plan and load workspace files with the LibTmux.Workspace cmdlets.' },
-    packages: [{
-      id: 'workspace', name: 'LibTmux.Workspace',
-      registry: 'https://www.powershellgallery.com/packages/LibTmux.Workspace',
-      source: { path: 'src/LibTmux.Workspace.PowerShell', ref: 'master' },
-      installs: [
-        { label: 'PowerShellGet', lang: 'powershell', code: 'Install-Module -Name LibTmux.Workspace -AllowPrerelease',
-          note: 'Installs the matching LibTmux core dependency. Run PowerShell and tmux on the same Unix host.' },
-        { label: 'PSResourceGet', lang: 'powershell', code: 'Install-PSResource -Name LibTmux.Workspace -Prerelease',
-          note: 'Installs the matching LibTmux core dependency. Run PowerShell and tmux on the same Unix host.' },
-      ],
-    }],
+    productDescriptions: {
+      workspace: 'Read, validate, plan and load workspace files with the LibTmux.Workspace cmdlets.',
+    },
+    packages: [
+      {
+        id: 'workspace',
+        name: 'LibTmux.Workspace',
+        registry: 'https://www.powershellgallery.com/packages/LibTmux.Workspace',
+        source: { path: 'src/LibTmux.Workspace.PowerShell', ref: 'master' },
+        installs: [
+          {
+            label: 'PowerShellGet',
+            lang: 'powershell',
+            code: 'Install-Module -Name LibTmux.Workspace -AllowPrerelease',
+            note: 'Installs the matching LibTmux core dependency. Run PowerShell and tmux on the same Unix host.',
+          },
+          {
+            label: 'PSResourceGet',
+            lang: 'powershell',
+            code: 'Install-PSResource -Name LibTmux.Workspace -Prerelease',
+            note: 'Installs the matching LibTmux core dependency. Run PowerShell and tmux on the same Unix host.',
+          },
+        ],
+      },
+    ],
     installs: [
-      { label: 'PowerShellGet', lang: 'powershell', code: 'Install-Module -Name LibTmux -AllowPrerelease',
-        note: 'Requires PowerShell 7.4 or later and tmux on the same Unix host.' },
-      { label: 'PSResourceGet', lang: 'powershell', code: 'Install-PSResource -Name LibTmux -Prerelease',
-        note: 'Requires PowerShell 7.4 or later and tmux on the same Unix host.' },
+      {
+        label: 'PowerShellGet',
+        lang: 'powershell',
+        code: 'Install-Module -Name LibTmux -AllowPrerelease',
+        note: 'Requires PowerShell 7.4 or later and tmux on the same Unix host.',
+      },
+      {
+        label: 'PSResourceGet',
+        lang: 'powershell',
+        code: 'Install-PSResource -Name LibTmux -Prerelease',
+        note: 'Requires PowerShell 7.4 or later and tmux on the same Unix host.',
+      },
     ],
-    registry: { name: 'PowerShell Gallery', url: 'https://www.powershellgallery.com/packages/LibTmux', icon: 'powershell' },
-    initProject: { code: 'Create a PowerShell script in this directory; no project manifest is required.', lang: 'text' },
+    registry: {
+      name: 'PowerShell Gallery',
+      url: 'https://www.powershellgallery.com/packages/LibTmux',
+      icon: 'powershell',
+    },
+    initProject: {
+      code: 'Create a PowerShell script in this directory; no project manifest is required.',
+      lang: 'text',
+    },
     installForms: {
       stable: { code: 'Install-Module -Name LibTmux', lang: 'powershell' },
-      prerelease: { code: 'Install-Module -Name LibTmux -RequiredVersion {version} -AllowPrerelease', lang: 'powershell' },
-      git: { code: 'git clone --branch {tag} --depth 1 https://github.com/libtmux/libtmux-powershell.git\npwsh -NoProfile -File libtmux-powershell/eng/Build.ps1 -Restore', lang: 'console' },
+      prerelease: {
+        code: 'Install-Module -Name LibTmux -RequiredVersion {version} -AllowPrerelease',
+        lang: 'powershell',
+      },
+      git: {
+        code: 'git clone --branch {tag} --depth 1 https://github.com/libtmux/libtmux-powershell.git\npwsh -NoProfile -File libtmux-powershell/eng/Build.ps1 -Restore',
+        lang: 'console',
+      },
     },
-    installNote: 'Import LibTmux after installation. LibTmux.Workspace is a separate module; the .NET MCP tool does not import either module.',
+    installNote:
+      'Import LibTmux after installation. LibTmux.Workspace is a separate module; the .NET MCP tool does not import either module.',
   },
   {
     slug: 'julia',
@@ -616,30 +714,61 @@ const CORE_PORTS: readonly Port[] = [
     generator: 'Julia syntax, native methods and documentation',
     workspaceCli: 'libtmux-workspace load',
     workspaceCliAvailability: 'local',
-    productDescriptions: { workspace: 'Read and plan tmuxp-style workspaces, then load them with LibTmuxWorkspace or its CLI.',
-      mcp: 'Run LibTmuxMCP to expose tmux tools to an MCP client.' },
+    productDescriptions: {
+      workspace: 'Read and plan tmuxp-style workspaces, then load them with LibTmuxWorkspace or its CLI.',
+      mcp: 'Run LibTmuxMCP to expose tmux tools to an MCP client.',
+    },
     packages: [
-      { id: 'workspace', name: 'LibTmuxWorkspace', source: { path: 'packages/LibTmuxWorkspace', ref: 'master' },
-        require: 'LibTmuxWorkspace', executable: 'libtmux-workspace',
-        installs: [{ label: 'Pkg (Git)', lang: 'julia',
-          code: 'using Pkg\nPkg.activate(".")\nrepo = "https://github.com/libtmux/libtmux-julia.git"\ntag = "v0.1.0-alpha.1"\nPkg.add([\n    PackageSpec(url=repo, rev=tag),\n    PackageSpec(url=repo, rev=tag, subdir="packages/LibTmuxWorkspace"),\n])',
-          note: 'Run in Julia. The core and workspace packages must use the same source release; neither is registered in General.' }] },
-      { id: 'mcp', name: 'LibTmuxMCP', source: { path: 'packages/LibTmuxMCP', ref: 'master' },
-        require: 'LibTmuxMCP', executable: 'libtmux-mcp',
-        installs: [{ label: 'Pkg (Git)', lang: 'julia',
-          code: 'using Pkg\nPkg.activate(".")\nrepo = "https://github.com/libtmux/libtmux-julia.git"\ntag = "v0.1.0-alpha.1"\nPkg.add([\n    PackageSpec(url=repo, rev=tag),\n    PackageSpec(url=repo, rev=tag, subdir="packages/LibTmuxMCP"),\n])',
-          note: 'Run in Julia. The core and MCP packages must use the same source release; neither is registered in General.' }] },
+      {
+        id: 'workspace',
+        name: 'LibTmuxWorkspace',
+        source: { path: 'packages/LibTmuxWorkspace', ref: 'master' },
+        require: 'LibTmuxWorkspace',
+        executable: 'libtmux-workspace',
+        installs: [
+          {
+            label: 'Pkg (Git)',
+            lang: 'julia',
+            code: 'using Pkg\nPkg.activate(".")\nrepo = "https://github.com/libtmux/libtmux-julia.git"\ntag = "v0.1.0-alpha.1"\nPkg.add([\n    PackageSpec(url=repo, rev=tag),\n    PackageSpec(url=repo, rev=tag, subdir="packages/LibTmuxWorkspace"),\n])',
+            note: 'Run in Julia. The core and workspace packages must use the same source release; neither is registered in General.',
+          },
+        ],
+      },
+      {
+        id: 'mcp',
+        name: 'LibTmuxMCP',
+        source: { path: 'packages/LibTmuxMCP', ref: 'master' },
+        require: 'LibTmuxMCP',
+        executable: 'libtmux-mcp',
+        installs: [
+          {
+            label: 'Pkg (Git)',
+            lang: 'julia',
+            code: 'using Pkg\nPkg.activate(".")\nrepo = "https://github.com/libtmux/libtmux-julia.git"\ntag = "v0.1.0-alpha.1"\nPkg.add([\n    PackageSpec(url=repo, rev=tag),\n    PackageSpec(url=repo, rev=tag, subdir="packages/LibTmuxMCP"),\n])',
+            note: 'Run in Julia. The core and MCP packages must use the same source release; neither is registered in General.',
+          },
+        ],
+      },
+    ],
+    installs: [
+      {
+        label: 'Pkg (Git)',
+        lang: 'julia',
+        code: 'using Pkg\nPkg.activate(".")\nPkg.add(PackageSpec(\n    url="https://github.com/libtmux/libtmux-julia.git",\n    rev="v0.1.0-alpha.1",\n))',
+        note: 'Run in Julia with tmux on PATH. This alpha release is installed from Git; it is not registered in General.',
+      },
     ],
-    installs: [{ label: 'Pkg (Git)', lang: 'julia',
-      code: 'using Pkg\nPkg.activate(".")\nPkg.add(PackageSpec(\n    url="https://github.com/libtmux/libtmux-julia.git",\n    rev="v0.1.0-alpha.1",\n))',
-      note: 'Run in Julia with tmux on PATH. This alpha release is installed from Git; it is not registered in General.' }],
     initProject: { code: 'using Pkg\nPkg.activate(".")', lang: 'julia' },
     installForms: {
       stable: { code: 'using Pkg\nPkg.add("LibTmux")', lang: 'julia' },
       prerelease: { code: 'using Pkg\nPkg.add(PackageSpec(name="LibTmux", version="{version}"))', lang: 'julia' },
-      git: { code: 'using Pkg\nPkg.add(PackageSpec(url="https://github.com/libtmux/libtmux-julia.git", rev="{tag}"))', lang: 'julia' },
+      git: {
+        code: 'using Pkg\nPkg.add(PackageSpec(url="https://github.com/libtmux/libtmux-julia.git", rev="{tag}"))',
+        lang: 'julia',
+      },
     },
-    installNote: 'Julia 1.10+ and tmux 3.2a+ are compatibility targets; see the compatibility guide for tested versions. Companion packages share the core source release.',
+    installNote:
+      'Julia 1.10+ and tmux 3.2a+ are compatibility targets; see the compatibility guide for tested versions. Companion packages share the core source release.',
   },
   {
     slug: 'ts',
@@ -793,20 +922,37 @@ const CORE_PORTS: readonly Port[] = [
       // A git install takes the workspace root, which is `@libtmux/repo` and
       // carries no library, so the import fails with "Cannot find module".
       // Depend on the package directory instead.
-      git: { code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-ts && bun add ./libtmux-ts/packages/libtmux', lang: 'console' },
+      git: {
+        code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-ts && bun add ./libtmux-ts/packages/libtmux',
+        lang: 'console',
+      },
     },
   },
   {
     slug: 'rs',
     projectName: 'libtmux-rs',
     packages: [
-      { id: 'workspace', name: 'tmux-workspace', registry: 'https://crates.io/crates/tmux-workspace',
+      {
+        id: 'workspace',
+        name: 'tmux-workspace',
+        registry: 'https://crates.io/crates/tmux-workspace',
         source: { path: 'crates/tmux-workspace', ref: 'master' },
         executable: 'tmux-workspace',
-        installs: [{ label: 'cargo', lang: 'console', code: 'cargo install --locked --path crates/tmux-workspace',
-          note: 'Run from a libtmux-rs checkout with its pinned Rust toolchain. This builds and installs the native CLI; run tmux-workspace --help afterward.' }] },
-      { id: 'mcp', name: 'tmux-mcp', registry: 'https://crates.io/crates/tmux-mcp',
-        source: { path: 'crates/tmux-mcp', ref: 'master' } },
+        installs: [
+          {
+            label: 'cargo',
+            lang: 'console',
+            code: 'cargo install --locked --path crates/tmux-workspace',
+            note: 'Run from a libtmux-rs checkout with its pinned Rust toolchain. This builds and installs the native CLI; run tmux-workspace --help afterward.',
+          },
+        ],
+      },
+      {
+        id: 'mcp',
+        name: 'tmux-mcp',
+        registry: 'https://crates.io/crates/tmux-mcp',
+        source: { path: 'crates/tmux-mcp', ref: 'master' },
+      },
     ],
     logoLanguage: 'rust',
     shortName: 'Rs',
@@ -827,8 +973,7 @@ const CORE_PORTS: readonly Port[] = [
     ecosystemHost: {
       name: 'docs.rs',
       url: 'https://docs.rs/libtmux',
-      rationale:
-        'Rust API documentation for published crate versions on docs.rs.',
+      rationale: 'Rust API documentation for published crate versions on docs.rs.',
     },
     generator: '',
     installs: [
@@ -859,8 +1004,12 @@ const CORE_PORTS: readonly Port[] = [
     language: 'Go',
     packageName: 'github.com/libtmux/libtmux-go/tmux',
     packages: [
-      { id: 'mcp', name: 'github.com/libtmux/libtmux-go/mcp', registry: 'https://pkg.go.dev/github.com/libtmux/libtmux-go/mcp',
-        source: { path: 'mcp/cmd/libtmux-mcp', ref: 'master' } },
+      {
+        id: 'mcp',
+        name: 'github.com/libtmux/libtmux-go/mcp',
+        registry: 'https://pkg.go.dev/github.com/libtmux/libtmux-go/mcp',
+        source: { path: 'mcp/cmd/libtmux-mcp', ref: 'master' },
+      },
       {
         id: 'workspace',
         name: 'github.com/libtmux/libtmux-go/workspace',
@@ -889,8 +1038,7 @@ const CORE_PORTS: readonly Port[] = [
     ecosystemHost: {
       name: 'pkg.go.dev',
       url: 'https://pkg.go.dev/github.com/libtmux/libtmux-go/tmux',
-      rationale:
-        'Go API documentation for published module versions on pkg.go.dev.',
+      rationale: 'Go API documentation for published module versions on pkg.go.dev.',
     },
     generator: '',
     installs: [
@@ -914,13 +1062,27 @@ const CORE_PORTS: readonly Port[] = [
     slug: 'java',
     projectName: 'libtmux-java',
     packages: [
-      { id: 'workspace', name: 'libtmux-workspace-cli', registry: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-workspace-cli',
+      {
+        id: 'workspace',
+        name: 'libtmux-workspace-cli',
+        registry: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-workspace-cli',
         source: { path: 'libtmux-workspace-cli', ref: 'master' },
         executable: 'tmux-workspace',
-        installs: [{ label: 'Gradle', lang: 'console', code: './gradlew \\\n    --max-workers=2 \\\n    --no-parallel \\\n    :libtmux-workspace-cli:installDist',
-          note: 'Run from a libtmux-java checkout with JDK 25 or newer. The launcher is libtmux-workspace-cli/build/install/tmux-workspace/bin/tmux-workspace; keep its adjacent libraries.' }] },
-      { id: 'mcp', name: 'libtmux-mcp', registry: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-mcp',
-        source: { path: 'libtmux-mcp', ref: 'master' } },
+        installs: [
+          {
+            label: 'Gradle',
+            lang: 'console',
+            code: './gradlew \\\n    --max-workers=2 \\\n    --no-parallel \\\n    :libtmux-workspace-cli:installDist',
+            note: 'Run from a libtmux-java checkout with JDK 25 or newer. The launcher is libtmux-workspace-cli/build/install/tmux-workspace/bin/tmux-workspace; keep its adjacent libraries.',
+          },
+        ],
+      },
+      {
+        id: 'mcp',
+        name: 'libtmux-mcp',
+        registry: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-mcp',
+        source: { path: 'libtmux-mcp', ref: 'master' },
+      },
     ],
     logoLanguage: 'java',
     shortName: 'Java',
@@ -940,8 +1102,7 @@ const CORE_PORTS: readonly Port[] = [
     ecosystemHost: {
       name: 'javadoc.io',
       url: 'https://javadoc.io/doc/io.github.libtmux/libtmux',
-      rationale:
-        'Java API documentation from the Javadoc JAR published to Maven Central.',
+      rationale: 'Java API documentation from the Javadoc JAR published to Maven Central.',
     },
     generator: '',
     installs: [
@@ -977,7 +1138,11 @@ const CORE_PORTS: readonly Port[] = [
 </dependency>`,
       },
     ],
-    registry: { name: 'Maven Central', url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux', icon: 'maven' },
+    registry: {
+      name: 'Maven Central',
+      url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux',
+      icon: 'maven',
+    },
     initProject: { code: 'gradle init --type java-application --dsl kotlin', lang: 'console' },
     installForms: {
       // Gradle has no unpinned form, so every spelling carries the version.
@@ -985,7 +1150,10 @@ const CORE_PORTS: readonly Port[] = [
       // to readers as if it were a command.
       stable: { code: 'implementation("io.github.libtmux:libtmux:{version}")', lang: 'kotlin' },
       prerelease: { code: 'implementation("io.github.libtmux:libtmux:{version}")', lang: 'kotlin' },
-      git: { code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-java && (cd libtmux-java && ./gradlew publishToMavenLocal)', lang: 'console' },
+      git: {
+        code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-java && (cd libtmux-java && ./gradlew publishToMavenLocal)',
+        lang: 'console',
+      },
     },
   },
   {
@@ -1019,8 +1187,12 @@ const CORE_PORTS: readonly Port[] = [
       git: { code: 'dotnet add reference ../libtmux-dotnet/src/LibTmux/LibTmux.csproj', lang: 'console' },
     },
     packages: [
-      { id: 'mcp', name: 'LibTmux.Mcp', registry: 'https://www.nuget.org/packages/LibTmux.Mcp',
-        source: { path: 'src/LibTmux.Mcp', ref: 'master' } },
+      {
+        id: 'mcp',
+        name: 'LibTmux.Mcp',
+        registry: 'https://www.nuget.org/packages/LibTmux.Mcp',
+        source: { path: 'src/LibTmux.Mcp', ref: 'master' },
+      },
       {
         id: 'workspace',
         name: 'LibTmux.Workspace.Cli',
@@ -1055,10 +1227,20 @@ const CORE_PORTS: readonly Port[] = [
     slug: 'cxx',
     projectName: 'libtmux-cxx',
     packages: [
-      { id: 'workspace', name: 'tmux-workspace', source: { path: 'apps/workspace', ref: 'master' },
+      {
+        id: 'workspace',
+        name: 'tmux-workspace',
+        source: { path: 'apps/workspace', ref: 'master' },
         executable: 'tmux-workspace',
-        installs: [{ label: 'CMake', lang: 'console', code: 'cmake --preset cxx-dev -DLIBTMUX_BUILD_WORKSPACE_CLI=ON && \\\n    cmake --build --preset cxx-dev --target tmux-workspace --parallel 2',
-          note: 'Run from a libtmux-cxx checkout with Clang 18.1.3, libc++ 18.1, CMake 3.25 or newer, and Ninja. The command is build/cxx-dev/apps/workspace/tmux-workspace.' }] },
+        installs: [
+          {
+            label: 'CMake',
+            lang: 'console',
+            code: 'cmake --preset cxx-dev -DLIBTMUX_BUILD_WORKSPACE_CLI=ON && \\\n    cmake --build --preset cxx-dev --target tmux-workspace --parallel 2',
+            note: 'Run from a libtmux-cxx checkout with Clang 18.1.3, libc++ 18.1, CMake 3.25 or newer, and Ninja. The command is build/cxx-dev/apps/workspace/tmux-workspace.',
+          },
+        ],
+      },
       { id: 'mcp', name: 'libtmux-mcp-server', source: { path: 'apps/mcp', ref: 'master' } },
     ],
     logoLanguage: 'cpp',
@@ -1124,20 +1306,37 @@ target_link_libraries(your_target PRIVATE libtmux::libtmux)`,
       // There is no vcpkg port yet, so this is the only form that works today.
       // FetchContent rather than a clone: it pins the tag in the build file,
       // where the next reader of the repository can see it.
-      git: { code: 'include(FetchContent)\nFetchContent_Declare(libtmux-cxx\n  GIT_REPOSITORY https://github.com/libtmux/libtmux-cxx\n  GIT_TAG {tag})\nFetchContent_MakeAvailable(libtmux-cxx)', lang: 'cmake' },
+      git: {
+        code: 'include(FetchContent)\nFetchContent_Declare(libtmux-cxx\n  GIT_REPOSITORY https://github.com/libtmux/libtmux-cxx\n  GIT_TAG {tag})\nFetchContent_MakeAvailable(libtmux-cxx)',
+        lang: 'cmake',
+      },
     },
   },
   {
     slug: 'swift',
     projectName: 'libtmux-swift',
     packages: [
-      { id: 'workspace', name: 'tmux-workspace', registry: 'https://swiftpackageindex.com/libtmux/libtmux-swift',
+      {
+        id: 'workspace',
+        name: 'tmux-workspace',
+        registry: 'https://swiftpackageindex.com/libtmux/libtmux-swift',
         source: { path: 'Sources/TmuxWorkspaceCLI', ref: 'master' },
         executable: 'tmux-workspace',
-        installs: [{ label: 'SwiftPM', lang: 'console', code: 'swift build \\\n    --jobs 2 \\\n    --traits YAMLWorkspaces \\\n    --force-resolved-versions \\\n    --product tmux-workspace',
-          note: 'Run from a libtmux-swift checkout with Swift 6.2 or newer on Linux, or Xcode Swift 6.3 or newer on macOS. The command is .build/debug/tmux-workspace.' }] },
-      { id: 'mcp', name: 'libtmux-mcp', registry: 'https://swiftpackageindex.com/libtmux/libtmux-swift',
-        source: { path: 'Sources/LibTmuxMCP', ref: 'master' } },
+        installs: [
+          {
+            label: 'SwiftPM',
+            lang: 'console',
+            code: 'swift build \\\n    --jobs 2 \\\n    --traits YAMLWorkspaces \\\n    --force-resolved-versions \\\n    --product tmux-workspace',
+            note: 'Run from a libtmux-swift checkout with Swift 6.2 or newer on Linux, or Xcode Swift 6.3 or newer on macOS. The command is .build/debug/tmux-workspace.',
+          },
+        ],
+      },
+      {
+        id: 'mcp',
+        name: 'libtmux-mcp',
+        registry: 'https://swiftpackageindex.com/libtmux/libtmux-swift',
+        source: { path: 'Sources/LibTmuxMCP', ref: 'master' },
+      },
     ],
     logoLanguage: 'swift',
     shortName: 'Sw',
@@ -1184,7 +1383,10 @@ target_link_libraries(your_target PRIVATE libtmux::libtmux)`,
       // `from: "0.1.0"` means ">= 0.1.0, < 1.0.0", and `0.1.0-alpha.5` sorts
       // below `0.1.0`, so nothing in the repository is in range. This is the
       // one port where the spelling is forced rather than chosen.
-      prerelease: { code: '.package(url: "https://github.com/libtmux/libtmux-swift", exact: "{version}")', lang: 'swift' },
+      prerelease: {
+        code: '.package(url: "https://github.com/libtmux/libtmux-swift", exact: "{version}")',
+        lang: 'swift',
+      },
       git: { code: '.package(url: "https://github.com/libtmux/libtmux-swift", exact: "{tag}")', lang: 'swift' },
     },
     installNote:
@@ -1192,52 +1394,104 @@ target_link_libraries(your_target PRIVATE libtmux::libtmux)`,
   },
 ] as const
 
-type WrapperLibrary = Omit<Port, 'repo' | 'checkout' | 'worktree' | 'tagGrammar' | 'tagPrefix' | 'versionedDocs' | 'renderer' | 'generator'> & {
+type WrapperLibrary = Omit<
+  Port,
+  'repo' | 'checkout' | 'worktree' | 'tagGrammar' | 'tagPrefix' | 'versionedDocs' | 'renderer' | 'generator'
+> & {
   parentLibrary: { slug: string; runtime: string }
 }
 
 const WRAPPER_LIBRARIES: readonly WrapperLibrary[] = [
   {
-    slug: 'kotlin', logoLanguage: 'kotlin', shortName: 'Kt', name: 'Kotlin', language: 'Kotlin',
+    slug: 'kotlin',
+    logoLanguage: 'kotlin',
+    shortName: 'Kt',
+    name: 'Kotlin',
+    language: 'Kotlin',
     projectName: 'libtmux-kotlin',
     parentLibrary: { slug: 'java', runtime: 'JVM' },
     source: { path: 'libtmux-kotlin', ref: 'master' },
     packageName: 'io.github.libtmux:libtmux-kotlin',
-    registry: { name: 'Maven Central', url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin', icon: 'maven' },
-    ecosystemHost: { name: 'Dokka', url: 'https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin', rationale: 'Kotlin API documentation from the Dokka archive published with the package.' },
+    registry: {
+      name: 'Maven Central',
+      url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-kotlin',
+      icon: 'maven',
+    },
+    ecosystemHost: {
+      name: 'Dokka',
+      url: 'https://javadoc.io/doc/io.github.libtmux/libtmux-kotlin',
+      rationale: 'Kotlin API documentation from the Dokka archive published with the package.',
+    },
     installs: [
       { label: 'Gradle', lang: 'kotlin', code: 'implementation("io.github.libtmux:libtmux-kotlin:{version}")' },
-      { label: 'Maven', lang: 'xml', code: '<dependency>\n  <groupId>io.github.libtmux</groupId>\n  <artifactId>libtmux-kotlin</artifactId>\n  <version>{version}</version>\n</dependency>' },
+      {
+        label: 'Maven',
+        lang: 'xml',
+        code: '<dependency>\n  <groupId>io.github.libtmux</groupId>\n  <artifactId>libtmux-kotlin</artifactId>\n  <version>{version}</version>\n</dependency>',
+      },
     ],
     initProject: { code: 'gradle init --type kotlin-application --dsl kotlin', lang: 'console' },
     installForms: {
       stable: { code: 'implementation("io.github.libtmux:libtmux-kotlin:{version}")', lang: 'kotlin' },
       prerelease: { code: 'implementation("io.github.libtmux:libtmux-kotlin:{version}")', lang: 'kotlin' },
-      git: { code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-java && (cd libtmux-java && ./gradlew :libtmux:publishToMavenLocal :libtmux-kotlin:publishToMavenLocal)', lang: 'console' },
+      git: {
+        code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-java && (cd libtmux-java && ./gradlew :libtmux:publishToMavenLocal :libtmux-kotlin:publishToMavenLocal)',
+        lang: 'console',
+      },
     },
   },
   {
-    slug: 'scala', logoLanguage: 'scala', shortName: 'Sc', name: 'Scala', language: 'Scala',
+    slug: 'scala',
+    logoLanguage: 'scala',
+    shortName: 'Sc',
+    name: 'Scala',
+    language: 'Scala',
     projectName: 'libtmux-scala',
     parentLibrary: { slug: 'java', runtime: 'JVM' },
     source: { path: 'libtmux-scala', ref: 'master' },
     packageName: 'io.github.libtmux:libtmux-scala_3',
-    registry: { name: 'Maven Central', url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-scala_3', icon: 'maven' },
-    ecosystemHost: { name: 'Scaladoc', url: 'https://javadoc.io/doc/io.github.libtmux/libtmux-scala_3', rationale: 'Scala 3 API documentation from the Scaladoc archive published with the package.' },
+    registry: {
+      name: 'Maven Central',
+      url: 'https://central.sonatype.com/artifact/io.github.libtmux/libtmux-scala_3',
+      icon: 'maven',
+    },
+    ecosystemHost: {
+      name: 'Scaladoc',
+      url: 'https://javadoc.io/doc/io.github.libtmux/libtmux-scala_3',
+      rationale: 'Scala 3 API documentation from the Scaladoc archive published with the package.',
+    },
     installs: [
-      { label: 'sbt', lang: 'scala', code: 'libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "{version}"' },
+      {
+        label: 'sbt',
+        lang: 'scala',
+        code: 'libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "{version}"',
+      },
       { label: 'Gradle', lang: 'kotlin', code: 'implementation("io.github.libtmux:libtmux-scala_3:{version}")' },
-      { label: 'Maven', lang: 'xml', code: '<dependency>\n  <groupId>io.github.libtmux</groupId>\n  <artifactId>libtmux-scala_3</artifactId>\n  <version>{version}</version>\n</dependency>' },
+      {
+        label: 'Maven',
+        lang: 'xml',
+        code: '<dependency>\n  <groupId>io.github.libtmux</groupId>\n  <artifactId>libtmux-scala_3</artifactId>\n  <version>{version}</version>\n</dependency>',
+      },
     ],
     initProject: { code: 'sbt new scala/scala3.g8', lang: 'console' },
     installForms: {
       stable: { code: 'libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "{version}"', lang: 'scala' },
-      prerelease: { code: 'libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "{version}"', lang: 'scala' },
-      git: { code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-java && (cd libtmux-java && ./gradlew :libtmux:publishToMavenLocal :libtmux-scala:publishToMavenLocal)', lang: 'console' },
+      prerelease: {
+        code: 'libraryDependencies += "io.github.libtmux" %% "libtmux-scala" % "{version}"',
+        lang: 'scala',
+      },
+      git: {
+        code: 'git clone --branch {tag} https://github.com/libtmux/libtmux-java && (cd libtmux-java && ./gradlew :libtmux:publishToMavenLocal :libtmux-scala:publishToMavenLocal)',
+        lang: 'console',
+      },
     },
   },
   {
-    slug: 'fsharp', logoLanguage: 'fsharp', shortName: 'F#', name: 'F#', language: 'F#',
+    slug: 'fsharp',
+    logoLanguage: 'fsharp',
+    shortName: 'F#',
+    name: 'F#',
+    language: 'F#',
     projectName: 'libtmux-fsharp',
     parentLibrary: { slug: 'csharp', runtime: '.NET' },
     sourceReferenceDirectory: 'docs/fsharp-reference/reference',
@@ -1257,10 +1511,16 @@ const WRAPPER_LIBRARIES: readonly WrapperLibrary[] = [
 export const PORTS: readonly Port[] = CORE_PORTS.flatMap((parent) => [
   parent,
   ...WRAPPER_LIBRARIES.filter((library) => library.parentLibrary.slug === parent.slug).map((library): Port => ({
-    repo: parent.repo, checkout: parent.checkout, worktree: parent.worktree,
+    repo: parent.repo,
+    checkout: parent.checkout,
+    worktree: parent.worktree,
     docsDispatch: parent.docsDispatch && { ...parent.docsDispatch, language: library.slug },
-    tagGrammar: parent.tagGrammar, tagPrefix: parent.tagPrefix,
-    versionedDocs: parent.versionedDocs, renderer: 'none', generator: '', referenceKind: 'model',
+    tagGrammar: parent.tagGrammar,
+    tagPrefix: parent.tagPrefix,
+    versionedDocs: parent.versionedDocs,
+    renderer: 'none',
+    generator: '',
+    referenceKind: 'model',
     publishesOwnTree: true,
     ...library,
   })),
@@ -1268,9 +1528,7 @@ export const PORTS: readonly Port[] = CORE_PORTS.flatMap((parent) => [
 
 export const API_MODEL_PORTS = PORTS.filter((port) => port.referenceKind !== 'guide')
 
-export const PORT_BY_SLUG: Readonly<Record<string, Port>> = Object.fromEntries(
-  PORTS.map((p) => [p.slug, p]),
-)
+export const PORT_BY_SLUG: Readonly<Record<string, Port>> = Object.fromEntries(PORTS.map((p) => [p.slug, p]))
 
 /** Open a library's directory at its documented revision, tag, or default branch. */
 export function portSourceUrl(port: Port, version = 'latest', revision?: string): string {
@@ -1310,15 +1568,17 @@ export function workspaceOverviewNotice(port: Port): { title: string; body: stri
   if (port.workspaceCliAvailability === 'published') {
     return {
       title,
-      body: `The \`${command}\` CLI is published to ${port.registry?.name ?? 'the package registry'} `
-        + 'as a prerelease. Pin its version when automation depends on its output.',
+      body:
+        `The \`${command}\` CLI is published to ${port.registry?.name ?? 'the package registry'} ` +
+        'as a prerelease. Pin its version when automation depends on its output.',
     }
   }
   if (port.workspaceCliAvailability !== 'local') return undefined
   return {
     title,
-    body: `Build \`${command}\` from the source revision in the installation guide. `
-      + 'Its CLI and workspace library have separate installation and configuration contracts.',
+    body:
+      `Build \`${command}\` from the source revision in the installation guide. ` +
+      'Its CLI and workspace library have separate installation and configuration contracts.',
   }
 }
 
@@ -1464,8 +1724,7 @@ export function installCommand(port: Port, entry: RegistryEntry): InstallForm {
   // only place the code exists, so the tag is the version.
   if (!entry.tag) {
     throw new Error(
-      `installCommand: ${port.slug} has no registry version and no release tag; ` +
-        'run node scripts/gen-registry.mjs',
+      `installCommand: ${port.slug} has no registry version and no release tag; ` + 'run node scripts/gen-registry.mjs',
     )
   }
   return fill(forms.git, '{tag}', entry.tag)
@@ -1483,9 +1742,12 @@ export function releaseWording(port: Port, entry: RegistryEntry): string {
 }
 
 /** Artwork identity for a port page, reference, or shared product landing. */
-export function pageBrand(portSlug?: string, pagePath = ''): { language: string; variant: 'library' | 'workspace' | 'mcp' } {
+export function pageBrand(
+  portSlug?: string,
+  pagePath = '',
+): { language: string; variant: 'library' | 'workspace' | 'mcp' } {
   const segments = pagePath.toLowerCase().split('/').filter(Boolean)
-  const port = PORT_BY_SLUG[portSlug ?? ''] ?? PORT_BY_SLUG[segments[0] === 'reference' ? segments[1] ?? '' : '']
+  const port = PORT_BY_SLUG[portSlug ?? ''] ?? PORT_BY_SLUG[segments[0] === 'reference' ? (segments[1] ?? '') : '']
   let language = port?.logoLanguage ?? 'python'
   if (port?.slug === 'java') {
     if (segments.some((segment) => /(^|[-.])kotlin($|[-.])/.test(segment))) language = 'kotlin'
@@ -1493,7 +1755,10 @@ export function pageBrand(portSlug?: string, pagePath = ''): { language: string;
   } else if (port?.slug === 'csharp' && segments.some((segment) => /(^|[-.])fsharp($|[-.])/.test(segment))) {
     language = 'fsharp'
   }
-  const variant = segments.some((segment) => /^(?:libtmux[-.]|tmux-)?mcp(?:[.-]|$)/.test(segment)) ? 'mcp'
-    : segments.some((segment) => /^(?:libtmux[-.]|tmux-)?workspace(?:[.-]|$)/.test(segment)) ? 'workspace' : 'library'
+  const variant = segments.some((segment) => /^(?:libtmux[-.]|tmux-)?mcp(?:[.-]|$)/.test(segment))
+    ? 'mcp'
+    : segments.some((segment) => /^(?:libtmux[-.]|tmux-)?workspace(?:[.-]|$)/.test(segment))
+      ? 'workspace'
+      : 'library'
   return { language, variant }
 }
diff --git a/site/src/lib/product-api.ts b/site/src/lib/product-api.ts
index 356309a86..3daa4803b 100644
--- a/site/src/lib/product-api.ts
+++ b/site/src/lib/product-api.ts
@@ -12,17 +12,27 @@ export function productApiHref(model: ApiModel, symbol: ApiSymbol, version: stri
 }
 
 /** Equivalent declarations stay in their product and target port's version. */
-export function productApiAlternatives(model: ApiModel, symbol: ApiSymbol, version: string, defaults: Record<string, string>) {
+export function productApiAlternatives(
+  model: ApiModel,
+  symbol: ApiSymbol,
+  version: string,
+  defaults: Record<string, string>,
+) {
   return referenceAlternatives(model.port, symbol.publicId ?? symbol.id).map((group) => ({
     ...group,
     ports: group.ports.map((entry) => {
       const target = API_MODELS[entry.port]
       const declaration = entry.publicId
-        ? target?.symbols.find((candidate) => (candidate.publicId ?? candidate.id) === entry.publicId) : undefined
+        ? target?.symbols.find((candidate) => (candidate.publicId ?? candidate.id) === entry.publicId)
+        : undefined
       return {
         ...entry,
         href: declaration
-          ? productApiHref(target, declaration, entry.port === model.port ? version : (defaults[entry.port] ?? 'latest'))
+          ? productApiHref(
+              target,
+              declaration,
+              entry.port === model.port ? version : (defaults[entry.port] ?? 'latest'),
+            )
           : entry.href,
       }
     }),
@@ -36,12 +46,15 @@ export function productApiRoutes(
   defaults: Record<string, string>,
   buildVersion: string,
 ): { path: string; model: ApiModel; symbol: ApiSymbol; version: string }[] {
-  return Object.entries(models).filter(([port]) => !buildPort || port === buildPort)
+  return Object.entries(models)
+    .filter(([port]) => !buildPort || port === buildPort)
     .flatMap(([port, model]) => {
       const version = buildPort ? buildVersion : (defaults[port] ?? 'latest')
       return [...symbolsForProduct(model, 'mcp'), ...symbolsForProduct(model, 'workspace')].map((symbol) => ({
         path: `${buildPort ? '' : `${port}/${version}/`}${productApiPath(symbol.product as DocProduct)}/${symbol.slug}`,
-        model, symbol, version,
+        model,
+        symbol,
+        version,
       }))
     })
 }
@@ -55,20 +68,31 @@ export function productApiRedirects(
 ) {
   // WorkspaceBuilderError now carries arbitrary callback errors and is no longer Equatable.
   const model = models.swift
-  if (!model || (buildPort && buildPort !== 'swift') ||
-      model.symbols.some((symbol) => symbol.id === 'WorkspaceBuilderError.!=(_:_:)')) return []
-  const owner = productApiRoutes({ swift: model }, buildPort, defaults, buildVersion)
-    .find((route) => route.symbol.id === 'WorkspaceBuilderError')
+  if (
+    !model ||
+    (buildPort && buildPort !== 'swift') ||
+    model.symbols.some((symbol) => symbol.id === 'WorkspaceBuilderError.!=(_:_:)')
+  )
+    return []
+  const owner = productApiRoutes({ swift: model }, buildPort, defaults, buildVersion).find(
+    (route) => route.symbol.id === 'WorkspaceBuilderError',
+  )
   if (!owner) return []
-  return [{ ...owner, target: owner.path,
-    path: owner.path.replace(/workspacebuildererror$/, 'workspacebuildererror-(_-_-)') }]
+  return [
+    {
+      ...owner,
+      target: owner.path,
+      path: owner.path.replace(/workspacebuildererror$/, 'workspacebuildererror-(_-_-)'),
+    },
+  ]
 }
 
 /** Public declarations listed on a product's reference landing page. */
 export function productApiRoots(model: ApiModel, product: DocProduct): ApiSymbol[] {
   const symbols = symbolsForProduct(model, product)
   const ids = new Set(symbols.map((symbol) => symbol.id))
-  return symbols.filter((symbol) => !symbol.parent || !ids.has(symbol.parent))
+  return symbols
+    .filter((symbol) => !symbol.parent || !ids.has(symbol.parent))
     .sort((a, b) => a.name.localeCompare(b.name))
 }
 
@@ -76,15 +100,17 @@ export function productApiRoots(model: ApiModel, product: DocProduct): ApiSymbol
 export function productApiNavigation(model: ApiModel, product: DocProduct, version: string): SidebarItem[] {
   const symbols = symbolsForProduct(model, product)
   const children = new Map<string, ApiSymbol[]>()
-  for (const symbol of symbols) if (symbol.parent) {
-    const entries = children.get(symbol.parent) ?? []
-    entries.push(symbol)
-    children.set(symbol.parent, entries)
-  }
+  for (const symbol of symbols)
+    if (symbol.parent) {
+      const entries = children.get(symbol.parent) ?? []
+      entries.push(symbol)
+      children.set(symbol.parent, entries)
+    }
   const entry = (symbol: ApiSymbol, label = symbol.name): SidebarItem => {
     const members = children.get(symbol.id) ?? []
     const link = { label, kind: symbol.command?.kind ?? symbol.kind, href: productApiHref(model, symbol, version) }
-    return members.length ? { type: 'group', ...link, items: members.map((member) => entry(member)) }
+    return members.length
+      ? { type: 'group', ...link, items: members.map((member) => entry(member)) }
       : { type: 'link', ...link }
   }
   const rows: SidebarItem[] = []
@@ -113,7 +139,10 @@ const indexes = new WeakMap<ApiModel, Map<string, SymbolIndex>>()
 /** Reuse a symbol index without mixing core and product URL builders. */
 export function productApiIndex(model: ApiModel, version: string): SymbolIndex {
   let versions = indexes.get(model)
-  if (!versions) { versions = new Map(); indexes.set(model, versions) }
+  if (!versions) {
+    versions = new Map()
+    indexes.set(model, versions)
+  }
   let index = versions.get(version)
   if (!index) {
     index = createApiIndex(model, (symbol) => productApiHref(model, symbol, version))
diff --git a/site/src/lib/prompt-highlight.ts b/site/src/lib/prompt-highlight.ts
index 38a9e4959..84f20cdd1 100644
--- a/site/src/lib/prompt-highlight.ts
+++ b/site/src/lib/prompt-highlight.ts
@@ -41,9 +41,7 @@ const INLINE = /(`[^`]+`)|(https?:\/\/[^\s<>()]+)/g
 
 function inline(escaped: string): string {
   return escaped.replace(INLINE, (match, code: string | undefined) =>
-    code
-      ? `<span class="lm-ph-code">${code}</span>`
-      : `<span class="lm-ph-url">${match}</span>`,
+    code ? `<span class="lm-ph-code">${code}</span>` : `<span class="lm-ph-url">${match}</span>`,
   )
 }
 
diff --git a/site/src/lib/prompt-routes.ts b/site/src/lib/prompt-routes.ts
index db481b6e5..dc49580ee 100644
--- a/site/src/lib/prompt-routes.ts
+++ b/site/src/lib/prompt-routes.ts
@@ -38,5 +38,4 @@ export const PROMPT_PAIRS = PORTS.flatMap((port) => TOPICS.map((topic) => ({ por
 export const topicPath = (topicId: string): string => `prompts/${topicId}`
 
 /** Site-relative path of one prompt's plain-text file, without the locale. */
-export const textPath = (portSlug: string, topicId: string): string =>
-  `prompts/${portSlug}/${topicId}.txt`
+export const textPath = (portSlug: string, topicId: string): string => `prompts/${portSlug}/${topicId}.txt`
diff --git a/site/src/lib/prompts.ts b/site/src/lib/prompts.ts
index 5b554dd82..ec5d00d4b 100644
--- a/site/src/lib/prompts.ts
+++ b/site/src/lib/prompts.ts
@@ -277,7 +277,8 @@ Constraints:
       rs: 'Use `libtmux::test::TestServer`, which runs an isolated server and shuts it down on drop.',
       go: 'Use `tmuxtest.NewServer(ctx, t)` from `github.com/libtmux/libtmux-go/tmux/tmuxtest`, which registers its own cleanup.',
       java: 'Use the JUnit 5 support in `io.github.libtmux.junit5`: `TmuxExtension`, and `NamedServerFixture` when the socket name matters.',
-      csharp: 'Use `LibTmux.Testing.TemporaryServerScope`, which is `IAsyncDisposable`, so `await using` handles teardown on the failure path.',
+      csharp:
+        'Use `LibTmux.Testing.TemporaryServerScope`, which is `IAsyncDisposable`, so `await using` handles teardown on the failure path.',
       cxx: 'Use `libtmux::testing::ScopedTmuxServer` from `<libtmux/testing/scoped_server.hpp>`, whose destructor reports teardown.',
       swift: 'Use `withTmuxServer { }` from the `TmuxFixture` library product, which scopes the server to the closure.',
       ts: 'This port does not export a test fixture yet; its launcher is internal. Build the fixture on the public API and say what you needed that was missing, so it can be vended properly.',
@@ -382,11 +383,16 @@ function installStep(port: Port, entry: RegistryEntry, install: InstallForm, wor
   // Indented as a block rather than prefixed with `$`: half these forms are
   // manifest lines, not shell commands, and a prompt that tells an agent to
   // run `implementation("...")` in a shell gets exactly that.
-  lines.push(install.code.split('\n').map((line) => `       ${line}`).join('\n'))
+  lines.push(
+    install.code
+      .split('\n')
+      .map((line) => `       ${line}`)
+      .join('\n'),
+  )
   const check =
     entry.status === 'stable'
-      ? `Check ${(port.registry?.url ?? `https://github.com/${port.repo}`)} if you need a different version.`
-      : `Check ${(port.registry?.url ?? `https://github.com/${port.repo}`)} for a newer version, and prefer a stable release over this one if there now is any.`
+      ? `Check ${port.registry?.url ?? `https://github.com/${port.repo}`} if you need a different version.`
+      : `Check ${port.registry?.url ?? `https://github.com/${port.repo}`} for a newer version, and prefer a stable release over this one if there now is any.`
   lines.push(wrap(check, 76, '   '))
   if (port.installNote) lines.push(wrap(port.installNote, 76, '   '))
   return lines.join('\n')
@@ -453,7 +459,7 @@ export function portParts(args: {
     `is at ${ctx.docsBase}/.`,
     '',
     `Language:   ${port.language}`,
-    `Package:    ${port.packageName} (${(port.registry?.name ?? 'its repository')})`,
+    `Package:    ${port.packageName} (${port.registry?.name ?? 'its repository'})`,
     `Repository: https://github.com/${port.repo}`,
     '',
     'Read these before writing code:',
@@ -465,11 +471,13 @@ export function portParts(args: {
     '1. Report the tmux version with `tmux -V`. libtmux drives a real tmux, so',
     '   nothing below works without one. Stop and tell me if it is missing.',
     ...(port.initProject.lang === 'text'
-      ? [wrap(`2. If this directory is not a ${port.language} project yet, ${port.initProject.code}`, 76, '').replace(/\n/g, '\n   ')]
-      : [
-          `2. If this directory is not a ${port.language} project yet, start one:`,
-          `       ${port.initProject.code}`,
-        ]),
+      ? [
+          wrap(`2. If this directory is not a ${port.language} project yet, ${port.initProject.code}`, 76, '').replace(
+            /\n/g,
+            '\n   ',
+          ),
+        ]
+      : [`2. If this directory is not a ${port.language} project yet, start one:`, `       ${port.initProject.code}`]),
     '   Skip this in a project that already exists, and match what is here.',
     installStep(port, entry, install, wording),
     '4. Write the smallest program that proves the install works: connect to a',
@@ -495,12 +503,16 @@ export function portParts(args: {
 
   const unavailable: Record<string, string> = {}
   if (port.slug === 'ruby') {
-    unavailable['session-freezer'] = 'Ruby workspace support loads and applies creation plans. It does not freeze a live session, preserve program state, or reconcile an existing topology. Report that boundary and do not invent a freeze API.'
-    unavailable['session-supervisor'] = 'Ruby workspace support is creation-only. It can validate, plan, and load a new workspace, but it does not reconcile or delete drift. Report that boundary and do not present creation as convergence.'
+    unavailable['session-freezer'] =
+      'Ruby workspace support loads and applies creation plans. It does not freeze a live session, preserve program state, or reconcile an existing topology. Report that boundary and do not invent a freeze API.'
+    unavailable['session-supervisor'] =
+      'Ruby workspace support is creation-only. It can validate, plan, and load a new workspace, but it does not reconcile or delete drift. Report that boundary and do not present creation as convergence.'
   }
   if (port.slug === 'lua') {
-    unavailable['session-freezer'] = 'Lua has no published workspace package or loader. Document the missing product and stop; do not call the scaffold or invent freeze and restore APIs.'
-    unavailable['session-supervisor'] = 'Lua has no published workspace product or reconciliation API. Document the missing product and stop; do not advertise scaffold modules as usable.'
+    unavailable['session-freezer'] =
+      'Lua has no published workspace package or loader. Document the missing product and stop; do not call the scaffold or invent freeze and restore APIs.'
+    unavailable['session-supervisor'] =
+      'Lua has no published workspace product or reconciliation API. Document the missing product and stop; do not advertise scaffold modules as usable.'
   }
 
   return { setup, notes, unavailable }
diff --git a/site/src/lib/prose-markdown.ts b/site/src/lib/prose-markdown.ts
index bff708801..fc025b3b1 100644
--- a/site/src/lib/prose-markdown.ts
+++ b/site/src/lib/prose-markdown.ts
@@ -14,7 +14,12 @@ interface MarkdownLinkProjection {
 }
 
 /** Add resolved links without reserializing prose or executable examples. */
-export function linkProseMarkdown(raw: string, port?: string, product?: ApiProduct, project: MarkdownLinkProjection = {}): string {
+export function linkProseMarkdown(
+  raw: string,
+  port?: string,
+  product?: ApiProduct,
+  project: MarkdownLinkProjection = {},
+): string {
   const { body, portAt } = resolvePortContent(raw, port)
   const linkApi = !port || PORT_BY_SLUG[port]?.referenceKind !== 'guide'
   const spans = new Set<number>()
@@ -27,16 +32,20 @@ export function linkProseMarkdown(raw: string, port?: string, product?: ApiProdu
       const end = node.position?.end.offset
       if (start !== undefined && end !== undefined) {
         const owner = portAt(start) ?? port
-        edits.push({ start, end, text: rewriteMarkdownLinks(body.slice(start, end), (href: string) => {
-          if (href.startsWith('mcp:')) {
-            const paragraph = body.lastIndexOf('\n\n', start)
-            const before = body.slice(paragraph < 0 ? 0 : paragraph + 2, start)
-            const decision = link(href, { pagePort: owner, before })
-            if (decision.kind === 'link') return project.resolved?.(decision.href) ?? decision.href
-            return href
-          }
-          return project.authored?.(href, owner) ?? href
-        }) })
+        edits.push({
+          start,
+          end,
+          text: rewriteMarkdownLinks(body.slice(start, end), (href: string) => {
+            if (href.startsWith('mcp:')) {
+              const paragraph = body.lastIndexOf('\n\n', start)
+              const before = body.slice(paragraph < 0 ? 0 : paragraph + 2, start)
+              const decision = link(href, { pagePort: owner, before })
+              if (decision.kind === 'link') return project.resolved?.(decision.href) ?? decision.href
+              return href
+            }
+            return project.authored?.(href, owner) ?? href
+          }),
+        })
       }
     }
     if (['link', 'linkReference', 'image', 'imageReference', 'code', 'definition'].includes(node.type)) return SKIP
@@ -51,13 +60,21 @@ export function linkProseMarkdown(raw: string, port?: string, product?: ApiProdu
   })
   for (const mention of proseMentions(body, PORT_BY_LABEL, portAt)) {
     if (!spans.has(mention.start)) continue
-    const decision = link(mention.text, { pagePort: portAt(mention.start) ?? port ?? mention.port, before: mention.before })
+    const decision = link(mention.text, {
+      pagePort: portAt(mention.start) ?? port ?? mention.port,
+      before: mention.before,
+    })
     if (decision.kind !== 'link') continue
     // Angle destinations preserve balanced punctuation in API slugs.
     const href = (project.resolved?.(decision.href) ?? decision.href).replaceAll('<', '%3C').replaceAll('>', '%3E')
-    edits.push({ start: mention.start, end: mention.end, text: `[${body.slice(mention.start, mention.end)}](<${href}>)` })
+    edits.push({
+      start: mention.start,
+      end: mention.end,
+      text: `[${body.slice(mention.start, mention.end)}](<${href}>)`,
+    })
   }
   let out = body
-  for (const edit of edits.sort((a, b) => b.start - a.start)) out = `${out.slice(0, edit.start)}${edit.text}${out.slice(edit.end)}`
+  for (const edit of edits.sort((a, b) => b.start - a.start))
+    out = `${out.slice(0, edit.start)}${edit.text}${out.slice(edit.end)}`
   return out
 }
diff --git a/site/src/lib/prose-resolver.ts b/site/src/lib/prose-resolver.ts
index bfb438250..413cdb1ca 100644
--- a/site/src/lib/prose-resolver.ts
+++ b/site/src/lib/prose-resolver.ts
@@ -1,4 +1,14 @@
-import { Resolver, decideFilePath, decideMention, notASymbol, parentInventory, type ApiProduct, type InventoryEntry, type MentionContext, type MentionDecision } from '@libtmux/api-model'
+import {
+  Resolver,
+  decideFilePath,
+  decideMention,
+  notASymbol,
+  parentInventory,
+  type ApiProduct,
+  type InventoryEntry,
+  type MentionContext,
+  type MentionDecision,
+} from '@libtmux/api-model'
 import { API_MODELS, PORT_NAME, referenceHref } from './api-models'
 import { productApiHref } from './product-api'
 import { PORTS, PORT_BY_SLUG, portPageUrl, referenceUrl } from './ports'
@@ -33,10 +43,21 @@ export const PORT_BY_LABEL: Record<string, string> = Object.fromEntries(
 // Static imports also survive the bundled Markdown route, where source files
 // are no longer adjacent to this module.
 const PATHS: Record<string, { repo: string; revision: string; paths: string[] }> = {
-  py: pyPaths, ruby: rubyPaths, lua: luaPaths, ts: tsPaths, rs: rsPaths,
-  go: goPaths, java: javaPaths, csharp: csharpPaths, cxx: cxxPaths,
-  swift: swiftPaths, kotlin: kotlinPaths, scala: scalaPaths, fsharp: fsharpPaths,
-  powershell: powershellPaths, julia: juliaPaths,
+  py: pyPaths,
+  ruby: rubyPaths,
+  lua: luaPaths,
+  ts: tsPaths,
+  rs: rsPaths,
+  go: goPaths,
+  java: javaPaths,
+  csharp: csharpPaths,
+  cxx: cxxPaths,
+  swift: swiftPaths,
+  kotlin: kotlinPaths,
+  scala: scalaPaths,
+  fsharp: fsharpPaths,
+  powershell: powershellPaths,
+  julia: juliaPaths,
 }
 const TREES = Object.fromEntries(Object.entries(PATHS).map(([port, data]) => [port, new Set(data.paths)]))
 const FILE_RE = /^[\w./@-]+\.(py|ts|tsx|js|rs|go|java|cs|cpp|hpp|h|swift|jl|ps1|psm1|psd1|md|toml|json|ya?ml|sh)$/
@@ -47,21 +68,33 @@ type ProseDecision = MentionDecision & { file?: boolean }
 export function createProseLinker(product?: ApiProduct) {
   const resolver = getResolver()
   let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
-  const versionOf = (port: string) => port === process.env.LIBTMUX_DOCS_PORT
-    ? buildTarget(process.env).version : (defaults[port] ?? 'latest')
+  try {
+    defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  } catch {
+    /* Local defaults are latest. */
+  }
+  const versionOf = (port: string) =>
+    port === process.env.LIBTMUX_DOCS_PORT ? buildTarget(process.env).version : (defaults[port] ?? 'latest')
 
   return (text: string, context: Pick<MentionContext, 'pagePort' | 'before'>): ProseDecision => {
     let protocol = decideMcpMention(text, { ...context, product })
     // Markdown encodes URI-template braces; literal registrations still win.
     if (protocol?.kind === 'unresolved' && text.startsWith('mcp:')) {
-      try { protocol = decideMcpMention(decodeURIComponent(text), { ...context, product }) ?? protocol } catch { /* Preserve malformed destinations. */ }
+      try {
+        protocol = decideMcpMention(decodeURIComponent(text), { ...context, product }) ?? protocol
+      } catch {
+        /* Preserve malformed destinations. */
+      }
     }
     if (protocol?.kind === 'link') {
       const { port, object } = protocol
-      return { kind: 'link', port, external: false,
+      return {
+        kind: 'link',
+        port,
+        external: false,
         href: portPageUrl(PORT_BY_SLUG[port]!, versionOf(port), object.path),
-        title: `${object.name}: ${PORT_NAME[port]} MCP ${object.kind}` }
+        title: `${object.name}: ${PORT_NAME[port]} MCP ${object.kind}`,
+      }
     }
     if (protocol) return protocol
     if (FILE_RE.test(text) || text.endsWith('/')) {
@@ -70,20 +103,29 @@ export function createProseLinker(product?: ApiProduct) {
       if (decision.kind !== 'link') return decision
       const meta = PATHS[decision.port]!
       return {
-        kind: 'link', port: decision.port, file: true, external: true,
+        kind: 'link',
+        port: decision.port,
+        file: true,
+        external: true,
         href: `https://github.com/${meta.repo}/${decision.dir ? 'tree' : 'blob'}/${meta.revision}/${decision.path}`,
         title: `${decision.path}: ${meta.repo}`,
       }
     }
     if (notASymbol(text)) return { kind: 'skip', why: 'not a symbol' }
-    const decision = decideMention(text, {
-      ...context, product,
-      symbolHref: (port, symbol) => productApiHref(API_MODELS[port], symbol, versionOf(port)),
-      moduleHref: (port, module) => {
-        const target = PORT_BY_SLUG[port]
-        return target ? `${referenceUrl(target, versionOf(port))}#${module}` : `#${module}`
+    const decision = decideMention(
+      text,
+      {
+        ...context,
+        product,
+        symbolHref: (port, symbol) => productApiHref(API_MODELS[port], symbol, versionOf(port)),
+        moduleHref: (port, module) => {
+          const target = PORT_BY_SLUG[port]
+          return target ? `${referenceUrl(target, versionOf(port))}#${module}` : `#${module}`
+        },
       },
-    }, resolver, API_MODELS)
+      resolver,
+      API_MODELS,
+    )
     if (decision.kind === 'link' && decision.href.startsWith('/reference/')) {
       return { ...decision, href: withPortRoot(decision.href) }
     }
@@ -165,8 +207,12 @@ export function getResolver(): Resolver {
   for (const port of PORTS) {
     const dependencies = [...(port.parentLibrary ? [port.parentLibrary.slug] : []), ...(port.apiDependencies ?? [])]
     for (const dependency of dependencies) {
-      r.addInventory(`libtmux ${PORT_NAME[dependency]}`, '', parentInventory(API_MODELS[dependency],
-        (symbol) => referenceHref(dependency, symbol.publicId ?? symbol.id)!), [port.slug])
+      r.addInventory(
+        `libtmux ${PORT_NAME[dependency]}`,
+        '',
+        parentInventory(API_MODELS[dependency], (symbol) => referenceHref(dependency, symbol.publicId ?? symbol.id)!),
+        [port.slug],
+      )
     }
   }
   resolver = r
diff --git a/site/src/lib/quickstarts.ts b/site/src/lib/quickstarts.ts
index eb4a9e89c..7288e7f99 100644
--- a/site/src/lib/quickstarts.ts
+++ b/site/src/lib/quickstarts.ts
@@ -27,7 +27,7 @@ export interface HomeExample {
 }
 
 export const HOME_VIEWS = ['concise', 'errors', 'cleanup', 'full'] as const
-export type HomeView = typeof HOME_VIEWS[number]
+export type HomeView = (typeof HOME_VIEWS)[number]
 
 /** Each view is a complete program, including its imports and initialization. */
 export function homeProgram(example: HomeExample, view: HomeView): string {
@@ -37,16 +37,21 @@ export function homeProgram(example: HomeExample, view: HomeView): string {
 }
 
 export function homeCodeColumns(code: string): number {
-  return Math.max(...code.split('\n').map((line) => Array.from(line).reduce(
-    (column, char) => column + (char === '\t' ? 8 - column % 8 : 1), 0,
-  )))
+  return Math.max(
+    ...code
+      .split('\n')
+      .map((line) => Array.from(line).reduce((column, char) => column + (char === '\t' ? 8 - (column % 8) : 1), 0)),
+  )
 }
 
 export const QUICKSTARTS: Partial<Record<string, Quickstart>> = Object.fromEntries(
-  Object.entries(HOME_EXAMPLES).map(([port, complete]) => [port, {
-    lang: complete.lang,
-    code: homeProgram(complete, 'concise').replace(/\n$/, ''),
-    source: `Verified against ${complete.sourceRepository} at ${complete.sourceRevision.slice(0, 12)}.`,
-    complete,
-  }]),
+  Object.entries(HOME_EXAMPLES).map(([port, complete]) => [
+    port,
+    {
+      lang: complete.lang,
+      code: homeProgram(complete, 'concise').replace(/\n$/, ''),
+      source: `Verified against ${complete.sourceRepository} at ${complete.sourceRevision.slice(0, 12)}.`,
+      complete,
+    },
+  ]),
 )
diff --git a/site/src/lib/reference-page-links.ts b/site/src/lib/reference-page-links.ts
index 63b4e969b..d0067b1cb 100644
--- a/site/src/lib/reference-page-links.ts
+++ b/site/src/lib/reference-page-links.ts
@@ -5,14 +5,20 @@ import { defaultVersionFor } from './versions'
 
 /** Verified concept relationships, also published for external shells. */
 export function referencePageLinks() {
-  const symbols: Record<string, Record<string, { port: string; href: string; label: string; kind?: string; note?: string }[]>> = {}
+  const symbols: Record<
+    string,
+    Record<string, { port: string; href: string; label: string; kind?: string; note?: string }[]>
+  > = {}
   for (const concept of Object.values(CONCEPTS)) {
     for (const [port, publicId] of Object.entries(concept.symbols).flatMap(([port, publicId]) =>
-      [publicId, ...(concept.variants?.[port] ?? [])].map((id) => [port, id] as const))) {
+      [publicId, ...(concept.variants?.[port] ?? [])].map((id) => [port, id] as const),
+    )) {
       const entries = referenceAlternatives(port, publicId).flatMap((alternative) =>
-        alternative.ports.flatMap((entry) => entry.href
-          ? [{ port: entry.port, href: entry.href, label: alternative.label, kind: entry.kind, note: entry.note }]
-          : []),
+        alternative.ports.flatMap((entry) =>
+          entry.href
+            ? [{ port: entry.port, href: entry.href, label: alternative.label, kind: entry.kind, note: entry.note }]
+            : [],
+        ),
       )
       ;(symbols[port] ??= {})[publicId] = entries
     }
diff --git a/site/src/lib/registry.ts b/site/src/lib/registry.ts
index 0faad9fb9..f6a286310 100644
--- a/site/src/lib/registry.ts
+++ b/site/src/lib/registry.ts
@@ -13,7 +13,15 @@
  * assertion and could drift on how it handles a missing port.
  */
 import data from '../data/registry.json'
-import { installCommand, releaseWording, type InstallCommand, type InstallForm, type Port, type RegistryData, type RegistryEntry } from './ports'
+import {
+  installCommand,
+  releaseWording,
+  type InstallCommand,
+  type InstallForm,
+  type Port,
+  type RegistryData,
+  type RegistryEntry,
+} from './ports'
 import { releaseTag } from './versions'
 import { portParts, type PortParts, type PromptContext } from './prompts'
 
@@ -43,17 +51,28 @@ export function nugetInstallSelection(
   env: Record<string, string | undefined> = {},
 ): { version?: string; pin?: boolean } {
   if (port.slug !== 'csharp' && port.slug !== 'fsharp') return {}
-  const selected = env.LIBTMUX_DOCS_PORT === port.slug
-    ? releaseTag(env.LIBTMUX_DOCS_VERSION ?? '', port) : null
+  const selected = env.LIBTMUX_DOCS_PORT === port.slug ? releaseTag(env.LIBTMUX_DOCS_VERSION ?? '', port) : null
   return {
-    version: selected?.replace(/^v/, '') ?? sources.find((source) => source.product === 'core' && source.package === port.packageName)?.version,
+    version:
+      selected?.replace(/^v/, '') ??
+      sources.find((source) => source.product === 'core' && source.package === port.packageName)?.version,
     pin: selected !== null,
   }
 }
 
 /** Resolve package snippets against the selected docs source or registry snapshot. */
-export function installsFor(port: Port, selection: { version?: string; pin?: boolean } = {}): readonly InstallCommand[] {
-  if (!port.installs.some((command) => command.code.includes('{version}') || command.additionalBlocks?.some((block) => block.code.includes('{version}')))) return port.installs
+export function installsFor(
+  port: Port,
+  selection: { version?: string; pin?: boolean } = {},
+): readonly InstallCommand[] {
+  if (
+    !port.installs.some(
+      (command) =>
+        command.code.includes('{version}') ||
+        command.additionalBlocks?.some((block) => block.code.includes('{version}')),
+    )
+  )
+    return port.installs
   const entry = registryFor(port)
   const version = selection.version ?? entry.version
   const fill = (code: string) => code.replaceAll('{version}', version!)
diff --git a/site/src/lib/row-anchors.ts b/site/src/lib/row-anchors.ts
index f272b5e18..fbdea4752 100644
--- a/site/src/lib/row-anchors.ts
+++ b/site/src/lib/row-anchors.ts
@@ -1,6 +1,10 @@
 /** A row's identity follows its section and label, independent of its position. */
 export function rowAnchor(section: string, item: string): string {
-  const slug = (text: string) => text.normalize('NFKC').toLowerCase()
-    .replace(/[^\p{L}\p{N}\p{M}]+/gu, '-').replace(/^-|-$/g, '')
+  const slug = (text: string) =>
+    text
+      .normalize('NFKC')
+      .toLowerCase()
+      .replace(/[^\p{L}\p{N}\p{M}]+/gu, '-')
+      .replace(/^-|-$/g, '')
   return `${slug(section) || 'overview'}-${slug(item) || 'entry'}`
 }
diff --git a/site/src/lib/search-mock.ts b/site/src/lib/search-mock.ts
index a78207952..02fe6599b 100644
--- a/site/src/lib/search-mock.ts
+++ b/site/src/lib/search-mock.ts
@@ -23,14 +23,23 @@ const PAGES: MockPage[] = [
     title: 'Getting started',
     excerpt: 'Install a libtmux port, start a tmux server and create a session from code.',
     sections: [
-      ['install', 'Install', 'Each port installs from its own registry: pip, npm, cargo, go get, Maven, NuGet, CMake or SwiftPM.'],
-      ['run-the-smallest-thing-that-proves-it-works', 'Run the smallest thing that proves it works', 'Start a session named foo, send keys to its pane, and read the output back.'],
+      [
+        'install',
+        'Install',
+        'Each port installs from its own registry: pip, npm, cargo, go get, Maven, NuGet, CMake or SwiftPM.',
+      ],
+      [
+        'run-the-smallest-thing-that-proves-it-works',
+        'Run the smallest thing that proves it works',
+        'Start a session named foo, send keys to its pane, and read the output back.',
+      ],
     ],
   },
   {
     path: 'tmux/concepts/server-session-window-pane/',
     title: 'Server, session, window, pane',
-    excerpt: 'tmux nests panes in windows, windows in sessions, and sessions in a server; every port models the same tree.',
+    excerpt:
+      'tmux nests panes in windows, windows in sessions, and sessions in a server; every port models the same tree.',
     sections: [
       ['server', 'Server', 'A server owns a socket and every session on it.'],
       ['session', 'Session', 'A session groups windows and outlives the client that created it.'],
diff --git a/site/src/lib/search-panel.ts b/site/src/lib/search-panel.ts
index f73fbd743..1d8e46468 100644
--- a/site/src/lib/search-panel.ts
+++ b/site/src/lib/search-panel.ts
@@ -70,7 +70,11 @@ export interface SearchPanelHandle {
   clear: () => void
 }
 
-export function mountSearchPanel(root: HTMLElement, bundlePath: string, settings: SearchPanelOptions = {}): SearchPanelHandle {
+export function mountSearchPanel(
+  root: HTMLElement,
+  bundlePath: string,
+  settings: SearchPanelOptions = {},
+): SearchPanelHandle {
   const input = root.querySelector<HTMLInputElement>('.search-panel__input')!
   const results = root.querySelector<HTMLElement>('.search-panel__results')!
   const filtersBox = root.querySelector<HTMLElement>('.search-panel__filters')!
@@ -252,8 +256,11 @@ export function mountSearchPanel(root: HTMLElement, bundlePath: string, settings
   }
 
   /** Results and the sections a reader can see, in the order arrow keys visit them. */
-  const choices = () =>
-    [...results.querySelectorAll<HTMLAnchorElement>('.search-panel__result, .search-panel__subs:not([hidden]) .search-panel__sub')]
+  const choices = () => [
+    ...results.querySelectorAll<HTMLAnchorElement>(
+      '.search-panel__result, .search-panel__subs:not([hidden]) .search-panel__sub',
+    ),
+  ]
 
   function highlight() {
     choices().forEach((choice, i) => choice.setAttribute('aria-selected', String(i === selected)))
diff --git a/site/src/lib/sidebar.ts b/site/src/lib/sidebar.ts
index 8253c8505..29c5e6c1d 100644
--- a/site/src/lib/sidebar.ts
+++ b/site/src/lib/sidebar.ts
@@ -48,18 +48,31 @@ export interface SidebarGroupItem {
 export type SidebarItem = SidebarLinkItem | SidebarGroupItem
 
 /** Existing ancestor pages, followed by the current page, in reading order. */
-export async function pageBreadcrumbs(title: string, path: string, version: string, port?: string, locale: Locale = DEFAULT_LOCALE) {
+export async function pageBreadcrumbs(
+  title: string,
+  path: string,
+  version: string,
+  port?: string,
+  locale: Locale = DEFAULT_LOCALE,
+) {
   const language = port ? PORT_BY_SLUG[port] : undefined
-  const url = (route: string) => language ? portPageUrl(language, version, route) : withRoot(`/${route}${route ? '/' : ''}`)
+  const url = (route: string) =>
+    language ? portPageUrl(language, version, route) : withRoot(`/${route}${route ? '/' : ''}`)
   const tmux = !port && /^tmux(?:\/|$)/.test(path)
   const items = [{ name: language?.name ?? (tmux ? 'tmux' : 'Documentation'), url: url(tmux ? 'tmux' : '') }]
-  const entries = docsEntriesAvailable(await getCollection('docs', (entry) => !entry.data.port || entry.data.port === port), port)
+  const entries = docsEntriesAvailable(
+    await getCollection('docs', (entry) => !entry.data.port || entry.data.port === port),
+    port,
+  )
   const parts = path.split('/').filter(Boolean)
   for (let i = tmux ? 2 : 1; i < parts.length; i++) {
     const route = parts.slice(0, i).join('/')
-    const matching = entries.filter((entry) => (port ? docsPath : docsRoutePath)({ ...entry, id: sourceIdOf(entry.id) }) === route)
-    const entry = matching.find((entry) => localeOf(entry.id) === locale)
-      ?? matching.find((entry) => localeOf(entry.id) === DEFAULT_LOCALE)
+    const matching = entries.filter(
+      (entry) => (port ? docsPath : docsRoutePath)({ ...entry, id: sourceIdOf(entry.id) }) === route,
+    )
+    const entry =
+      matching.find((entry) => localeOf(entry.id) === locale) ??
+      matching.find((entry) => localeOf(entry.id) === DEFAULT_LOCALE)
     if (entry) items.push({ name: entry.data.title, url: url(route) })
     else if (route === 'reference') items.push({ name: 'API reference', url: url(route) })
   }
@@ -102,8 +115,11 @@ export function entryPath(entry: CollectionEntry<'docs'>): string {
 /** Port pages keep their navigation scope even when rendered by a root build. */
 function linkHref(entry: CollectionEntry<'docs'>, version: string, port?: string): string {
   if (port) return portPageUrl(PORT_BY_SLUG[port], version, entryPath(entry))
-  const path = docsRoutePath({ ...entry, id: sourceIdOf(entry.id) }, process.env.LIBTMUX_DOCS_PORT,
-    entry.data.port ? { [entry.data.port]: version } : {})
+  const path = docsRoutePath(
+    { ...entry, id: sourceIdOf(entry.id) },
+    process.env.LIBTMUX_DOCS_PORT,
+    entry.data.port ? { [entry.data.port]: version } : {},
+  )
   const base = import.meta.env.BASE_URL
   return path ? `${base}${path}/` : base
 }
@@ -179,11 +195,13 @@ export function portAreas(port: string, version: string): SidebarGroupItem {
   return {
     type: 'group',
     label: 'Documentation',
-    items: (p.parentLibrary ? ['guides', 'examples', 'concepts'] : ['topics', 'guides', 'examples', 'concepts']).map((area) => ({
-      type: 'link',
-      label: `${area[0]!.toUpperCase()}${area.slice(1)}`,
-      href: portPageUrl(p, version, area),
-    })),
+    items: (p.parentLibrary ? ['guides', 'examples', 'concepts'] : ['topics', 'guides', 'examples', 'concepts']).map(
+      (area) => ({
+        type: 'link',
+        label: `${area[0]!.toUpperCase()}${area.slice(1)}`,
+        href: portPageUrl(p, version, area),
+      }),
+    ),
   }
 }
 
@@ -219,13 +237,16 @@ export async function getSidebar(
   // that exist precisely so every page answers in every language. A nav that
   // shrinks as you switch language is worse than one that admits what is
   // untranslated.
-  const entries = docsEntriesAvailable(await getCollection(
-    'docs',
-    (entry) =>
-      (entry.data.port === undefined || entry.data.port === port) &&
-      entry.data.product === product &&
-      localeOf(entry.id) === DEFAULT_LOCALE,
-  ), port)
+  const entries = docsEntriesAvailable(
+    await getCollection(
+      'docs',
+      (entry) =>
+        (entry.data.port === undefined || entry.data.port === port) &&
+        entry.data.product === product &&
+        localeOf(entry.id) === DEFAULT_LOCALE,
+    ),
+    port,
+  )
 
   // The reader's own locale, where it has this page. `entryPath` strips the
   // locale, so a translation and its source share a key; the href is built
@@ -292,15 +313,22 @@ export async function getSidebar(
    */
   if (port === undefined) return [...groups, ...ungrouped]
   if (product) {
-    if (product === 'mcp' && productAvailable(PORT_BY_SLUG[port], 'mcp') && MCP_REFERENCE[port]) ungrouped.splice(1, 0,
-      ...Object.entries(MCP_SECTIONS).map(([section, label]) => ({
-        type: 'link' as const, label, href: portPageUrl(PORT_BY_SLUG[port], version, `mcp/${section}`),
-      })))
-    if (product === 'workspace') return [
-      ...ungrouped,
-      ...groups.filter((group) => group.label !== 'Internals'),
-      ...groups.filter((group) => group.label === 'Internals'),
-    ]
+    if (product === 'mcp' && productAvailable(PORT_BY_SLUG[port], 'mcp') && MCP_REFERENCE[port])
+      ungrouped.splice(
+        1,
+        0,
+        ...Object.entries(MCP_SECTIONS).map(([section, label]) => ({
+          type: 'link' as const,
+          label,
+          href: portPageUrl(PORT_BY_SLUG[port], version, `mcp/${section}`),
+        })),
+      )
+    if (product === 'workspace')
+      return [
+        ...ungrouped,
+        ...groups.filter((group) => group.label !== 'Internals'),
+        ...groups.filter((group) => group.label === 'Internals'),
+      ]
     return [...ungrouped, ...groups]
   }
   return [...referenceEntries(port, version), ...groups, ...ungrouped]
diff --git a/site/src/lib/site-root.ts b/site/src/lib/site-root.ts
index a4a8ce977..47245f66d 100644
--- a/site/src/lib/site-root.ts
+++ b/site/src/lib/site-root.ts
@@ -48,10 +48,7 @@ export function withRoot(path: string): string {
  * `SITE_ROOT` is where *this* build is mounted (`/pr-42/ja` for a preview's
  * Japanese build), while this is where *any* locale begins (`/pr-42`).
  */
-export const LOCALES_ROOT: string = (process.env.LIBTMUX_DOCS_LOCALES_ROOT || '').replace(
-  /\/+$/,
-  '',
-)
+export const LOCALES_ROOT: string = (process.env.LIBTMUX_DOCS_LOCALES_ROOT || '').replace(/\/+$/, '')
 
 /**
  * Whether this build mounts the whole site rather than one port's subtree.
diff --git a/site/src/lib/symbol-markdown.ts b/site/src/lib/symbol-markdown.ts
index d29001171..2ac50ccd3 100644
--- a/site/src/lib/symbol-markdown.ts
+++ b/site/src/lib/symbol-markdown.ts
@@ -4,7 +4,19 @@ import { toMarkdown } from 'mdast-util-to-markdown'
 import { membersOf, memberSignals, memberTier, moduleOf, qualifiedNameOf } from '@libtmux/api-model'
 import mentions from '../data/mentions.json'
 import { PORT_NAME, referenceAlternatives } from './api-models'
-import { apiCommandFacts, apiCommandRelatedLinks, apiEntryFields, apiMemberGroups, apiMethodDetails, anonymousDeclarationLabel, nativeSignatureText, parameterBindingText, signatureMultiline, signatureParameterText, usesNativeSignatures } from './api-sections'
+import {
+  apiCommandFacts,
+  apiCommandRelatedLinks,
+  apiEntryFields,
+  apiMemberGroups,
+  apiMethodDetails,
+  anonymousDeclarationLabel,
+  nativeSignatureText,
+  parameterBindingText,
+  signatureMultiline,
+  signatureParameterText,
+  usesNativeSignatures,
+} from './api-sections'
 import { tmuxCommandsFor, tmuxManualUrl } from './tmux-manual-data'
 import { productApiIndex } from './product-api'
 import { defaultVersionFor } from './versions'
@@ -39,10 +51,12 @@ export interface MarkdownContext {
 
 function signatureLine(symbol: ApiSymbol, sig: Signature, port?: string): string {
   const multiline = signatureMultiline(symbol, sig, port)
-  const params = (sig.params ?? []).map((param) => {
-    const text = signatureParameterText(param, port)
-    return multiline ? `  ${text.replaceAll('\n', '\n  ')}` : text
-  }).join(multiline ? ',\n' : ', ')
+  const params = (sig.params ?? [])
+    .map((param) => {
+      const text = signatureParameterText(param, port)
+      return multiline ? `  ${text.replaceAll('\n', '\n  ')}` : text
+    })
+    .join(multiline ? ',\n' : ', ')
   const returns = sig.returns ? `${port === 'ts' ? ':' : ' ->'} ${sig.returns}` : ''
   return `${qualifiedNameOf(symbol)}(${multiline ? '\n' : ''}${params}${multiline ? '\n' : ''})${returns}`
 }
@@ -72,14 +86,26 @@ function powerShellProseMarkdown(markdown: string, index: SymbolIndex, symbol: A
         if (link) edits.push({ start, end, text: `[${inlineCode(node.value)}](${link.href})` })
       } else if (markdown.slice(start, end) === node.value) {
         const spans = index.linkText(node.value, symbol)
-        if (spans.some((span) => span.kind === 'ref' && span.link)) edits.push({ start, end,
-          text: spans.map((span) => span.kind === 'ref' && span.link
-            ? `[${inlineCode(span.label)}](${span.link.href})` : 'text' in span ? span.text : span.label).join('') })
+        if (spans.some((span) => span.kind === 'ref' && span.link))
+          edits.push({
+            start,
+            end,
+            text: spans
+              .map((span) =>
+                span.kind === 'ref' && span.link
+                  ? `[${inlineCode(span.label)}](${span.link.href})`
+                  : 'text' in span
+                    ? span.text
+                    : span.label,
+              )
+              .join(''),
+          })
       }
     } else if ('children' in node) for (const child of node.children) visit(child as Parameters<typeof visit>[0])
   }
   visit(fromMarkdown(markdown))
-  for (const edit of edits.sort((a, b) => b.start - a.start)) markdown = markdown.slice(0, edit.start) + edit.text + markdown.slice(edit.end)
+  for (const edit of edits.sort((a, b) => b.start - a.start))
+    markdown = markdown.slice(0, edit.start) + edit.text + markdown.slice(edit.end)
   return markdown
 }
 
@@ -87,8 +113,10 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   const { model, symbol } = ctx
   const port = 'port' in model ? model.port : undefined
   const language = 'language' in model ? model.language : port
-  const index = ctx.index ?? (port && 'port' in model ? productApiIndex(model, ctx.version ?? defaultVersionFor(port)) : undefined)
-  const prose = (text: string) => language === 'powershell' && index ? powerShellProseMarkdown(text, index, symbol) : text
+  const index =
+    ctx.index ?? (port && 'port' in model ? productApiIndex(model, ctx.version ?? defaultVersionFor(port)) : undefined)
+  const prose = (text: string) =>
+    language === 'powershell' && index ? powerShellProseMarkdown(text, index, symbol) : text
   const id = qualifiedNameOf(symbol)
   const out: string[] = [`# ${id}`, '']
 
@@ -98,7 +126,7 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   const mod = moduleOf(parent ?? symbol)
   if (mod) facts.push(`- **Module:** ${mod}`)
   if (ctx.packageName) facts.push(`- **Package:** ${ctx.packageName}`)
-  facts.push(`- **Language:** ${(port ? PORT_NAME[port] ?? port : language?.toUpperCase())}`)
+  facts.push(`- **Language:** ${port ? (PORT_NAME[port] ?? port) : language?.toUpperCase()}`)
   if (symbol.kind) facts.push(`- **Kind:** ${symbol.kind}`)
   if (ctx.source) facts.push(`- **Source:** ${ctx.source}`)
   if (symbol.exportedFrom) facts.push(`- **Exported from:** ${symbol.exportedFrom}`)
@@ -109,8 +137,14 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
       const parts: string[] = []
       let plain = ''
       for (const part of index?.linkType(base, symbol) ?? [{ text: base }]) {
-        if (!part.link) { plain += part.text; continue }
-        if (plain) { parts.push(inlineCode(plain)); plain = '' }
+        if (!part.link) {
+          plain += part.text
+          continue
+        }
+        if (plain) {
+          parts.push(inlineCode(plain))
+          plain = ''
+        }
         parts.push(`[${inlineCode(part.text)}](${part.link.href})`)
       }
       if (plain) parts.push(inlineCode(plain))
@@ -120,8 +154,14 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   }
   if (ctx.canonical) facts.push(`- **Page:** ${ctx.canonical}`)
   if (facts.length) out.push(...facts, '')
-  const commands = ctx.manualLinks ?? (port ? tmuxCommandsFor(port, symbol.publicId ?? symbol.id)
-    .map((command) => ({ ...command, href: tmuxManualUrl('latest', command.name) })) : [])
+  const commands =
+    ctx.manualLinks ??
+    (port
+      ? tmuxCommandsFor(port, symbol.publicId ?? symbol.id).map((command) => ({
+          ...command,
+          href: tmuxManualUrl('latest', command.name),
+        }))
+      : [])
   for (const command of commands) out.push(`tmux command: [\`${command.name}\`](${command.href})`, '')
   if (symbol.apiScope === 'supporting') {
     out.push('This type appears in public signatures. It is not a package entry point.', '')
@@ -132,9 +172,13 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
     out.push(fencedCode(`${symbol.name} = ${symbol.type}`, 'julia'), '')
   }
   const signatures = language === 'c' ? symbol.signatures.filter((signature) => signature.raw) : symbol.signatures
-  const sig = signatures.map((entry) => native && entry.raw
-    ? `${entry.label && entry.label !== '__AllParameterSets' ? `${entry.label}${entry.isDefault ? ' (default)' : ''}:\n` : ''}${nativeSignatureText(symbol, entry, language)}`
-    : signatureLine(symbol, entry, language)).join('\n\n')
+  const sig = signatures
+    .map((entry) =>
+      native && entry.raw
+        ? `${entry.label && entry.label !== '__AllParameterSets' ? `${entry.label}${entry.isDefault ? ' (default)' : ''}:\n` : ''}${nativeSignatureText(symbol, entry, language)}`
+        : signatureLine(symbol, entry, language),
+    )
+    .join('\n\n')
   if (sig) out.push(fencedCode(sig, language === 'c' ? 'c' : ''), '')
   else if (language === 'c') out.push(`${anonymousDeclarationLabel(symbol)}.`, '')
 
@@ -142,10 +186,17 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   if (symbol.doc?.body) out.push(prose(symbol.doc.body), '')
   if (symbol.command) {
     out.push('## Command details', '')
-    for (const fact of apiCommandFacts(symbol, index?.resolve(symbol.id)?.href)) out.push(`- **${fact.label}:** ${fact.value}`)
+    for (const fact of apiCommandFacts(symbol, index?.resolve(symbol.id)?.href))
+      out.push(`- **${fact.label}:** ${fact.value}`)
     out.push('')
     const related = apiCommandRelatedLinks(symbol, index)
-    if (related.length) out.push('Related APIs:', '', ...related.map((link) => `- [${link.symbol ? inlineCode(link.text) : link.text}](${link.href})`), '')
+    if (related.length)
+      out.push(
+        'Related APIs:',
+        '',
+        ...related.map((link) => `- [${link.symbol ? inlineCode(link.text) : link.text}](${link.href})`),
+        '',
+      )
   }
 
   const methods = apiMethodDetails(symbol)
@@ -155,7 +206,13 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
       const { signature } = method
       if (symbol.signatures.length > 1) {
         const declaration = nativeSignatureText(symbol, signature, language)
-        if (declaration.includes('\n')) out.push(`### ${inlineCode(symbol.name)} (overload ${methodIndex + 1})`, '', fencedCode(declaration, language), '')
+        if (declaration.includes('\n'))
+          out.push(
+            `### ${inlineCode(symbol.name)} (overload ${methodIndex + 1})`,
+            '',
+            fencedCode(declaration, language),
+            '',
+          )
         else out.push(`### ${inlineCode(method.label)}`, '')
       }
       if (signature.extension) out.push(`Available when \`${signature.extension}\` is loaded.`, '')
@@ -191,14 +248,17 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   }
 
   const { params, returns, raises } = apiEntryFields(symbol, language)
-  const overloads = (labels: string[]) => labels.length ? ` (for ${labels.map(inlineCode).join('; ')})` : ''
+  const overloads = (labels: string[]) => (labels.length ? ` (for ${labels.map(inlineCode).join('; ')})` : '')
   if (params.length) {
     out.push('## Parameters', '')
     for (const p of params) {
       const blockDoc = ['julia', 'ts'].includes(language ?? '') && p.doc?.includes('\n')
-      out.push(`- ${inlineCode(p.name + (p.optional ? '?' : ''))}${p.type ? ` (${inlineCode(p.type.replaceAll('\n', ' '))})` : ''}${p.doc && !blockDoc ? `: ${p.doc}` : ''}${p.since ? ` (added ${p.since})` : ''}${p.deprecated ? ` (deprecated ${p.deprecated})` : ''}${overloads(p.overloads)}`)
+      out.push(
+        `- ${inlineCode(p.name + (p.optional ? '?' : ''))}${p.type ? ` (${inlineCode(p.type.replaceAll('\n', ' '))})` : ''}${p.doc && !blockDoc ? `: ${p.doc}` : ''}${p.since ? ` (added ${p.since})` : ''}${p.deprecated ? ` (deprecated ${p.deprecated})` : ''}${overloads(p.overloads)}`,
+      )
       if (blockDoc) out.push('', ...p.doc!.split('\n').map((line) => `  ${line}`), '')
-      if (['julia', 'ts'].includes(language ?? '') && p.default !== undefined) out.push(`  Default: ${inlineCode(p.default)}.`)
+      if (['julia', 'ts'].includes(language ?? '') && p.default !== undefined)
+        out.push(`  Default: ${inlineCode(p.default)}.`)
       const binding = parameterBindingText(p)
       if (binding) out.push(`  ${binding}`)
     }
@@ -226,7 +286,9 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   const inherited = members.filter((member) => member.inheritedFrom && memberTier(member, signals) !== 'parent')
   const appendMembers = (entries: ApiSymbol[]) => {
     for (const member of entries) {
-      out.push(`- ${ctx.hrefFor ? `[${inlineCode(member.name)}](${ctx.hrefFor(member)})` : inlineCode(member.name)} (${member.kind})${member.inheritedFrom ? `, inherited from ${inlineCode(member.inheritedFrom)}` : ''}${member.doc?.summary ? `: ${member.doc.summary}` : ''}`)
+      out.push(
+        `- ${ctx.hrefFor ? `[${inlineCode(member.name)}](${ctx.hrefFor(member)})` : inlineCode(member.name)} (${member.kind})${member.inheritedFrom ? `, inherited from ${inlineCode(member.inheritedFrom)}` : ''}${member.doc?.summary ? `: ${member.doc.summary}` : ''}`,
+      )
     }
     out.push('')
   }
@@ -249,14 +311,28 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
   const paths = (ctx.paths ?? []).filter((path) => path.symbols.some((entry) => entry.id === symbol.id))
   if (paths.length) {
     out.push('## Paths through the source', '', 'Arrows name source relationships, not a runtime execution order.', '')
-    for (const path of paths) out.push(`### ${path.title}`, '', path.symbols.map((entry, i) =>
-      `${i > 0 ? ` — ${path.edges[i - 1] === 'call' ? 'calls' : 'references'} → ` : ''}${symbolLink(entry)}`).join(''), '')
+    for (const path of paths)
+      out.push(
+        `### ${path.title}`,
+        '',
+        path.symbols
+          .map(
+            (entry, i) =>
+              `${i > 0 ? ` — ${path.edges[i - 1] === 'call' ? 'calls' : 'references'} → ` : ''}${symbolLink(entry)}`,
+          )
+          .join(''),
+        '',
+      )
   }
   for (const section of apiRelationshipSections(model, symbol)) {
     out.push(`## ${section.label}`, '')
     for (const target of section.items) {
-      const callSource = section.id === 'api-calls' ? apiCallSource(model, symbol, target)
-        : section.id === 'api-called-by' ? apiCallSource(model, target, symbol) : undefined
+      const callSource =
+        section.id === 'api-calls'
+          ? apiCallSource(model, symbol, target)
+          : section.id === 'api-called-by'
+            ? apiCallSource(model, target, symbol)
+            : undefined
       out.push(`- ${symbolLink(target)} (${target.kind})${callSource ? ` [Call site](${callSource})` : ''}`)
     }
     out.push('')
@@ -268,7 +344,9 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
     for (const group of alternatives) {
       out.push(`### ${group.label}`, '')
       for (const entry of group.ports.filter((entry) => entry.port !== port && entry.href)) {
-        out.push(`- ${entry.name}: [${inlineCode(entry.publicId!)}](${entry.href})${entry.kind ? ` (${entry.kind})` : ''}${entry.note ? `. ${entry.note}` : ''}`)
+        out.push(
+          `- ${entry.name}: [${inlineCode(entry.publicId!)}](${entry.href})${entry.kind ? ` (${entry.kind})` : ''}${entry.note ? `. ${entry.note}` : ''}`,
+        )
       }
       out.push('')
     }
@@ -280,16 +358,21 @@ export function symbolMarkdown(ctx: MarkdownContext): string {
     const edits: { start: number; end: number; text: string }[] = []
     const visit = (node: ReturnType<typeof fromMarkdown> | ReturnType<typeof fromMarkdown>['children'][number]) => {
       if (node.type === 'link' && /^@ref(?:\s|$)/.test(node.url)) {
-        const label = node.children.map((child) => 'value' in child ? child.value : '').join('')
+        const label = node.children.map((child) => ('value' in child ? child.value : '')).join('')
         const target = node.url.slice(4).trim() || label
         const link = index.resolve(target, 'any', symbol)
         if (!link) throw new Error(`Unresolved Julia documentation link: ${symbol.id} -> ${target}`)
         node.url = link.href
-        edits.push({ start: node.position!.start.offset!, end: node.position!.end.offset!, text: toMarkdown(node).trimEnd() })
+        edits.push({
+          start: node.position!.start.offset!,
+          end: node.position!.end.offset!,
+          text: toMarkdown(node).trimEnd(),
+        })
       } else if ('children' in node) for (const child of node.children) visit(child as Parameters<typeof visit>[0])
     }
     visit(fromMarkdown(markdown))
-    for (const edit of edits.sort((a, b) => b.start - a.start)) markdown = markdown.slice(0, edit.start) + edit.text + markdown.slice(edit.end)
+    for (const edit of edits.sort((a, b) => b.start - a.start))
+      markdown = markdown.slice(0, edit.start) + edit.text + markdown.slice(edit.end)
   }
 
   return markdown
diff --git a/site/src/lib/tmux-config.mjs b/site/src/lib/tmux-config.mjs
index 059b7c367..2e668a100 100644
--- a/site/src/lib/tmux-config.mjs
+++ b/site/src/lib/tmux-config.mjs
@@ -1,8 +1,9 @@
 import older from '../data/tmux/3.2a.json' with { type: 'json' }
 import current from '../data/tmux/3.7c.json' with { type: 'json' }
 
-const commands = [...new Set([...older.commands, ...current.commands]
-  .flatMap(({ name, alias }) => [name, alias]).filter(Boolean))].join('|')
+const commands = [
+  ...new Set([...older.commands, ...current.commands].flatMap(({ name, alias }) => [name, alias]).filter(Boolean)),
+].join('|')
 
 /** tmux configuration has directives and recursive formats that Bash does not. */
 export const tmuxConfig = {
@@ -16,11 +17,21 @@ export const tmuxConfig = {
     { match: '%(?:if|elif|else|endif|hidden)\\b', name: 'keyword.control.tmux-config' },
     { include: '#escape' },
     {
-      begin: '"', end: '"', name: 'string.quoted.double.tmux-config',
-      patterns: [{ include: '#escape' }, { include: '#format' }, { include: '#style' }, { include: '#job' }, { include: '#variable' }],
+      begin: '"',
+      end: '"',
+      name: 'string.quoted.double.tmux-config',
+      patterns: [
+        { include: '#escape' },
+        { include: '#format' },
+        { include: '#style' },
+        { include: '#job' },
+        { include: '#variable' },
+      ],
     },
     {
-      begin: "'", end: "'", name: 'string.quoted.single.tmux-config',
+      begin: "'",
+      end: "'",
+      name: 'string.quoted.single.tmux-config',
       patterns: [{ include: '#format' }, { include: '#style' }, { include: '#job' }, { include: '#format-variable' }],
     },
     { include: '#variable' },
@@ -32,17 +43,23 @@ export const tmuxConfig = {
   ],
   repository: {
     escape: { match: '\\\\.', name: 'constant.character.escape.tmux-config' },
-    variable: { patterns: [
-      { match: '\\$[A-Za-z_][A-Za-z0-9_]*|\\$\\{[^}]*\\}', name: 'variable.other.tmux-config' },
-      { include: '#format-variable' },
-    ] },
+    variable: {
+      patterns: [
+        { match: '\\$[A-Za-z_][A-Za-z0-9_]*|\\$\\{[^}]*\\}', name: 'variable.other.tmux-config' },
+        { include: '#format-variable' },
+      ],
+    },
     'format-variable': { match: '#[A-Z0-9]', name: 'variable.other.tmux-config' },
     format: {
-      begin: '#\\{', end: '\\}', name: 'meta.interpolation.tmux-config',
+      begin: '#\\{',
+      end: '\\}',
+      name: 'meta.interpolation.tmux-config',
       beginCaptures: { 0: { name: 'punctuation.definition.interpolation.tmux-config' } },
       endCaptures: { 0: { name: 'punctuation.definition.interpolation.tmux-config' } },
       patterns: [
-        { include: '#format' }, { include: '#style' }, { include: '#job' },
+        { include: '#format' },
+        { include: '#style' },
+        { include: '#job' },
         { match: '#[,}]', name: 'constant.character.escape.tmux-config' },
         { match: '[?:,=<>!+*/|&;-]+', name: 'keyword.operator.tmux-config' },
         { match: '[A-Za-z_][A-Za-z0-9_]*', name: 'variable.other.tmux-config' },
@@ -50,11 +67,15 @@ export const tmuxConfig = {
       ],
     },
     style: {
-      begin: '#\\[', end: '\\]', name: 'meta.style.tmux-config',
+      begin: '#\\[',
+      end: '\\]',
+      name: 'meta.style.tmux-config',
       patterns: [{ include: '#format' }, { match: '[A-Za-z][\\w-]*', name: 'constant.other.style.tmux-config' }],
     },
     job: {
-      begin: '#\\(', end: '\\)', name: 'meta.job.tmux-config',
+      begin: '#\\(',
+      end: '\\)',
+      name: 'meta.job.tmux-config',
       patterns: [{ include: '#escape' }, { include: '#format' }, { include: '#variable' }],
     },
   },
diff --git a/site/src/lib/tmux-manual-data.ts b/site/src/lib/tmux-manual-data.ts
index 19a1c682d..402357b23 100644
--- a/site/src/lib/tmux-manual-data.ts
+++ b/site/src/lib/tmux-manual-data.ts
@@ -39,14 +39,14 @@ export function tmuxManualVersionUrl(version: string, command?: string): string
 export function isLegacyTmuxManualPath(pathname: string): boolean {
   const match = pathname.match(/\/tmux\/([^/]+)\/reference\/(.*?)\/?$/)
   if (!match || !TMUX_VERSIONS.includes(match[1])) return false
-  return match[2] === 'manual'
-    || tmuxManual(match[1]).commands.some((command) => command.name === match[2])
+  return match[2] === 'manual' || tmuxManual(match[1]).commands.some((command) => command.name === match[2])
 }
 
 export function tmuxManualRoutes(): { version: string; slug?: string }[] {
   if (!buildsTmuxDocumentation()) return []
   return TMUX_VERSIONS.flatMap((version) => [
-    { version }, { version, slug: 'full' },
+    { version },
+    { version, slug: 'full' },
     ...tmuxManual(version).commands.map((command) => ({ version, slug: command.name })),
   ])
 }
@@ -58,14 +58,15 @@ export function tmuxManualHtml(html: string, version: string): string {
 }
 
 export function tmuxManualTitle(version: string, slug?: string): string {
-  return slug === 'full' ? `tmux ${tmuxManual(version).version} manual`
-    : slug ? `tmux ${slug}` : 'tmux manual'
+  return slug === 'full' ? `tmux ${tmuxManual(version).version} manual` : slug ? `tmux ${slug}` : 'tmux manual'
 }
 
 export function tmuxManualDescription(version: string, slug?: string): string {
   const reference = tmuxManual(version)
-  return reference.commands.find((command) => command.name === slug)?.summary
-    ?? `Command syntax and behavior for tmux ${reference.version}.`
+  return (
+    reference.commands.find((command) => command.name === slug)?.summary ??
+    `Command syntax and behavior for tmux ${reference.version}.`
+  )
 }
 
 // These concepts differ by target scope, while tmux uses flags on one command.
@@ -74,35 +75,55 @@ const scopedConcepts: Record<string, string[]> = {
   'list-windows': ['list-server-windows'],
   'list-panes': ['list-session-panes', 'list-server-panes'],
 }
-const commandConcepts = (name: string) => [name, ...(scopedConcepts[name] ?? [])]
-  .flatMap((key) => CONCEPTS[key] ? [CONCEPTS[key]] : [])
+const commandConcepts = (name: string) =>
+  [name, ...(scopedConcepts[name] ?? [])].flatMap((key) => (CONCEPTS[key] ? [CONCEPTS[key]] : []))
 
 const guides = [
   { path: 'guides/getting-started', title: 'Start a tmux session', commands: ['new-session', 'list-sessions'] },
-  { path: 'guides/attaching-to-tmux', title: 'Attach to an existing session', commands: ['attach-session', 'has-session'] },
+  {
+    path: 'guides/attaching-to-tmux',
+    title: 'Attach to an existing session',
+    commands: ['attach-session', 'has-session'],
+  },
   { path: 'guides/sending-keys', title: 'Send input to a pane', commands: ['send-keys', 'send-prefix'] },
   { path: 'guides/capturing-output', title: 'Capture pane output', commands: ['capture-pane', 'clear-history'] },
-  { path: 'guides/querying-and-filtering', title: 'Find sessions, windows, and panes', commands: ['list-sessions', 'list-windows', 'list-panes', 'display-message'] },
-  { path: 'guides/testing-with-libtmux', title: 'Test with an isolated server', commands: ['new-session', 'new-window', 'kill-server'] },
-  { path: 'topics/options-and-hooks', title: 'Set options and hooks', commands: ['set-option', 'show-options', 'set-window-option', 'show-window-options', 'set-hook', 'show-hooks'] },
+  {
+    path: 'guides/querying-and-filtering',
+    title: 'Find sessions, windows, and panes',
+    commands: ['list-sessions', 'list-windows', 'list-panes', 'display-message'],
+  },
+  {
+    path: 'guides/testing-with-libtmux',
+    title: 'Test with an isolated server',
+    commands: ['new-session', 'new-window', 'kill-server'],
+  },
+  {
+    path: 'topics/options-and-hooks',
+    title: 'Set options and hooks',
+    commands: ['set-option', 'show-options', 'set-window-option', 'show-window-options', 'set-hook', 'show-hooks'],
+  },
   { path: 'topics/waiting-and-retry', title: 'Wait for completion', commands: ['wait-for'] },
 ]
 
 export function tmuxGuidesFor(command: string) {
-  return guides.filter((guide) => guide.commands.includes(command))
+  return guides
+    .filter((guide) => guide.commands.includes(command))
     .map((guide) => ({ title: guide.title, href: withPortRoot(`/tmux/${guide.path}/`) }))
 }
 
 /** Link only declarations present in the integrated library models. */
 export function tmuxApiLinks(command: string) {
   const seen = new Set<string>()
-  return commandConcepts(command).flatMap((concept) => Object.entries(concept.symbols).flatMap(([port, id]) => {
-    if (seen.has(port) || !API_MODELS[port]?.symbols.some((symbol) => (symbol.publicId ?? symbol.id) === id)) return []
-    const href = referenceHref(port, id)
-    if (!href) return []
-    seen.add(port)
-    return [{ name: PORT_BY_SLUG[port].name, href }]
-  }))
+  return commandConcepts(command).flatMap((concept) =>
+    Object.entries(concept.symbols).flatMap(([port, id]) => {
+      if (seen.has(port) || !API_MODELS[port]?.symbols.some((symbol) => (symbol.publicId ?? symbol.id) === id))
+        return []
+      const href = referenceHref(port, id)
+      if (!href) return []
+      seen.add(port)
+      return [{ name: PORT_BY_SLUG[port].name, href }]
+    }),
+  )
 }
 
 /** Task-oriented notes complement the pinned manual; the native catalog gates flags. */
@@ -111,39 +132,100 @@ export function tmuxCommandNotes(version: string, slug?: string) {
   const command = tmuxManual(version).commands.find((entry) => entry.name === slug)!
   const flags = new Set([...command.usage.matchAll(/(?:^|[\s\[])-([A-Za-z]+)/g)].flatMap((match) => [...match[1]]))
   const groups = [
-    { id: 'output-and-range', title: 'Output and line range', options: [
-      { flag: 'p', label: '-p', text: 'Print to standard output. Without this flag, tmux saves the capture in a paste buffer.' },
-      { flag: 'b', label: '-b name', text: 'Choose the paste buffer when -p is omitted. Without -b, tmux creates a new buffer.' },
-      { flag: 't', label: '-t pane', text: 'Choose the pane to capture. Inside tmux, "$TMUX_PANE" identifies the current pane.' },
-      { flag: 'S', label: '-S start', text: 'First line to capture. Zero is the first visible line; negative numbers reach into history. Use - for the start of history.' },
-      { flag: 'E', label: '-E end', text: 'Last line to capture. Use a line number, or - for the end of the visible pane. By default, capture only the visible pane.' },
-    ] },
-    { id: 'text-formatting', title: 'Text formatting', options: [
-      { flag: 'J', label: '-J', text: `Join wrapped lines and preserve trailing spaces.${flags.has('T') ? ' Implies -T.' : ''}` },
-      { flag: 'e', label: '-e', text: 'Keep escape sequences for text attributes and colors.' },
-      { flag: 'C', label: '-C', text: 'Escape non-printable characters as octal \\xxx sequences.' },
-      { flag: 'N', label: '-N', text: 'Preserve trailing spaces at the end of each line.' },
-      { flag: 'T', label: '-T', text: 'Ignore trailing positions that contain no character.' },
-      { flag: 'H', label: '-H', text: 'Capture only hyperlink targets, separated by spaces when a line contains several.' },
-      { flag: 'L', label: '-L', text: 'Prefix each line with its line number.' },
-      { flag: 'F', label: '-F', text: 'Prefix each line with its flags: - none, D unused, O output, P prompt, X extended cells, H hyperlinks.' },
-    ] },
-    { id: 'screens-and-pending-output', title: 'Screens and pending output', options: [
-      { flag: 'a', label: '-a', text: 'Capture the alternate screen instead of the normal screen. History is unavailable. Fails if no alternate screen exists.' },
-      { flag: 'q', label: '-q', text: 'With -a, suppress the error when no alternate screen exists.' },
-      { flag: 'M', label: '-M', text: 'Capture the mode screen, such as copy mode, when the pane is in a mode.' },
-      { flag: 'P', label: '-P', text: 'Capture a received but incomplete escape sequence, rather than the pane contents.' },
-    ] },
+    {
+      id: 'output-and-range',
+      title: 'Output and line range',
+      options: [
+        {
+          flag: 'p',
+          label: '-p',
+          text: 'Print to standard output. Without this flag, tmux saves the capture in a paste buffer.',
+        },
+        {
+          flag: 'b',
+          label: '-b name',
+          text: 'Choose the paste buffer when -p is omitted. Without -b, tmux creates a new buffer.',
+        },
+        {
+          flag: 't',
+          label: '-t pane',
+          text: 'Choose the pane to capture. Inside tmux, "$TMUX_PANE" identifies the current pane.',
+        },
+        {
+          flag: 'S',
+          label: '-S start',
+          text: 'First line to capture. Zero is the first visible line; negative numbers reach into history. Use - for the start of history.',
+        },
+        {
+          flag: 'E',
+          label: '-E end',
+          text: 'Last line to capture. Use a line number, or - for the end of the visible pane. By default, capture only the visible pane.',
+        },
+      ],
+    },
+    {
+      id: 'text-formatting',
+      title: 'Text formatting',
+      options: [
+        {
+          flag: 'J',
+          label: '-J',
+          text: `Join wrapped lines and preserve trailing spaces.${flags.has('T') ? ' Implies -T.' : ''}`,
+        },
+        { flag: 'e', label: '-e', text: 'Keep escape sequences for text attributes and colors.' },
+        { flag: 'C', label: '-C', text: 'Escape non-printable characters as octal \\xxx sequences.' },
+        { flag: 'N', label: '-N', text: 'Preserve trailing spaces at the end of each line.' },
+        { flag: 'T', label: '-T', text: 'Ignore trailing positions that contain no character.' },
+        {
+          flag: 'H',
+          label: '-H',
+          text: 'Capture only hyperlink targets, separated by spaces when a line contains several.',
+        },
+        { flag: 'L', label: '-L', text: 'Prefix each line with its line number.' },
+        {
+          flag: 'F',
+          label: '-F',
+          text: 'Prefix each line with its flags: - none, D unused, O output, P prompt, X extended cells, H hyperlinks.',
+        },
+      ],
+    },
+    {
+      id: 'screens-and-pending-output',
+      title: 'Screens and pending output',
+      options: [
+        {
+          flag: 'a',
+          label: '-a',
+          text: 'Capture the alternate screen instead of the normal screen. History is unavailable. Fails if no alternate screen exists.',
+        },
+        { flag: 'q', label: '-q', text: 'With -a, suppress the error when no alternate screen exists.' },
+        { flag: 'M', label: '-M', text: 'Capture the mode screen, such as copy mode, when the pane is in a mode.' },
+        {
+          flag: 'P',
+          label: '-P',
+          text: 'Capture a received but incomplete escape sequence, rather than the pane contents.',
+        },
+      ],
+    },
   ].map((group) => {
     const id = rowAnchor(rowAnchor(command.name, 'options'), group.title)
-    return { ...group, id, legacyId: group.id, options: group.options.filter((option) => flags.has(option.flag))
-      .map((option) => ({ ...option, id: rowAnchor(id, option.flag) })) }
+    return {
+      ...group,
+      id,
+      legacyId: group.id,
+      options: group.options
+        .filter((option) => flags.has(option.flag))
+        .map((option) => ({ ...option, id: rowAnchor(id, option.flag) })),
+    }
   })
   return {
     context: 'Run these commands inside tmux, in the pane you want to capture. TMUX_PANE identifies that pane.',
     examples: [
       { title: 'Print the visible pane', code: 'tmux capture-pane -p -t "$TMUX_PANE"' },
-      { title: 'Include up to 1,000 history lines and join wrapped lines', code: 'tmux capture-pane -p -J -S -1000 -t "$TMUX_PANE"' },
+      {
+        title: 'Include up to 1,000 history lines and join wrapped lines',
+        code: 'tmux capture-pane -p -J -S -1000 -t "$TMUX_PANE"',
+      },
     ],
     groups,
   }
@@ -154,21 +236,26 @@ export function tmuxManualHeadings(version: string, slug?: string) {
   const reference = tmuxManual(version)
   if (slug === 'full') return reference.sections.map((section) => ({ depth: 2, slug: section.id, text: section.title }))
   const notes = tmuxCommandNotes(version, slug)
-  if (slug) return [
-    ...(notes ? [{ depth: 2, slug: 'examples', text: 'Common uses' }] : []),
-    { depth: 2, slug: 'syntax', text: 'Syntax' },
-    { depth: 2, slug: 'behavior', text: notes ? 'Options' : 'Behavior' },
-    ...(notes?.groups.map((group) => ({ depth: 3, slug: group.id, text: group.title })) ?? []),
-    ...(tmuxGuidesFor(slug).length ? [{ depth: 2, slug: 'guides', text: 'Guides' }] : []),
-    ...(tmuxApiLinks(slug).length ? [{ depth: 2, slug: 'libraries', text: 'Use from a library' }] : []),
-  ].map((heading) => heading.depth === 2 ? { ...heading, slug: rowAnchor(slug, heading.text) } : heading)
+  if (slug)
+    return [
+      ...(notes ? [{ depth: 2, slug: 'examples', text: 'Common uses' }] : []),
+      { depth: 2, slug: 'syntax', text: 'Syntax' },
+      { depth: 2, slug: 'behavior', text: notes ? 'Options' : 'Behavior' },
+      ...(notes?.groups.map((group) => ({ depth: 3, slug: group.id, text: group.title })) ?? []),
+      ...(tmuxGuidesFor(slug).length ? [{ depth: 2, slug: 'guides', text: 'Guides' }] : []),
+      ...(tmuxApiLinks(slug).length ? [{ depth: 2, slug: 'libraries', text: 'Use from a library' }] : []),
+    ].map((heading) => (heading.depth === 2 ? { ...heading, slug: rowAnchor(slug, heading.text) } : heading))
   return [...new Set(reference.commands.map((entry) => entry.section))].map((section) => ({
-    depth: 2, slug: section.toLowerCase().replaceAll(' ', '-'), text: section[0] + section.slice(1).toLowerCase(),
+    depth: 2,
+    slug: section.toLowerCase().replaceAll(' ', '-'),
+    text: section[0] + section.slice(1).toLowerCase(),
   }))
 }
 
 /** Match source-verified concepts to commands present in the selected manual. */
 export function tmuxCommandsFor(port: string, publicId: string): TmuxCommand[] {
   const concepts = conceptsFor(port, publicId)
-  return tmuxManual('latest').commands.filter((command) => commandConcepts(command.name).some((concept) => concepts.includes(concept)))
+  return tmuxManual('latest').commands.filter((command) =>
+    commandConcepts(command.name).some((concept) => concepts.includes(concept)),
+  )
 }
diff --git a/site/src/lib/tmux-manual.ts b/site/src/lib/tmux-manual.ts
index fc7c73ce9..8febe24d1 100644
--- a/site/src/lib/tmux-manual.ts
+++ b/site/src/lib/tmux-manual.ts
@@ -9,11 +9,30 @@ function text(node: Root['children'][number]): string {
 }
 
 const punctuation: Record<string, string> = {
-  '!': 'exclamation', '"': 'double-quote', '#': 'hash', '$': 'dollar', '%': 'percent',
-  '&': 'ampersand', "'": 'single-quote', '(': 'left-parenthesis', ')': 'right-parenthesis',
-  '*': 'asterisk', ',': 'comma', '-': 'minus', '.': 'period', ':': 'colon', ';': 'semicolon',
-  '=': 'equals', '?': 'question', '[': 'left-bracket', ']': 'right-bracket',
-  '{': 'left-brace', '}': 'right-brace', '~': 'tilde', '/': 'slash', '\\': 'backslash',
+  '!': 'exclamation',
+  '"': 'double-quote',
+  '#': 'hash',
+  $: 'dollar',
+  '%': 'percent',
+  '&': 'ampersand',
+  "'": 'single-quote',
+  '(': 'left-parenthesis',
+  ')': 'right-parenthesis',
+  '*': 'asterisk',
+  ',': 'comma',
+  '-': 'minus',
+  '.': 'period',
+  ':': 'colon',
+  ';': 'semicolon',
+  '=': 'equals',
+  '?': 'question',
+  '[': 'left-bracket',
+  ']': 'right-bracket',
+  '{': 'left-brace',
+  '}': 'right-brace',
+  '~': 'tilde',
+  '/': 'slash',
+  '\\': 'backslash',
 }
 
 /** Keep lower-case keys distinct from Shift keys and punctuation addressable. */
@@ -29,23 +48,26 @@ function entryName(label: string): string {
 export function linkTmuxManualEntries(html: string, namespace = 'manual'): string {
   const tree = fromHtml(html, { fragment: true })
   const used = new Set<string>()
-  visit(tree, 'element', (node) => { if (node.properties.id) used.add(String(node.properties.id)) })
+  visit(tree, 'element', (node) => {
+    if (node.properties.id) used.add(String(node.properties.id))
+  })
   function walk(parent: Element | Root, section: string) {
     for (const node of parent.children) {
       if (node.type !== 'element') continue
       if (node.tagName === 'h2') {
-        section = text(node).replace(/\s+/g, ' ').trim() === 'DEFAULT KEY BINDINGS'
-          ? 'default-key-binding' : text(node)
+        section = text(node).replace(/\s+/g, ' ').trim() === 'DEFAULT KEY BINDINGS' ? 'default-key-binding' : text(node)
       } else if (node.tagName === 'h3') section = rowAnchor(section, text(node))
       if (node.tagName === 'dt') {
-        const label = text(select('code', node) ?? node).replace(/\s+/g, ' ').trim()
+        const label = text(select('code', node) ?? node)
+          .replace(/\s+/g, ' ')
+          .trim()
         const base = rowAnchor(section, entryName(label))
         let id = base
         for (let suffix = 2; used.has(id); suffix++) id = `${base}-${suffix}`
         used.add(id)
         const oldId = node.properties.id
         node.properties.id = id
-        node.properties.className = [...(node.properties.className as string[] ?? []), 'anchored-entry']
+        node.properties.className = [...((node.properties.className as string[]) ?? []), 'anchored-entry']
         const link = { href: `#${id}`, ariaLabel: `Link to ${label} in ${section.replace(/\s+/g, ' ').trim()}` }
         if (!select('a', node)) node.children = [h('a.row-label-link', link, node.children)]
         else node.children.push(h('a.manual-entry-permalink', link, [h('span', { ariaHidden: 'true' }, '#')]))
@@ -72,20 +94,25 @@ export async function highlightTmuxManual(html: string): Promise<string> {
   const tree = fromHtml(html, { fragment: true })
   const pending: Promise<void>[] = []
   visit(tree, 'element', (node, index, parent) => {
-    const synopsis = node.tagName === 'table' && Array.isArray(node.properties.className) && node.properties.className.includes('Nm')
+    const synopsis =
+      node.tagName === 'table' && Array.isArray(node.properties.className) && node.properties.className.includes('Nm')
     if ((!synopsis && node.tagName !== 'pre') || !parent || index === undefined) return
     const code = synopsis ? text(node).replace(/\s+/g, ' ').trim() : text(node)
     if (!code.trim()) return
     const language = synopsis ? 'tmux-usage' : tmuxManualLanguage(code)
-    pending.push((async () => {
-      const rendered = await highlight(code, language)
-      if (!rendered) throw new Error(`Cannot highlight tmux manual ${language} block`)
-      const replacement = fromHtml(rendered, { fragment: true }).children.find((child): child is Element => child.type === 'element')!
-      replacement.properties.className = [...(replacement.properties.className as string[] ?? []), 'lm-highlighted']
-      replacement.properties.dataLanguage = language
-      if (node.properties.id) replacement.properties.id = node.properties.id
-      parent.children[index] = replacement
-    })())
+    pending.push(
+      (async () => {
+        const rendered = await highlight(code, language)
+        if (!rendered) throw new Error(`Cannot highlight tmux manual ${language} block`)
+        const replacement = fromHtml(rendered, { fragment: true }).children.find(
+          (child): child is Element => child.type === 'element',
+        )!
+        replacement.properties.className = [...((replacement.properties.className as string[]) ?? []), 'lm-highlighted']
+        replacement.properties.dataLanguage = language
+        if (node.properties.id) replacement.properties.id = node.properties.id
+        parent.children[index] = replacement
+      })(),
+    )
   })
   await Promise.all(pending)
   return toHtml(tree)
diff --git a/site/src/lib/tmux-reference.ts b/site/src/lib/tmux-reference.ts
index b8d52657c..a0790220c 100644
--- a/site/src/lib/tmux-reference.ts
+++ b/site/src/lib/tmux-reference.ts
@@ -31,7 +31,7 @@ export function tmuxSourceModel(version = 'latest'): TmuxSourceModel {
   return model
 }
 export function tmuxReferenceUrl(version = 'latest', symbol?: ApiSymbol): string {
-  const slug = symbol ? symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id) : ''
+  const slug = symbol ? (symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id)) : ''
   return withPortRoot(`/tmux/${version}/reference/${slug ? `${slug}/` : ''}`)
 }
 
@@ -45,73 +45,132 @@ export function tmuxReferenceVersionUrl(version: string, currentVersion: string,
 const domains = [
   { id: 'server', label: 'Server', names: /^server(?!_(?:client|acl))(?:_|$)/, files: /^server(?:-fn)?\.c$/ },
   { id: 'session', label: 'Session', names: /^session(?:s|_|$)/, files: /^session\.c$/ },
-  { id: 'pane', label: 'Pane', names: /^(?:window_pane|window_mode)(?:s|_|$)/, files: /^window-(?:copy|buffer|client|tree|clock|customize)\.c$/ },
+  {
+    id: 'pane',
+    label: 'Pane',
+    names: /^(?:window_pane|window_mode)(?:s|_|$)/,
+    files: /^window-(?:copy|buffer|client|tree|clock|customize)\.c$/,
+  },
   { id: 'window', label: 'Window', names: /^(?:window(?!_(?:pane|mode))|winlink)(?:s|_|$)/, files: /^window\.c$/ },
-  { id: 'client', label: 'Client', names: /^(?:client|server_client|server_acl)(?:s|_|$)/, files: /^(?:client|server-client|server-acl)\.c$/ },
+  {
+    id: 'client',
+    label: 'Client',
+    names: /^(?:client|server_client|server_acl)(?:s|_|$)/,
+    files: /^(?:client|server-client|server-acl)\.c$/,
+  },
   { id: 'commands', label: 'Commands', names: /^(?:cmd|args)(?:_|$)/, files: /^(?:cmd(?:-.*)?|arguments)\.c$/ },
-  { id: 'screen', label: 'Screen and terminal', names: /^(?:screen|grid|tty|input|colour|utf8)(?:_|$)/, files: /^(?:screen|grid|tty|input|colour|utf8)(?:-.*)?\.c$/ },
-  { id: 'options', label: 'Options and formats', names: /^(?:options|format|environ)(?:_|$)/, files: /^(?:options|format|environ)(?:-.*)?\.c$/ },
-  { id: 'layout', label: 'Layouts and buffers', names: /^(?:layout|paste)(?:_|$)/, files: /^(?:layout|paste)(?:-.*)?\.c$/ },
+  {
+    id: 'screen',
+    label: 'Screen and terminal',
+    names: /^(?:screen|grid|tty|input|colour|utf8)(?:_|$)/,
+    files: /^(?:screen|grid|tty|input|colour|utf8)(?:-.*)?\.c$/,
+  },
+  {
+    id: 'options',
+    label: 'Options and formats',
+    names: /^(?:options|format|environ)(?:_|$)/,
+    files: /^(?:options|format|environ)(?:-.*)?\.c$/,
+  },
+  {
+    id: 'layout',
+    label: 'Layouts and buffers',
+    names: /^(?:layout|paste)(?:_|$)/,
+    files: /^(?:layout|paste)(?:-.*)?\.c$/,
+  },
   { id: 'compat', label: 'Compatibility', names: /^(?:compat)_/, files: /^compat\// },
 ]
 
 /** Entry points into each subsystem, in the order a reader follows its work. */
 const selections: Record<string, string[]> = {
   server: [
-    'c:function:server_start', 'c:function:server_create_socket',
-    'c:function:server_update_socket', 'c:function:server_check_unattached',
-    'c:function:server_destroy_session', 'c:function:server_kill_window',
+    'c:function:server_start',
+    'c:function:server_create_socket',
+    'c:function:server_update_socket',
+    'c:function:server_check_unattached',
+    'c:function:server_destroy_session',
+    'c:function:server_kill_window',
     'c:function:server_kill_pane',
   ],
   session: [
-    'c:struct:session', 'c:function:session_create',
-    'c:function:session_find', 'c:function:session_find_by_id',
-    'c:function:session_attach', 'c:function:session_detach',
-    'c:function:session_select', 'c:function:session_set_current',
+    'c:struct:session',
+    'c:function:session_create',
+    'c:function:session_find',
+    'c:function:session_find_by_id',
+    'c:function:session_attach',
+    'c:function:session_detach',
+    'c:function:session_select',
+    'c:function:session_set_current',
     'c:function:session_destroy',
   ],
   window: [
-    'c:struct:window', 'c:struct:winlink',
-    'c:function:window_create', 'c:function:window_find_by_id',
-    'c:function:window_set_active_pane', 'c:function:window_add_pane',
-    'c:function:window_remove_pane', 'c:function:window_resize',
+    'c:struct:window',
+    'c:struct:winlink',
+    'c:function:window_create',
+    'c:function:window_find_by_id',
+    'c:function:window_set_active_pane',
+    'c:function:window_add_pane',
+    'c:function:window_remove_pane',
+    'c:function:window_resize',
   ],
   pane: [
-    'c:struct:window_pane', 'c:function:window_pane_find_by_id',
-    'c:function:window_pane_at_index', 'c:function:window_pane_key',
-    'c:function:window_pane_paste', 'c:function:window_pane_resize',
-    'c:function:window_pane_set_mode', 'c:function:window_pane_reset_mode',
+    'c:struct:window_pane',
+    'c:function:window_pane_find_by_id',
+    'c:function:window_pane_at_index',
+    'c:function:window_pane_key',
+    'c:function:window_pane_paste',
+    'c:function:window_pane_resize',
+    'c:function:window_pane_set_mode',
+    'c:function:window_pane_reset_mode',
   ],
   client: [
-    'c:struct:client', 'c:function:client_main',
-    'c:function:server_client_create', 'c:function:server_client_open',
-    'c:function:server_client_set_session', 'c:function:server_client_detach',
+    'c:struct:client',
+    'c:function:client_main',
+    'c:function:server_client_create',
+    'c:function:server_client_open',
+    'c:function:server_client_set_session',
+    'c:function:server_client_detach',
     'c:function:server_client_lost',
   ],
   commands: [
-    'c:struct:cmd', 'c:struct:cmd_entry',
-    'c:struct:args', 'c:struct:cmd_parse_result',
-    'c:struct:cmd_find_state', 'c:function:cmd_parse_from_string',
-    'c:function:cmd_find_target', 'c:function:cmdq_get_command',
-    'c:function:cmdq_append', 'c:function:cmdq_next',
+    'c:struct:cmd',
+    'c:struct:cmd_entry',
+    'c:struct:args',
+    'c:struct:cmd_parse_result',
+    'c:struct:cmd_find_state',
+    'c:function:cmd_parse_from_string',
+    'c:function:cmd_find_target',
+    'c:function:cmdq_get_command',
+    'c:function:cmdq_append',
+    'c:function:cmdq_next',
   ],
   options: [
-    'c:struct:options', 'c:struct:format_tree',
-    'c:struct:environ', 'c:function:options_get',
-    'c:function:options_set_string', 'c:function:options_set_number',
-    'c:function:format_create', 'c:function:format_expand',
+    'c:struct:options',
+    'c:struct:format_tree',
+    'c:struct:environ',
+    'c:function:options_get',
+    'c:function:options_set_string',
+    'c:function:options_set_number',
+    'c:function:format_create',
+    'c:function:format_expand',
   ],
   screen: [
-    'c:struct:screen', 'c:struct:grid',
-    'c:struct:grid_cell', 'c:struct:tty',
-    'c:function:screen_init', 'c:function:screen_resize',
-    'c:function:screen_write_start', 'c:function:screen_write_puts',
+    'c:struct:screen',
+    'c:struct:grid',
+    'c:struct:grid_cell',
+    'c:struct:tty',
+    'c:function:screen_init',
+    'c:function:screen_resize',
+    'c:function:screen_write_start',
+    'c:function:screen_write_puts',
     'c:function:screen_write_stop',
   ],
   layout: [
-    'c:struct:layout_cell', 'c:struct:paste_buffer',
-    'c:function:layout_init', 'c:function:layout_split_pane',
-    'c:function:layout_resize_pane', 'c:function:paste_get_top',
+    'c:struct:layout_cell',
+    'c:struct:paste_buffer',
+    'c:function:layout_init',
+    'c:function:layout_split_pane',
+    'c:function:layout_resize_pane',
+    'c:function:paste_get_top',
     'c:function:paste_set',
   ],
 }
@@ -123,8 +182,9 @@ function navigationFor(model: TmuxSourceModel) {
   const groups = new Map<string, string[]>()
   for (const symbol of topLevel) {
     // Primary object names group their operations; source files place the rest.
-    const domain = domains.find((entry) => entry.names.test(symbol.name))
-      ?? domains.find((entry) => entry.files.test(symbol.source.file))
+    const domain =
+      domains.find((entry) => entry.names.test(symbol.name)) ??
+      domains.find((entry) => entry.files.test(symbol.source.file))
     const key = domain?.id ?? 'support'
     const entries = groups.get(key) ?? []
     entries.push(symbol.id)
@@ -137,24 +197,49 @@ function navigationFor(model: TmuxSourceModel) {
       const order = (selections[domain.id] ?? []).filter((id) => available.has(id))
       const rest = ids.filter((id) => !order.includes(id))
       return {
-        id: domain.id, label: domain.label,
+        id: domain.id,
+        label: domain.label,
         collapsed: !['server', 'session', 'window', 'pane', 'client'].includes(domain.id),
-        match: { kind: 'id' as const, is: ids }, order,
-        ...(order.length && rest.length ? { children: [{
-          id: `${domain.id}-support`, label: 'Supporting declarations', collapsed: true,
-          match: { kind: 'id' as const, is: rest },
-        }] } : {}),
+        match: { kind: 'id' as const, is: ids },
+        order,
+        ...(order.length && rest.length
+          ? {
+              children: [
+                {
+                  id: `${domain.id}-support`,
+                  label: 'Supporting declarations',
+                  collapsed: true,
+                  match: { kind: 'id' as const, is: rest },
+                },
+              ],
+            }
+          : {}),
       }
     })
   // Match order handles overlapping vocabulary; display follows tmux's hierarchy.
-  const order = ['server', 'session', 'window', 'pane', 'client', 'commands', 'options', 'screen', 'layout', 'compat', 'support']
+  const order = [
+    'server',
+    'session',
+    'window',
+    'pane',
+    'client',
+    'commands',
+    'options',
+    'screen',
+    'layout',
+    'compat',
+    'support',
+  ]
   buckets.sort((left, right) => order.indexOf(left.id) - order.indexOf(right.id))
   const nav = navSidecarFor('tmux', model, { buckets }) as ReturnType<typeof navSidecarFor> & PortNavData
   return { nav, tree: navTreeFor(model, nav) }
 }
 function navigation(model: TmuxSourceModel) {
   let value = navigationCache.get(model)
-  if (!value) { value = navigationFor(model); navigationCache.set(model, value) }
+  if (!value) {
+    value = navigationFor(model)
+    navigationCache.set(model, value)
+  }
   return value
 }
 
@@ -173,38 +258,49 @@ export function tmuxReferenceTree(version = 'latest') {
   return referenceTreeFor('tmux', model, navigation(model).tree)
 }
 export function tmuxSourceCommands(version: string, symbol: ApiSymbol) {
-  return tmuxSourceModel(version).commands
-    .filter((command) => command.entry === symbol.id || command.callback === symbol.id)
+  return tmuxSourceModel(version)
+    .commands.filter((command) => command.entry === symbol.id || command.callback === symbol.id)
     .map((command) => ({ name: command.name, href: tmuxManualUrl(version, command.name) }))
 }
 export function tmuxCommandSources(version: string, name: string) {
   const model = tmuxSourceModel(version)
   const command = model.commands.find((entry) => entry.name === name)
-  return command ? [command.entry, command.callback].flatMap((id) => {
-    const symbol = model.symbols.find((entry) => entry.id === id)
-    return symbol ? [{ name: symbol.name, href: tmuxReferenceUrl(version, symbol) }] : []
-  }) : []
+  return command
+    ? [command.entry, command.callback].flatMap((id) => {
+        const symbol = model.symbols.find((entry) => entry.id === id)
+        return symbol ? [{ name: symbol.name, href: tmuxReferenceUrl(version, symbol) }] : []
+      })
+    : []
 }
 export function tmuxReferenceRoutes() {
-  return buildsTmuxDocumentation() ? TMUX_VERSIONS.flatMap((version) => [
-    { version, symbol: undefined as ApiSymbol | undefined },
-    ...tmuxSourceModel(version).symbols.map((symbol) => ({ version, symbol })),
-  ]) : []
+  return buildsTmuxDocumentation()
+    ? TMUX_VERSIONS.flatMap((version) => [
+        { version, symbol: undefined as ApiSymbol | undefined },
+        ...tmuxSourceModel(version).symbols.map((symbol) => ({ version, symbol })),
+      ])
+    : []
 }
 /** Representative reading paths, checked against each version's native edges. */
 export function tmuxReferencePaths(version = 'latest') {
   const model = tmuxSourceModel(version)
   const paths = [
     apiRelationshipPath(model, 'Create a session and its first pane', [
-      'c:function:cmd-new-session.c:cmd_new_session_exec', 'c:function:spawn_window',
-      'c:function:spawn_pane', 'c:function:window_add_pane', 'c:function:window.c:window_pane_create',
+      'c:function:cmd-new-session.c:cmd_new_session_exec',
+      'c:function:spawn_window',
+      'c:function:spawn_pane',
+      'c:function:window_add_pane',
+      'c:function:window.c:window_pane_create',
     ]),
     apiRelationshipPath(model, 'Split a window', [
-      'c:function:cmd-split-window.c:cmd_split_window_exec', 'c:function:spawn_pane',
-      'c:function:window_add_pane', 'c:function:window.c:window_pane_create',
+      'c:function:cmd-split-window.c:cmd_split_window_exec',
+      'c:function:spawn_pane',
+      'c:function:window_add_pane',
+      'c:function:window.c:window_pane_create',
     ]),
     apiRelationshipPath(model, 'Start the server and create a client', [
-      'c:function:server_start', 'c:function:server_client_create', 'c:function:proc_add_peer',
+      'c:function:server_start',
+      'c:function:server_client_create',
+      'c:function:proc_add_peer',
     ]),
   ]
   return paths.filter((path) => path !== undefined)
@@ -214,7 +310,10 @@ export function tmuxReferenceContext(version: string, symbol?: ApiSymbol) {
   const commands = symbol ? tmuxSourceCommands(version, symbol) : []
   const equivalents = commands.flatMap((command) => tmuxApiLinks(command.name))
   return {
-    model, version, label: 'tmux C', title: 'tmux C source reference',
+    model,
+    version,
+    label: 'tmux C',
+    title: 'tmux C source reference',
     description: `C declarations from tmux ${model.version}. These are tmux internals, not a supported external library API.`,
     referenceBase: tmuxReferenceUrl(version),
     pagePath: `tmux/${version}/reference${symbol ? `/${symbol.slug}` : ''}`,
@@ -223,11 +322,16 @@ export function tmuxReferenceContext(version: string, symbol?: ApiSymbol) {
       { name: `Reference (${model.version})`, url: tmuxReferenceUrl(version) },
       ...(symbol ? [{ name: symbol.name, url: tmuxReferenceUrl(version, symbol) }] : []),
     ],
-    ...navigation(model), index: tmuxReferenceIndex(version), paths: tmuxReferencePaths(version),
+    ...navigation(model),
+    index: tmuxReferenceIndex(version),
+    paths: tmuxReferencePaths(version),
     manualLinks: commands,
-    pagePorts: PORTS.map((port) => ({ port: port.slug, name: port.name,
-      links: [...new Set(equivalents.filter((entry) => entry.name === port.name).map((entry) => entry.href))]
-        .map((href) => ({ href })),
+    pagePorts: PORTS.map((port) => ({
+      port: port.slug,
+      name: port.name,
+      links: [...new Set(equivalents.filter((entry) => entry.name === port.name).map((entry) => entry.href))].map(
+        (href) => ({ href }),
+      ),
     })),
   }
 }
diff --git a/site/src/lib/versions.ts b/site/src/lib/versions.ts
index fda500157..54aab2a38 100644
--- a/site/src/lib/versions.ts
+++ b/site/src/lib/versions.ts
@@ -241,20 +241,23 @@ export function newestPublishedTag(
   const releases = tags
     .map((name) => ({ name, version: releaseTag(name, port) }))
     .filter((entry): entry is { name: string; version: string } => entry.version !== null)
-  const candidates = published && published.length > 0
-    ? releases.filter((entry) => {
-        const tag = packageVersion(entry.version, port.tagGrammar).tag
-        return published.some(
-          (version) => compareTags(packageVersion(version, port.tagGrammar).tag, tag, port.tagGrammar) === 0,
-        )
-      })
-    : releases
+  const candidates =
+    published && published.length > 0
+      ? releases.filter((entry) => {
+          const tag = packageVersion(entry.version, port.tagGrammar).tag
+          return published.some(
+            (version) => compareTags(packageVersion(version, port.tagGrammar).tag, tag, port.tagGrammar) === 0,
+          )
+        })
+      : releases
   if (candidates.length === 0) return null
-  const newest = [...candidates].sort((a, b) => compareTags(
-    packageVersion(a.version, port.tagGrammar).tag,
-    packageVersion(b.version, port.tagGrammar).tag,
-    port.tagGrammar,
-  ))[0]
+  const newest = [...candidates].sort((a, b) =>
+    compareTags(
+      packageVersion(a.version, port.tagGrammar).tag,
+      packageVersion(b.version, port.tagGrammar).tag,
+      port.tagGrammar,
+    ),
+  )[0]
   return newest.name
 }
 
@@ -275,7 +278,11 @@ export function packageVersionIsPrerelease(version: string, grammar: TagGrammar)
  * prerelease above the release it precedes. This function is what the
  * switcher renders, so it is the ordering that has to be right.
  */
-export function sortVersions(entries: VersionEntry[], grammar: TagGrammar = 'semver', tagPrefix?: string): VersionEntry[] {
+export function sortVersions(
+  entries: VersionEntry[],
+  grammar: TagGrammar = 'semver',
+  tagPrefix?: string,
+): VersionEntry[] {
   const rank: Record<VersionKind, number> = { alias: 0, trunk: 1, tag: 2, branch: 3, pr: 4 }
   const tagName = (slug: string) => {
     const version = releaseTag(slug, { tagGrammar: grammar, tagPrefix }) ?? slug
diff --git a/site/src/lib/workspace-shared-slots.ts b/site/src/lib/workspace-shared-slots.ts
index 33dc2b4f9..faafbc975 100644
--- a/site/src/lib/workspace-shared-slots.ts
+++ b/site/src/lib/workspace-shared-slots.ts
@@ -14,7 +14,10 @@ const CONTENT_PORTS = new Set([...PORTS.map((port) => port.slug), 'root'])
 const SLOT_TAG = /<!--\s*port:([\s\S]*?)-->|<!--\s*\/port\s*-->/gi
 
 /** Keep browse cards in their authored port, including explicitly shared root cards. */
-export function selectPortCards<T extends { ports?: readonly string[] }>(cards: readonly T[] | undefined, port?: string): T[] {
+export function selectPortCards<T extends { ports?: readonly string[] }>(
+  cards: readonly T[] | undefined,
+  port?: string,
+): T[] {
   return cards?.filter((card) => !card.ports || card.ports.includes(port || 'root')) ?? []
 }
 
@@ -28,7 +31,12 @@ function fencedRanges(raw: string): [number, number][] {
     if (match) {
       const [, marker, rest] = match
       if (!fence && !(marker[0] === '`' && rest.includes('`'))) {
-        fence = { marker: marker[0], length: marker.length, start: offset, literal: /^(?:markdown|md)\b/.test(rest.trim()) }
+        fence = {
+          marker: marker[0],
+          length: marker.length,
+          start: offset,
+          literal: /^(?:markdown|md)\b/.test(rest.trim()),
+        }
       } else if (fence && marker[0] === fence.marker && marker.length >= fence.length && !rest.trim()) {
         if (fence.literal) ranges.push([fence.start, offset + line.length])
         fence = undefined
@@ -102,7 +110,10 @@ export function resolveSlots(node: SlotNode, port?: string): string {
 }
 
 /** Resolve ownership and retain the context needed to link root-page API names. */
-export function resolvePortContent(raw: string, port?: string): { body: string; portAt: (offset: number) => string | undefined } {
+export function resolvePortContent(
+  raw: string,
+  port?: string,
+): { body: string; portAt: (offset: number) => string | undefined } {
   const parts: string[] = []
   const regions: { start: number; end: number; port: string }[] = []
   let offset = 0
@@ -111,7 +122,10 @@ export function resolvePortContent(raw: string, port?: string): { body: string;
     const owners = node.ports && [...node.ports].filter((owner) => owner !== 'root')
     const owner = owners?.length ? (owners.length === 1 ? owners[0] : undefined) : inherited
     for (const child of node.children) {
-      if (typeof child !== 'string') { append(child, owner); continue }
+      if (typeof child !== 'string') {
+        append(child, owner)
+        continue
+      }
       parts.push(child)
       if (owner) regions.push({ start: offset, end: offset + child.length, port: owner })
       offset += child.length
@@ -135,7 +149,11 @@ export interface SharedFrontmatter {
 }
 
 /** Merge a shared page's defaults with one port's overrides. */
-export function resolvePortData(frontmatter: SharedFrontmatter, port: string, product: string): Record<string, unknown> {
+export function resolvePortData(
+  frontmatter: SharedFrontmatter,
+  port: string,
+  product: string,
+): Record<string, unknown> {
   const { ports: overrides, ...defaults } = frontmatter
   return { ...defaults, ...overrides?.[port], port, product }
 }
diff --git a/site/src/loaders/workspace-shared.ts b/site/src/loaders/workspace-shared.ts
index eee93a095..a2b23bdfe 100644
--- a/site/src/loaders/workspace-shared.ts
+++ b/site/src/loaders/workspace-shared.ts
@@ -116,7 +116,9 @@ export function workspaceDocsLoader(): Loader {
         ownedIds.delete(file)
       }
       const reportError = (file: string, error: unknown) => {
-        context.logger.error(`Failed to reload ${relative(root, file)}: ${error instanceof Error ? error.message : String(error)}`)
+        context.logger.error(
+          `Failed to reload ${relative(root, file)}: ${error instanceof Error ? error.message : String(error)}`,
+        )
       }
 
       const syncShared = async (version: number, initial = false) => {
@@ -139,13 +141,18 @@ export function workspaceDocsLoader(): Loader {
             const ports = PORT_SLUGS.filter((port) => !realIds.has(`ports/${port}/${idFor(relPath)}`))
             const ids = ports.map((port) => `ports/${port}/${idFor(relPath)}`)
             const digests = ports.map((port) => context.generateDigest(`${port}\u0000${raw}`))
-            if (ownedIds.has(file) && ids.every((id, index) => context.store.get(id)?.digest === digests[index])) continue
+            if (ownedIds.has(file) && ids.every((id, index) => context.store.get(id)?.digest === digests[index]))
+              continue
             const { frontmatter, content: body } = parseFrontmatter(raw)
             const entries: Parameters<LoaderContext['store']['set']>[0][] = []
 
             for (const [index, port] of ports.entries()) {
               const id = ids[index]!
-              const data = await context.parseData({ id, data: resolvePortData(frontmatter, port, PRODUCT), filePath: relFilePath })
+              const data = await context.parseData({
+                id,
+                data: resolvePortData(frontmatter, port, PRODUCT),
+                filePath: relFilePath,
+              })
               const resolvedBody = resolvePortBody(body, port)
               const rendered = await context.renderMarkdown(frontmatterBlock(data) + resolvedBody, {
                 fileURL: pathToFileURL(file),
@@ -171,8 +178,8 @@ export function workspaceDocsLoader(): Loader {
         let pending = Promise.resolve()
         const onChange = (changedPath: string) => {
           const relPath = relative(sharedDir, changedPath)
-          if (isAbsolute(relPath) || relPath === '..' || relPath.startsWith(`..${sep}`)
-            || !/\.mdx?$/.test(relPath)) return pending
+          if (isAbsolute(relPath) || relPath === '..' || relPath.startsWith(`..${sep}`) || !/\.mdx?$/.test(relPath))
+            return pending
           context.logger.info(`Reloading shared workspace sources (${relative(root, changedPath)} changed)`)
           const version = ++revision
           // Watchers ignore promises, so the queue must contain every failure.
diff --git a/site/src/pages/[...slug].json.ts b/site/src/pages/[...slug].json.ts
index 7ea08b155..6f07f9bbb 100644
--- a/site/src/pages/[...slug].json.ts
+++ b/site/src/pages/[...slug].json.ts
@@ -7,24 +7,48 @@ import { buildTarget } from '../lib/versions'
 export function getStaticPaths() {
   if (buildLocale() !== DEFAULT_LOCALE) return []
   let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
+  try {
+    defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  } catch {
+    /* Local defaults are latest. */
+  }
   const routes = mcpReferenceRoutes(process.env.LIBTMUX_DOCS_PORT, defaults, buildTarget(process.env).version)
   return [
-    ...routes.map(({ path, port, section, itemSlug }) => ({ params: { slug: path }, props: { port, section, itemSlug } })),
-    ...routes.filter((route) => route.section === 'tools' && !route.itemSlug).map(({ path, port }) => ({
-      params: { slug: path.replace(/tools$/, 'tree') }, props: { port, tree: true },
+    ...routes.map(({ path, port, section, itemSlug }) => ({
+      params: { slug: path },
+      props: { port, section, itemSlug },
     })),
+    ...routes
+      .filter((route) => route.section === 'tools' && !route.itemSlug)
+      .map(({ path, port }) => ({
+        params: { slug: path.replace(/tools$/, 'tree') },
+        props: { port, tree: true },
+      })),
   ]
 }
 
 export const GET: APIRoute = ({ props }) => {
   const reference = MCP_REFERENCE[props.port]
   const object = mcpObjectAt(props.port, props.section, props.itemSlug)
-  const provenance = { repo: reference.repo, revision: reference.revision, extractedRevision: reference.extractedRevision,
-    selection: reference.selection, protocolVersion: reference.protocol.protocolVersion }
-  const index = props.section === 'prompts' ? { ...provenance, prompts: reference.protocol.prompts }
-    : props.section === 'resources' ? { ...provenance, resources: reference.protocol.resources, resourceTemplates: reference.protocol.resourceTemplates }
-    : reference // tools.json remains the existing complete protocol catalog.
-  const content = props.tree ? mcpNavigation(props.port).json : object?.tool ?? object?.item ?? index
-  return new Response(`${JSON.stringify(content, null, 2)}\n`, { headers: { 'Content-Type': 'application/json; charset=utf-8' } })
+  const provenance = {
+    repo: reference.repo,
+    revision: reference.revision,
+    extractedRevision: reference.extractedRevision,
+    selection: reference.selection,
+    protocolVersion: reference.protocol.protocolVersion,
+  }
+  const index =
+    props.section === 'prompts'
+      ? { ...provenance, prompts: reference.protocol.prompts }
+      : props.section === 'resources'
+        ? {
+            ...provenance,
+            resources: reference.protocol.resources,
+            resourceTemplates: reference.protocol.resourceTemplates,
+          }
+        : reference // tools.json remains the existing complete protocol catalog.
+  const content = props.tree ? mcpNavigation(props.port).json : (object?.tool ?? object?.item ?? index)
+  return new Response(`${JSON.stringify(content, null, 2)}\n`, {
+    headers: { 'Content-Type': 'application/json; charset=utf-8' },
+  })
 }
diff --git a/site/src/pages/[...slug].md.ts b/site/src/pages/[...slug].md.ts
index 8b5d0c9ec..e978ab8bd 100644
--- a/site/src/pages/[...slug].md.ts
+++ b/site/src/pages/[...slug].md.ts
@@ -11,9 +11,7 @@ import { docsRedirects, workspaceRedirects } from '../lib/docs-paths'
 import { llmsPage, localeProse } from '../lib/llms'
 import { isIndexSource, markdownDocument, markdownSlug } from '../lib/markdown-twins'
 
-type Props =
-  | { entry: CollectionEntry<'docs'> }
-  | { port: string; id: string; version: string }
+type Props = { entry: CollectionEntry<'docs'> } | { port: string; id: string; version: string }
 
 /**
  * The Markdown twins of `[...slug].astro`'s pages: every prose page, and
@@ -29,34 +27,53 @@ export async function getStaticPaths() {
   const locale = buildLocale()
   const port = process.env.LIBTMUX_DOCS_PORT
   let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults are latest. */ }
+  try {
+    defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  } catch {
+    /* Local defaults are latest. */
+  }
   const proseEntries = localeProse(await getCollection('docs'), locale, port, defaults)
-  const prose = proseEntries
-    .map(({ entry, route }) => ({
-      params: { slug: markdownSlug(route, isIndexSource(entry.filePath)) },
-      props: { entry } as Props,
-    }))
+  const prose = proseEntries.map(({ entry, route }) => ({
+    params: { slug: markdownSlug(route, isIndexSource(entry.filePath)) },
+    props: { entry } as Props,
+  }))
   if (locale !== DEFAULT_LOCALE) return prose
   // Static hosting cannot issue a transport redirect for a Markdown asset.
   // Serve the canonical twin at its legacy path without adding an alias to a
   // manifest, sitemap, or search index.
   const proseByRoute = new Map(proseEntries.map(({ entry, route }) => [route, entry]))
-  const aliases = docsRedirects(proseEntries.map(({ entry }) => entry), port, defaults)
-    .map(({ path, target }) => {
-      const entry = proseByRoute.get(target)
-      if (!entry) throw new Error(`Markdown alias target is not a prose route: ${target}`)
-      return {
-        params: { slug: markdownSlug(path, isIndexSource(entry.filePath)) },
-        props: { entry } as Props,
-      }
-    })
-  const routes = productApiRoutes(API_MODELS, port, defaults, buildTarget(process.env).version)
-    .map(({ path, model, symbol, version }) => ({ params: { slug: path }, props: { port: model.port, id: symbol.id, version } as Props }))
+  const aliases = docsRedirects(
+    proseEntries.map(({ entry }) => entry),
+    port,
+    defaults,
+  ).map(({ path, target }) => {
+    const entry = proseByRoute.get(target)
+    if (!entry) throw new Error(`Markdown alias target is not a prose route: ${target}`)
+    return {
+      params: { slug: markdownSlug(path, isIndexSource(entry.filePath)) },
+      props: { entry } as Props,
+    }
+  })
+  const routes = productApiRoutes(API_MODELS, port, defaults, buildTarget(process.env).version).map(
+    ({ path, model, symbol, version }) => ({
+      params: { slug: path },
+      props: { port: model.port, id: symbol.id, version } as Props,
+    }),
+  )
   const byPath = new Map(routes.map((route) => [route.params.slug, route.props]))
-  const retired = productApiRedirects(API_MODELS, port, defaults, buildTarget(process.env).version)
-    .map(({ path, target }) => ({ params: { slug: path }, props: byPath.get(target)! }))
-  const all = [...prose, ...aliases, ...routes, ...retired, ...workspaceRedirects([...byPath.keys()])
-    .map(({ path, target }) => ({ params: { slug: path }, props: byPath.get(target)! }))]
+  const retired = productApiRedirects(API_MODELS, port, defaults, buildTarget(process.env).version).map(
+    ({ path, target }) => ({ params: { slug: path }, props: byPath.get(target)! }),
+  )
+  const all = [
+    ...prose,
+    ...aliases,
+    ...routes,
+    ...retired,
+    ...workspaceRedirects([...byPath.keys()]).map(({ path, target }) => ({
+      params: { slug: path },
+      props: byPath.get(target)!,
+    })),
+  ]
   const paths = all.map((route) => route.params.slug)
   if (new Set(paths).size !== paths.length) throw new Error('Duplicate generated Markdown route')
   return all
@@ -71,11 +88,15 @@ export const GET: APIRoute = ({ props, site }) => {
   }
   const model = API_MODELS[route.port]
   const symbol = model.symbols.find((entry) => entry.id === route.id)!
-  return new Response(symbolMarkdown({
-    model, symbol,
-    version: route.version,
-    canonical: new URL(productApiHref(model, symbol, route.version), site ?? 'https://libtmux.org').href,
-    source: sourceUrl(model, symbol),
-    packageName: symbol.package ?? model.sources?.find((source) => source.product === symbol.product)?.package,
-  }), { headers })
+  return new Response(
+    symbolMarkdown({
+      model,
+      symbol,
+      version: route.version,
+      canonical: new URL(productApiHref(model, symbol, route.version), site ?? 'https://libtmux.org').href,
+      source: sourceUrl(model, symbol),
+      packageName: symbol.package ?? model.sources?.find((source) => source.product === symbol.product)?.package,
+    }),
+    { headers },
+  )
 }
diff --git a/site/src/pages/[...slug].preview.json.ts b/site/src/pages/[...slug].preview.json.ts
index b4cfeaad9..a97bb59fe 100644
--- a/site/src/pages/[...slug].preview.json.ts
+++ b/site/src/pages/[...slug].preview.json.ts
@@ -16,12 +16,19 @@ export function getStaticPaths() {
   const buildBase = process.env.LIBTMUX_DOCS_BASE ?? '/'
   const buildVersion = buildTarget(process.env).version
   let defaults: Record<string, string> = {}
-  try { defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}') } catch { /* Local defaults use latest. */ }
-  const route = (href: string, preview: LinkPreview) => ({ params: { slug: href.slice(buildBase.length).replace(/\/$/, '') }, props: { preview } })
+  try {
+    defaults = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
+  } catch {
+    /* Local defaults use latest. */
+  }
+  const route = (href: string, preview: LinkPreview) => ({
+    params: { slug: href.slice(buildBase.length).replace(/\/$/, '') },
+    props: { preview },
+  })
   const paths = !buildPort ? [route(API_GLOSSARY_PATH, glossaryPreview(API_GLOSSARY_PATH))] : []
   for (const [port, model] of Object.entries(API_MODELS)) {
     if (buildPort && port !== buildPort) continue
-    const version = buildPort ? buildVersion : defaults[port] ?? 'latest'
+    const version = buildPort ? buildVersion : (defaults[port] ?? 'latest')
     const info = PORT_BY_SLUG[port]
     for (const symbol of model.symbols) {
       if (!buildPort && (!symbol.product || symbol.product === 'core' || symbol.apiScope === 'internal')) continue
@@ -40,6 +47,7 @@ export function getStaticPaths() {
   }
   return paths
 }
-export const GET: APIRoute = ({ props }) => new Response(JSON.stringify(props.preview), {
-  headers: { 'Content-Type': 'application/json; charset=utf-8' },
-})
+export const GET: APIRoute = ({ props }) =>
+  new Response(JSON.stringify(props.preview), {
+    headers: { 'Content-Type': 'application/json; charset=utf-8' },
+  })
diff --git a/site/src/pages/docs.json.ts b/site/src/pages/docs.json.ts
index 4fabe8a58..2aec99be3 100644
--- a/site/src/pages/docs.json.ts
+++ b/site/src/pages/docs.json.ts
@@ -4,7 +4,18 @@ import { getCollection, render } from 'astro:content'
 import { DEFAULT_LOCALE, localeRoot } from '../i18n/locales.ts'
 import { buildLocale, localeOf } from '../i18n/resolve.ts'
 import { API_MODELS, PORT_NAME, pageSlug } from '../lib/api-models.ts'
-import { DOC_PRODUCTS, hasReference, PORTS, PORT_BY_SLUG, portPageUrl, productApiPath, productAvailable, productInDevelopment, referenceUrl, type DocProduct } from '../lib/ports.ts'
+import {
+  DOC_PRODUCTS,
+  hasReference,
+  PORTS,
+  PORT_BY_SLUG,
+  portPageUrl,
+  productApiPath,
+  productAvailable,
+  productInDevelopment,
+  referenceUrl,
+  type DocProduct,
+} from '../lib/ports.ts'
 import { PORT_ROOT } from '../lib/site-root.ts'
 import { docsRoutePath } from '../lib/docs-paths.ts'
 import { docsEntriesAvailable } from '../lib/page-port-links.ts'
@@ -15,7 +26,13 @@ import { buildTarget } from '../lib/versions.ts'
 import { tmuxReferenceContext, tmuxReferenceUrl } from '../lib/tmux-reference'
 import { buildsTmuxDocumentation, TMUX_VERSIONS } from '../lib/tmux-manual-data'
 import { referenceIndexSections, referenceIndexSectionsFor } from '../lib/api-tree.ts'
-import { tmuxManualDescription, tmuxManualHeadings, tmuxManualTitle, tmuxManualRoutes, tmuxManualUrl } from '../lib/tmux-manual-data.ts'
+import {
+  tmuxManualDescription,
+  tmuxManualHeadings,
+  tmuxManualTitle,
+  tmuxManualRoutes,
+  tmuxManualUrl,
+} from '../lib/tmux-manual-data.ts'
 
 /**
  * `/docs.json` — the agent manifest.
@@ -47,18 +64,25 @@ export const GET: APIRoute = async ({ site }) => {
   const visiblePorts = PORTS.filter((entry) => !port || entry.slug === port)
   const locale = buildLocale()
   const defaults: Record<string, string> = JSON.parse(process.env.LIBTMUX_DOCS_PORT_DEFAULTS || '{}')
-  const versionFor = (slug: string) => slug === port ? buildTarget(process.env).version : (defaults[slug] ?? 'latest')
+  const versionFor = (slug: string) => (slug === port ? buildTarget(process.env).version : (defaults[slug] ?? 'latest'))
 
-  const entries = docsEntriesAvailable(await getCollection(
-    'docs',
-    (entry) => localeOf(entry.id) === DEFAULT_LOCALE
-      && (locale === DEFAULT_LOCALE || Boolean(port) || !entry.data.port),
-  ), port)
+  const entries = docsEntriesAvailable(
+    await getCollection(
+      'docs',
+      (entry) =>
+        localeOf(entry.id) === DEFAULT_LOCALE && (locale === DEFAULT_LOCALE || Boolean(port) || !entry.data.port),
+    ),
+    port,
+  )
   // What this build serves at each route: a translation where it has one, and
   // the default locale's page where a placeholder stands in for it.
-  const translations = new Map(locale === DEFAULT_LOCALE ? []
-    : localeProse(await getCollection('docs'), locale, port, defaults)
-      .map(({ entry, route }) => [route, entry] as const))
+  const translations = new Map(
+    locale === DEFAULT_LOCALE
+      ? []
+      : localeProse(await getCollection('docs'), locale, port, defaults).map(
+          ({ entry, route }) => [route, entry] as const,
+        ),
+  )
 
   const pages = []
   for (const entry of entries) {
@@ -111,33 +135,54 @@ export const GET: APIRoute = async ({ site }) => {
 
   for (const { version, slug } of tmuxManualRoutes()) {
     const url = `${origin}${tmuxManualUrl(version, slug)}`
-    pages.push({ title: tmuxManualTitle(version, slug), description: tmuxManualDescription(version, slug),
-      section: 'tmux manual', url, markdownUrl: markdownPath(url, !slug),
-      headings: tmuxManualHeadings(version, slug).map((heading) => ({ id: heading.slug, level: heading.depth, text: heading.text })) })
-  }
-
-  if (buildsTmuxDocumentation()) for (const version of TMUX_VERSIONS) {
-    const context = tmuxReferenceContext(version)
-    const url = `${origin}${tmuxReferenceUrl(version)}`
-    const sections = referenceIndexSectionsFor(context.model, context.tree)
-    pages.push({ title: context.title, description: context.description,
-      section: 'tmux C source reference', url, markdownUrl: `${url}index.md`, symbolIndexUrl: `${url}tree.json`,
-      headings: [
-        ...(context.paths.length ? [{ id: 'api-source-paths', level: 2, text: 'Paths through the source' }] : []),
-        ...sections.map((section) => ({ id: `section-${section.id}`, level: 2, text: section.name })),
-      ],
-      symbols: sections.flatMap((section) => [...section.types, ...section.free]).map((symbol) => ({
-        id: symbol.publicId ?? symbol.id, name: symbol.name, kind: symbol.kind,
-        qualifiedName: qualifiedNameOf(symbol), namespace: moduleOf(symbol),
-        url: `${origin}${tmuxReferenceUrl(version, symbol)}`,
+    pages.push({
+      title: tmuxManualTitle(version, slug),
+      description: tmuxManualDescription(version, slug),
+      section: 'tmux manual',
+      url,
+      markdownUrl: markdownPath(url, !slug),
+      headings: tmuxManualHeadings(version, slug).map((heading) => ({
+        id: heading.slug,
+        level: heading.depth,
+        text: heading.text,
       })),
     })
   }
 
+  if (buildsTmuxDocumentation())
+    for (const version of TMUX_VERSIONS) {
+      const context = tmuxReferenceContext(version)
+      const url = `${origin}${tmuxReferenceUrl(version)}`
+      const sections = referenceIndexSectionsFor(context.model, context.tree)
+      pages.push({
+        title: context.title,
+        description: context.description,
+        section: 'tmux C source reference',
+        url,
+        markdownUrl: `${url}index.md`,
+        symbolIndexUrl: `${url}tree.json`,
+        headings: [
+          ...(context.paths.length ? [{ id: 'api-source-paths', level: 2, text: 'Paths through the source' }] : []),
+          ...sections.map((section) => ({ id: `section-${section.id}`, level: 2, text: section.name })),
+        ],
+        symbols: sections
+          .flatMap((section) => [...section.types, ...section.free])
+          .map((symbol) => ({
+            id: symbol.publicId ?? symbol.id,
+            name: symbol.name,
+            kind: symbol.kind,
+            qualifiedName: qualifiedNameOf(symbol),
+            namespace: moduleOf(symbol),
+            url: `${origin}${tmuxReferenceUrl(version, symbol)}`,
+          })),
+      })
+    }
+
   const manifest = {
     name: port ? `libtmux for ${PORT_BY_SLUG[port].name}` : 'libtmux',
     url: `${origin}${base}`,
-    description: port ? `Guides, examples and API reference for ${PORT_BY_SLUG[port].packageName}.`
+    description: port
+      ? `Guides, examples and API reference for ${PORT_BY_SLUG[port].packageName}.`
       : `Typed tmux control libraries for ${PORTS.map((port) => port.name).join(', ')}, documented as one site.`,
     sourceRepository: `https://github.com/${port ? PORT_BY_SLUG[port].repo : 'tmux-python/libtmux'}`,
     agentEntrypoints: {
@@ -158,15 +203,24 @@ export const GET: APIRoute = async ({ site }) => {
       reference: hasReference(p) ? referenceUrl(p, versionFor(p.slug)) : null,
       ...(p.parentLibrary ? { parentLibrary: p.parentLibrary } : {}),
       products: Object.entries(p.parentLibrary ? {} : DOC_PRODUCTS).map(([slug, product]) => ({
-        slug, name: product.label,
+        slug,
+        name: product.label,
         availability: productAvailable(p, slug as DocProduct) ? 'available' : 'unpublished',
         inDevelopment: productInDevelopment(p, slug as DocProduct),
-        ...(slug === 'workspace' ? { cli: p.workspaceCli ?? null, cliAvailability: p.workspaceCliAvailability ?? null } : {}),
+        ...(slug === 'workspace'
+          ? { cli: p.workspaceCli ?? null, cliAvailability: p.workspaceCliAvailability ?? null }
+          : {}),
         url: portPageUrl(p, versionFor(p.slug), slug),
         reference: productAvailable(p, slug as DocProduct)
-          ? portPageUrl(p, versionFor(p.slug), productApiPath(slug as DocProduct)) : null,
-        ...(slug === 'mcp' ? { protocol: productAvailable(p, 'mcp')
-          ? portPageUrl(p, versionFor(p.slug), 'mcp/tools').replace(/\/$/, '.json') : null } : {}),
+          ? portPageUrl(p, versionFor(p.slug), productApiPath(slug as DocProduct))
+          : null,
+        ...(slug === 'mcp'
+          ? {
+              protocol: productAvailable(p, 'mcp')
+                ? portPageUrl(p, versionFor(p.slug), 'mcp/tools').replace(/\/$/, '.json')
+                : null,
+            }
+          : {}),
         source: API_MODELS[p.slug]?.sources?.find((source) => source.product === slug),
       })),
       extracted: API_MODELS[p.slug]
@@ -182,9 +236,11 @@ export const GET: APIRoute = async ({ site }) => {
         kind: area.kind,
         availability: area.kind === 'unavailable' ? 'unpublished' : 'available',
         url: portPageUrl(p, versionFor(p.slug), area.route),
-        ...(area.kind === 'companion-package' ? {
-          package: p.packages?.find((entry) => entry.id === area.package)?.name,
-        } : {}),
+        ...(area.kind === 'companion-package'
+          ? {
+              package: p.packages?.find((entry) => entry.id === area.package)?.name,
+            }
+          : {}),
       })),
     })),
     pages,
diff --git a/site/src/pages/llms.txt.ts b/site/src/pages/llms.txt.ts
index fe9eec82e..3b6d27718 100644
--- a/site/src/pages/llms.txt.ts
+++ b/site/src/pages/llms.txt.ts
@@ -51,9 +51,7 @@ export const GET: APIRoute = async ({ site }) => {
   }
 
   out.push('## Optional', '')
-  out.push(
-    `- [Full documentation text](${origin}${base}llms-full.txt): guides and MCP contracts in a single fetch.`,
-  )
+  out.push(`- [Full documentation text](${origin}${base}llms-full.txt): guides and MCP contracts in a single fetch.`)
   out.push('')
 
   return new Response(out.join('\n'), {
diff --git a/site/src/pages/prompts.json.ts b/site/src/pages/prompts.json.ts
index 44b6a1b18..322ea450b 100644
--- a/site/src/pages/prompts.json.ts
+++ b/site/src/pages/prompts.json.ts
@@ -55,7 +55,7 @@ export const GET: APIRoute = ({ site }) => {
         status: entry.status,
         version: entry.version,
         tag: entry.tag,
-        registry: (port.registry?.name ?? 'its repository'),
+        registry: port.registry?.name ?? 'its repository',
       },
     }
   })
@@ -64,8 +64,7 @@ export const GET: APIRoute = ({ site }) => {
     schema: 1,
     name: 'libtmux agent prompts',
     url: `${base}/prompts/`,
-    description:
-      'Prompts that set up libtmux in a repository and build something with it, one per language and task.',
+    description: 'Prompts that set up libtmux in a repository and build something with it, one per language and task.',
     sourceRepository: 'https://github.com/libtmux/docs',
     topics: TOPICS.map((topic) => ({
       id: topic.id,
diff --git a/site/src/pages/reference/[...slug].md.ts b/site/src/pages/reference/[...slug].md.ts
index 4afef296e..1dae1d9a8 100644
--- a/site/src/pages/reference/[...slug].md.ts
+++ b/site/src/pages/reference/[...slug].md.ts
@@ -27,10 +27,9 @@ export async function getStaticPaths() {
   if (buildLocale() !== DEFAULT_LOCALE) return []
   const model = API_MODELS[port]
   if (!model) return []
-  const productIds = new Set([
-    ...symbolsForProduct(model, 'mcp'),
-    ...symbolsForProduct(model, 'workspace'),
-  ].map((symbol) => symbol.id))
+  const productIds = new Set(
+    [...symbolsForProduct(model, 'mcp'), ...symbolsForProduct(model, 'workspace')].map((symbol) => symbol.id),
+  )
   const paths: { params: { slug: string }; props: { port: string; id: string } }[] = []
   for (const symbol of model.symbols) {
     if (productIds.has(symbol.id)) continue
diff --git a/site/src/pages/reference/glossary.json.ts b/site/src/pages/reference/glossary.json.ts
index 3d206e18e..7fd0a53b3 100644
--- a/site/src/pages/reference/glossary.json.ts
+++ b/site/src/pages/reference/glossary.json.ts
@@ -1,16 +1,25 @@
 import type { APIRoute } from 'astro'
-import { API_GLOSSARY_DESCRIPTION, ALL_GLOSSARY_GROUPS, API_GLOSSARY_PATH, API_GLOSSARY_TITLE, apiGlossaryHref } from '../../lib/api-glossary'
+import {
+  API_GLOSSARY_DESCRIPTION,
+  ALL_GLOSSARY_GROUPS,
+  API_GLOSSARY_PATH,
+  API_GLOSSARY_TITLE,
+  apiGlossaryHref,
+} from '../../lib/api-glossary'
 
 export const GET: APIRoute = ({ site }) => {
   const origin = site?.origin ?? 'https://libtmux.org'
-  return new Response(JSON.stringify({
-    schema: 1,
-    title: API_GLOSSARY_TITLE,
-    description: API_GLOSSARY_DESCRIPTION,
-    url: new URL(API_GLOSSARY_PATH, origin).href,
-    groups: ALL_GLOSSARY_GROUPS.map((group) => ({
-      ...group,
-      terms: group.terms.map((term) => ({ ...term, url: new URL(apiGlossaryHref(term.id)!, origin).href })),
-    })),
-  }), { headers: { 'Content-Type': 'application/json; charset=utf-8' } })
+  return new Response(
+    JSON.stringify({
+      schema: 1,
+      title: API_GLOSSARY_TITLE,
+      description: API_GLOSSARY_DESCRIPTION,
+      url: new URL(API_GLOSSARY_PATH, origin).href,
+      groups: ALL_GLOSSARY_GROUPS.map((group) => ({
+        ...group,
+        terms: group.terms.map((term) => ({ ...term, url: new URL(apiGlossaryHref(term.id)!, origin).href })),
+      })),
+    }),
+    { headers: { 'Content-Type': 'application/json; charset=utf-8' } },
+  )
 }
diff --git a/site/src/pages/reference/glossary.md.ts b/site/src/pages/reference/glossary.md.ts
index c1eafffb2..fc929e5f5 100644
--- a/site/src/pages/reference/glossary.md.ts
+++ b/site/src/pages/reference/glossary.md.ts
@@ -1,6 +1,7 @@
 import type { APIRoute } from 'astro'
 import { apiGlossaryMarkdown } from '../../lib/api-glossary'
 
-export const GET: APIRoute = ({ site }) => new Response(apiGlossaryMarkdown(site?.origin ?? 'https://libtmux.org'), {
-  headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
-})
+export const GET: APIRoute = ({ site }) =>
+  new Response(apiGlossaryMarkdown(site?.origin ?? 'https://libtmux.org'), {
+    headers: { 'Content-Type': 'text/markdown; charset=utf-8' },
+  })
diff --git a/site/src/pages/reference/sources/[...path].ts b/site/src/pages/reference/sources/[...path].ts
index 6836e2807..303e0026d 100644
--- a/site/src/pages/reference/sources/[...path].ts
+++ b/site/src/pages/reference/sources/[...path].ts
@@ -8,10 +8,12 @@ export function getStaticPaths() {
   const model = API_MODELS[process.env.LIBTMUX_DOCS_PORT ?? '']
   if (buildLocale() !== DEFAULT_LOCALE || !model) return []
   return Object.entries(model.generatedSources ?? {}).map(([path, source]) => ({
-    params: { path }, props: { source },
+    params: { path },
+    props: { source },
   }))
 }
 
-export const GET: APIRoute = ({ props }) => new Response(props.source as string, {
-  headers: { 'Content-Type': 'text/plain; charset=utf-8' },
-})
+export const GET: APIRoute = ({ props }) =>
+  new Response(props.source as string, {
+    headers: { 'Content-Type': 'text/plain; charset=utf-8' },
+  })
diff --git a/site/src/pages/tmux/[version]/reference/[...slug].md.ts b/site/src/pages/tmux/[version]/reference/[...slug].md.ts
index 1ae0c0c2b..40c89cbdc 100644
--- a/site/src/pages/tmux/[version]/reference/[...slug].md.ts
+++ b/site/src/pages/tmux/[version]/reference/[...slug].md.ts
@@ -1,22 +1,38 @@
 import type { APIRoute } from 'astro'
 import { sourceUrl } from '@libtmux/api-model'
 import { symbolMarkdown } from '../../../../lib/symbol-markdown'
-import { tmuxReferenceIndex, tmuxReferencePaths, tmuxReferenceRoutes, tmuxReferenceUrl, tmuxSourceCommands, tmuxSourceModel } from '../../../../lib/tmux-reference'
+import {
+  tmuxReferenceIndex,
+  tmuxReferencePaths,
+  tmuxReferenceRoutes,
+  tmuxReferenceUrl,
+  tmuxSourceCommands,
+  tmuxSourceModel,
+} from '../../../../lib/tmux-reference'
 
 export function getStaticPaths() {
-  return tmuxReferenceRoutes().filter(({ symbol }) => symbol).map(({ version, symbol }) => ({
-    params: { version, slug: symbol!.slug }, props: { version, symbol: symbol! },
-  }))
+  return tmuxReferenceRoutes()
+    .filter(({ symbol }) => symbol)
+    .map(({ version, symbol }) => ({
+      params: { version, slug: symbol!.slug },
+      props: { version, symbol: symbol! },
+    }))
 }
 export const GET: APIRoute = ({ props, site }) => {
   const { version, symbol } = props
   const model = tmuxSourceModel(version)
-  return new Response(symbolMarkdown({
-    model, symbol, version, index: tmuxReferenceIndex(version),
-    canonical: new URL(tmuxReferenceUrl(version, symbol), site).href,
-    source: sourceUrl(model, symbol),
-    hrefFor: (entry) => tmuxReferenceUrl(version, entry),
-    manualLinks: tmuxSourceCommands(version, symbol),
-    paths: tmuxReferencePaths(version),
-  }), { headers: { 'Content-Type': 'text/markdown; charset=utf-8' } })
+  return new Response(
+    symbolMarkdown({
+      model,
+      symbol,
+      version,
+      index: tmuxReferenceIndex(version),
+      canonical: new URL(tmuxReferenceUrl(version, symbol), site).href,
+      source: sourceUrl(model, symbol),
+      hrefFor: (entry) => tmuxReferenceUrl(version, entry),
+      manualLinks: tmuxSourceCommands(version, symbol),
+      paths: tmuxReferencePaths(version),
+    }),
+    { headers: { 'Content-Type': 'text/markdown; charset=utf-8' } },
+  )
 }
diff --git a/site/src/pages/tmux/[version]/reference/tree.json.ts b/site/src/pages/tmux/[version]/reference/tree.json.ts
index 2e904558f..656cccbb5 100644
--- a/site/src/pages/tmux/[version]/reference/tree.json.ts
+++ b/site/src/pages/tmux/[version]/reference/tree.json.ts
@@ -5,6 +5,7 @@ import { tmuxReferenceTree } from '../../../../lib/tmux-reference'
 export function getStaticPaths() {
   return buildsTmuxDocumentation() ? TMUX_VERSIONS.map((version) => ({ params: { version } })) : []
 }
-export const GET: APIRoute = ({ params }) => new Response(JSON.stringify(tmuxReferenceTree(params.version)), {
-  headers: { 'Content-Type': 'application/json; charset=utf-8' },
-})
+export const GET: APIRoute = ({ params }) =>
+  new Response(JSON.stringify(tmuxReferenceTree(params.version)), {
+    headers: { 'Content-Type': 'application/json; charset=utf-8' },
+  })
diff --git a/site/src/plugins/ec-copy-readiness.mjs b/site/src/plugins/ec-copy-readiness.mjs
index 6f558271e..fc9f0f7e1 100644
--- a/site/src/plugins/ec-copy-readiness.mjs
+++ b/site/src/plugins/ec-copy-readiness.mjs
@@ -9,7 +9,8 @@ export function copyReadiness() {
     baseStyles: '.copy button:disabled { cursor: progress; } .copy button { transition: none; }',
     // Custom modules follow the built-in frame module in the same bundle.
     // Its observer also attaches handlers before this observer enables buttons.
-    jsModules: [`(() => {
+    jsModules: [
+      `(() => {
       function enable(root) {
         root.querySelectorAll?.('.expressive-code .copy button[data-copy-pending]').forEach(button => {
           button.disabled = false;
@@ -21,7 +22,8 @@ export function copyReadiness() {
         records.forEach(record => record.addedNodes.forEach(enable));
       }).observe(document.body, { childList: true, subtree: true });
       document.addEventListener('astro:page-load', () => enable(document));
-    })();`],
+    })();`,
+    ],
     hooks: {
       postprocessRenderedBlock: ({ renderData }) => {
         const button = select('.copy button[data-code]', renderData.blockAst)
diff --git a/site/src/plugins/ec-shell-prompt.mjs b/site/src/plugins/ec-shell-prompt.mjs
index 3f856e38b..6e45ecd7c 100644
--- a/site/src/plugins/ec-shell-prompt.mjs
+++ b/site/src/plugins/ec-shell-prompt.mjs
@@ -56,9 +56,7 @@ function commandContinuation(text, quote, inWord) {
       syntax += character
     }
   }
-  const continuation = quote ? 'quote'
-    : escaped ? 'backslash'
-      : /(?:&&|\|\||\|)\s*$/.test(syntax) ? 'operator' : ''
+  const continuation = quote ? 'quote' : escaped ? 'backslash' : /(?:&&|\|\||\|)\s*$/.test(syntax) ? 'operator' : ''
   // Backslash-newline joins the next line without creating a word boundary.
   const joinedWord = escaped && /[^\s;&|()]$/.test(syntax.slice(0, -1))
   return { quote, continuation, inWord: joinedWord }
@@ -89,9 +87,8 @@ export function sessionLines(lines) {
     const text = kind === 'prompt' ? line.slice(PROMPT.length) : line
     const awaitingOperand = continuation === 'operator' && /^\s*(?:#.*)?$/.test(text)
     if (!awaitingOperand) {
-      ({ quote, continuation, inWord } = kind !== 'output'
-        ? commandContinuation(text, quote, inWord)
-        : { quote: '', continuation: '', inWord: false })
+      ;({ quote, continuation, inWord } =
+        kind !== 'output' ? commandContinuation(text, quote, inWord) : { quote: '', continuation: '', inWord: false })
     }
     return { kind, text }
   })
diff --git a/site/src/plugins/rehype-api-links.ts b/site/src/plugins/rehype-api-links.ts
index 3e7cedff2..2d9df6748 100644
--- a/site/src/plugins/rehype-api-links.ts
+++ b/site/src/plugins/rehype-api-links.ts
@@ -91,39 +91,70 @@ const BLOCKS = new Set(['p', 'li', 'td', 'th', 'dd', 'dt', 'figcaption', 'blockq
 
 type El = { type?: string; tagName?: string; value?: string; properties?: Record<string, unknown>; children?: El[] }
 
-const symbolsByPage = new Map(Object.entries(API_MODELS).flatMap(([port, model]) => model.symbols.map(symbol => [
-  `${port}/${symbol.product && symbol.product !== 'core' ? `${symbol.product}/` : ''}${symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id)}`,
-  symbol,
-] as const)))
-const protocolByPage = new Map(Object.keys(MCP_REFERENCE).flatMap(port => mcpObjects(port).map(object => [
-  `${port}/${object.path}`, object,
-] as const)))
+const symbolsByPage = new Map(
+  Object.entries(API_MODELS).flatMap(([port, model]) =>
+    model.symbols.map(
+      (symbol) =>
+        [
+          `${port}/${symbol.product && symbol.product !== 'core' ? `${symbol.product}/` : ''}${symbol.slug ?? pageSlug(symbol.publicId ?? symbol.id)}`,
+          symbol,
+        ] as const,
+    ),
+  ),
+)
+const protocolByPage = new Map(
+  Object.keys(MCP_REFERENCE).flatMap((port) =>
+    mcpObjects(port).map((object) => [`${port}/${object.path}`, object] as const),
+  ),
+)
 
 /** Only mark links whose actual destination names a known declaration. */
 function addKindBadge(anchor: El, port?: string, route?: string): void {
   const href = anchor.properties?.href
-  if (typeof href !== 'string' || href.startsWith('#') || !anchor.children?.length || anchor.children.some(child => child.properties?.dataApiKind)) return
+  if (
+    typeof href !== 'string' ||
+    href.startsWith('#') ||
+    !anchor.children?.length ||
+    anchor.children.some((child) => child.properties?.dataApiKind)
+  )
+    return
   // Relative links require the real page route, including product nesting.
   if (route === undefined && !/^(?:\/|[a-z][a-z0-9+.-]*:)/i.test(href)) return
   let url: URL
-  try { url = new URL(href, `https://libtmux.org/${port ?? '_'}/latest/${(route ?? '').replace(/\/$/, '')}/`) } catch { return }
+  try {
+    url = new URL(href, `https://libtmux.org/${port ?? '_'}/latest/${(route ?? '').replace(/\/$/, '')}/`)
+  } catch {
+    return
+  }
   if (url.origin !== 'https://libtmux.org') return
   let fragment: string
-  try { fragment = decodeURIComponent(url.hash.slice(1)) } catch { return }
+  try {
+    fragment = decodeURIComponent(url.hash.slice(1))
+  } catch {
+    return
+  }
   const match = /\/([^/]+)\/[^/]+\/(?:(mcp|workspace)\/)?reference\/([^/]+)\/?$/.exec(url.pathname)
   const protocol = /\/([^/]+)\/[^/]+\/(mcp\/(?:tools|prompts|resources)\/.+?)\/?$/.exec(url.pathname)
   let kind: string | undefined
   let title: string | undefined
   if (match && PORT_BY_SLUG[match[1]!]) {
     let slug: string
-    try { slug = decodeURIComponent(match[3]!) } catch { return }
+    try {
+      slug = decodeURIComponent(match[3]!)
+    } catch {
+      return
+    }
     const symbol = symbolsByPage.get(`${match[1]}/${match[2] ? `${match[2]}/` : ''}${slug}`)
     if (!symbol || (fragment && fragment !== (symbol.publicId ?? symbol.id))) return
     kind = symbol.kind
     title = symbol.command?.kind ?? kind
   } else if (protocol && PORT_BY_SLUG[protocol[1]!]) {
     let path: string
-    try { path = decodeURIComponent(protocol[2]!) } catch { return }
+    try {
+      path = decodeURIComponent(protocol[2]!)
+    } catch {
+      return
+    }
     const object = protocolByPage.get(`${protocol[1]}/${path}`)
     if (!object || (fragment && fragment !== object.id)) return
     kind = object.kind
@@ -132,10 +163,24 @@ function addKindBadge(anchor: El, port?: string, route?: string): void {
   if (!kind) return
   const mark = kindMark(kind)
   if (!mark) return
-  anchor.children.unshift({ type: 'element', tagName: 'span', properties: {
-    className: ['api-link-kind', 'api-nav__kind', `api-badge--kind-${kind}`],
-    dataApiKind: kind, ariaHidden: 'true', title,
-  }, children: [{ type: 'element', tagName: 'span', properties: { className: ['api-badge__label'] }, children: [{ type: 'text', value: mark }] }] })
+  anchor.children.unshift({
+    type: 'element',
+    tagName: 'span',
+    properties: {
+      className: ['api-link-kind', 'api-nav__kind', `api-badge--kind-${kind}`],
+      dataApiKind: kind,
+      ariaHidden: 'true',
+      title,
+    },
+    children: [
+      {
+        type: 'element',
+        tagName: 'span',
+        properties: { className: ['api-badge__label'] },
+        children: [{ type: 'text', value: mark }],
+      },
+    ],
+  })
 }
 
 /**
@@ -153,12 +198,21 @@ function addKindBadge(anchor: El, port?: string, route?: string): void {
  * language of the fence above, then the port this build is for.
  */
 export function rehypeApiLinks() {
-  return (tree: unknown, file?: { path?: string; data?: { astro?: { frontmatter?: { port?: string; product?: ApiProduct; route?: string } } } }) => {
+  return (
+    tree: unknown,
+    file?: {
+      path?: string
+      data?: { astro?: { frontmatter?: { port?: string; product?: ApiProduct; route?: string } } }
+    },
+  ) => {
     const frontmatter = file?.data?.astro?.frontmatter
     const buildPort = frontmatter?.port ?? (process.env.LIBTMUX_DOCS_PORT || undefined)
     const source = file?.path?.replaceAll('\\', '/').match(/\/content\/(docs|_workspace-shared)\/(.+)\.mdx?$/)
-    const id = source ? `${source[1] === '_workspace-shared' ? `ports/${buildPort}/` : ''}${source[2]}`.replace(/(?:^|\/)index$/, '') : undefined
-    const route = frontmatter?.route ?? (id !== undefined ? docsPath({ id, data: { ...frontmatter, port: buildPort } }) : undefined)
+    const id = source
+      ? `${source[1] === '_workspace-shared' ? `ports/${buildPort}/` : ''}${source[2]}`.replace(/(?:^|\/)index$/, '')
+      : undefined
+    const route =
+      frontmatter?.route ?? (id !== undefined ? docsPath({ id, data: { ...frontmatter, port: buildPort } }) : undefined)
     // Native wrapper references own their symbols. Resolving the same short
     // name against another language's model would create a misleading link.
     const resolveMentions = !buildPort || PORT_BY_SLUG[buildPort]?.referenceKind !== 'guide'
@@ -166,7 +220,13 @@ export function rehypeApiLinks() {
     const link = createProseLinker(file?.data?.astro?.frontmatter?.product)
     const sections: { depth: number; port?: string }[] = []
 
-    const walk = (node: El, inLink: boolean, rowPort: string | undefined, fence: { lang?: string }, before: { text: string }) => {
+    const walk = (
+      node: El,
+      inLink: boolean,
+      rowPort: string | undefined,
+      fence: { lang?: string },
+      before: { text: string },
+    ) => {
       const kids = node.children
       if (!Array.isArray(kids)) return
 
@@ -209,7 +269,8 @@ export function rehypeApiLinks() {
             const pagePort = buildPort ?? rowPort ?? fence.lang ?? sections.at(-1)?.port
             const decision = link(href, { pagePort, before: scope.text })
             if (decision.kind === 'link') child.properties!.href = decision.href
-            else if (decision.kind === 'unresolved') record({ port: pagePort ?? 'shared', text: href, why: decision.why })
+            else if (decision.kind === 'unresolved')
+              record({ port: pagePort ?? 'shared', text: href, why: decision.why })
           }
           walk(child, true, rowPort, fence, scope)
           scope.text += textOf(child)
@@ -219,12 +280,18 @@ export function rehypeApiLinks() {
         if (child.tagName === 'code' && !inLink && resolveMentions) {
           const text = textOf(child).trim()
           const explicitPort = child.properties?.dataDocPort
-          const pagePort = (typeof explicitPort === 'string' ? explicitPort : undefined)
-            ?? buildPort ?? rowPort ?? fence.lang ?? sections.at(-1)?.port
+          const pagePort =
+            (typeof explicitPort === 'string' ? explicitPort : undefined) ??
+            buildPort ??
+            rowPort ??
+            fence.lang ??
+            sections.at(-1)?.port
           const decision = link(text, { pagePort, before: scope.text })
           if (decision.kind === 'link') {
             kids[i] = {
-              type: 'element', tagName: 'a', children: [child],
+              type: 'element',
+              tagName: 'a',
+              children: [child],
               properties: {
                 href: decision.href,
                 class: decision.file ? 'api-mention api-mention--file' : 'api-mention',
@@ -233,8 +300,11 @@ export function rehypeApiLinks() {
               },
             }
             addKindBadge(kids[i]!, buildPort, route)
-          } else if (decision.kind === 'unresolved' && !decision.file &&
-            (text.startsWith('mcp:') || (pagePort && isLikelyReference(text) && !notApiReason(text)))) {
+          } else if (
+            decision.kind === 'unresolved' &&
+            !decision.file &&
+            (text.startsWith('mcp:') || (pagePort && isLikelyReference(text) && !notApiReason(text)))
+          ) {
             record({ port: pagePort ?? 'shared', text, why: decision.why })
           }
           scope.text += text
@@ -250,10 +320,25 @@ export function rehypeApiLinks() {
 }
 
 const LANG_TO_PORT: Record<string, string> = {
-  python: 'py', py: 'py', typescript: 'ts', ts: 'ts', javascript: 'ts', js: 'ts',
-  rust: 'rs', rs: 'rs', go: 'go', java: 'java', csharp: 'csharp', cs: 'csharp',
-  cpp: 'cxx', 'c++': 'cxx', swift: 'swift',
-  powershell: 'powershell', pwsh: 'powershell', ps1: 'powershell', julia: 'julia',
+  python: 'py',
+  py: 'py',
+  typescript: 'ts',
+  ts: 'ts',
+  javascript: 'ts',
+  js: 'ts',
+  rust: 'rs',
+  rs: 'rs',
+  go: 'go',
+  java: 'java',
+  csharp: 'csharp',
+  cs: 'csharp',
+  cpp: 'cxx',
+  'c++': 'cxx',
+  swift: 'swift',
+  powershell: 'powershell',
+  pwsh: 'powershell',
+  ps1: 'powershell',
+  julia: 'julia',
 }
 
 function textOf(node: unknown): string {
diff --git a/site/src/plugins/rehype-code-tabs.mjs b/site/src/plugins/rehype-code-tabs.mjs
index 068775b7a..d0af8385b 100644
--- a/site/src/plugins/rehype-code-tabs.mjs
+++ b/site/src/plugins/rehype-code-tabs.mjs
@@ -151,8 +151,7 @@ export function rehypeCodeTabs() {
         // A heading always breaks the run: it opens a new section, and a tab
         // group spanning one would take the heading out of the page's table
         // of contents.
-        const isHeading =
-          child.type === 'element' && /^h[1-6]$/.test(String(child.tagName))
+        const isHeading = child.type === 'element' && /^h[1-6]$/.test(String(child.tagName))
 
         // A paragraph while a run is open is a caption for whatever comes
         // next — held, not flushed. If the next thing is not a fence, it is
diff --git a/site/src/plugins/rehype-row-anchors.ts b/site/src/plugins/rehype-row-anchors.ts
index d8c390fed..790e31415 100644
--- a/site/src/plugins/rehype-row-anchors.ts
+++ b/site/src/plugins/rehype-row-anchors.ts
@@ -23,8 +23,9 @@ export function rehypeRowAnchors() {
         const depth = Number(node.tagName[1])
         sections.length = depth
         sections[depth - 1] = String(node.properties.id ?? textOf(node))
-        section = sections.filter(Boolean).reduce((path, id) =>
-          !path || id.startsWith(`${path}-`) ? id : `${path}-${id}`, '')
+        section = sections
+          .filter(Boolean)
+          .reduce((path, id) => (!path || id.startsWith(`${path}-`) ? id : `${path}-${id}`), '')
         sectionName = textOf(node)
       }
       if (node.tagName !== 'tr' || (parent as Element)?.tagName === 'thead') return
@@ -41,13 +42,23 @@ export function rehypeRowAnchors() {
       }
       used.add(id)
       node.properties.id = id
-      node.properties.className = [...(Array.isArray(node.properties.className) ? node.properties.className : []), 'anchored-entry']
-      cell.properties.className = [...(Array.isArray(cell.properties.className) ? cell.properties.className : []), 'row-anchor-cell']
+      node.properties.className = [
+        ...(Array.isArray(node.properties.className) ? node.properties.className : []),
+        'anchored-entry',
+      ]
+      cell.properties.className = [
+        ...(Array.isArray(cell.properties.className) ? cell.properties.className : []),
+        'row-anchor-cell',
+      ]
       cell.children.push({
-        type: 'element', tagName: 'a',
+        type: 'element',
+        tagName: 'a',
         properties: {
-          href: `#${id}`, className: ['row-anchor-link'], dataRowPermalink: true,
-          dataPagefindIgnore: 'all', ariaLabel: `Link to ${label} in ${sectionName}`,
+          href: `#${id}`,
+          className: ['row-anchor-link'],
+          dataRowPermalink: true,
+          dataPagefindIgnore: 'all',
+          ariaLabel: `Link to ${label} in ${sectionName}`,
         },
         children: [{ type: 'text', value: '¶' }],
       })
diff --git a/site/src/plugins/rehype-site-root.mjs b/site/src/plugins/rehype-site-root.mjs
index 62bf327cc..b09190b19 100644
--- a/site/src/plugins/rehype-site-root.mjs
+++ b/site/src/plugins/rehype-site-root.mjs
@@ -30,7 +30,7 @@ export function rehypeSiteRoot() {
       // Only single-leading-slash paths: '//host' is protocol-relative.
       if (typeof value !== 'string' || !value.startsWith('/') || value.startsWith('//')) return
       const owner = typeof node.properties.dataDocPort === 'string' ? node.properties.dataDocPort : port
-      const version = owner === buildPort ? buildTarget(process.env).version : (defaults[owner] || 'latest')
+      const version = owner === buildPort ? buildTarget(process.env).version : defaults[owner] || 'latest'
       node.properties[attr] = attr === 'href' ? proseHref(value, root, owner, version, portRoot) : `${root}${value}`
     })
   }
diff --git a/site/src/plugins/remark-port-code.mjs b/site/src/plugins/remark-port-code.mjs
index b336de22b..43b3729e4 100644
--- a/site/src/plugins/remark-port-code.mjs
+++ b/site/src/plugins/remark-port-code.mjs
@@ -94,8 +94,13 @@ export function resolvePortCode(body, port, authoredPort, link = (href) => href)
       if (dropping) continue
       out.push(line)
       if (fence.replaced) out.push(readFence(owner, meta, 'Markdown export'))
-    } else if (fence && marker && marker[1][0] === fence.marker
-      && marker[1].length >= fence.length && !marker[2].trim()) {
+    } else if (
+      fence &&
+      marker &&
+      marker[1][0] === fence.marker &&
+      marker[1].length >= fence.length &&
+      !marker[2].trim()
+    ) {
       if (!fence.dropping) out.push(line)
       fence = undefined
     } else if (!fence?.dropping && !fence?.replaced) {
@@ -108,7 +113,9 @@ export function resolvePortCode(body, port, authoredPort, link = (href) => href)
 /** Rewrite authored destinations while preserving labels and literal inline code. */
 export function rewriteMarkdownLinks(text, link) {
   return text
-    .replace(/(`+).*?\1|(\]\()(<[^<>\n]*>|[^\s)]+)(?=[\s)])/g, (all, code, prefix, href) => code ? all : `${prefix}${destination(href)}`)
+    .replace(/(`+).*?\1|(\]\()(<[^<>\n]*>|[^\s)]+)(?=[\s)])/g, (all, code, prefix, href) =>
+      code ? all : `${prefix}${destination(href)}`,
+    )
     .replace(/^( {0,3}\[[^\]]+\]:\s*)(<[^<>\n]*>|\S+)/gm, (_all, prefix, href) => `${prefix}${destination(href)}`)
   function destination(href) {
     return href.startsWith('<') && href.endsWith('>') ? `<${link(href.slice(1, -1))}>` : link(href)
@@ -166,7 +173,6 @@ export function remarkPortCode() {
       if (meta.file && owner) {
         node.value = readFence(owner, meta, file?.path)
       }
-
     })
 
     for (const [parent, node] of removals) {
@@ -187,8 +193,11 @@ export function readFence(owner, meta, pagePath) {
   // Assembly refreshes the cache with git show at the documented revision.
   // Reading a nearby working tree here would silently replace those bytes.
   let source = cached?.content
-  if (process.env.LIBTMUX_DOCS_PORT === owner && process.env.LIBTMUX_DOCS_SOURCE_SHA
-      && cached?.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA) {
+  if (
+    process.env.LIBTMUX_DOCS_PORT === owner &&
+    process.env.LIBTMUX_DOCS_SOURCE_SHA &&
+    cached?.revision !== process.env.LIBTMUX_DOCS_SOURCE_SHA
+  ) {
     throw new Error(`${pagePath ?? 'page'}: ${owner}:${meta.file} does not match the selected source revision`)
   }
 
diff --git a/site/src/styles/global.css b/site/src/styles/global.css
index bbca3715f..acd1e3cfc 100644
--- a/site/src/styles/global.css
+++ b/site/src/styles/global.css
@@ -133,7 +133,6 @@
   ::view-transition-old(*),
   ::view-transition-new(*),
   ::view-transition-group(*) {
-    /* biome-ignore lint/complexity/noImportantStyles: layered author CSS can only beat Astro's unlayered view-transition styles with !important */
     animation: none !important;
   }
 }
@@ -373,6 +372,19 @@ html[data-theme-mode="dark"] {
   margin-block-start: 1.5rem;
 }
 
+/*
+ * Examples should fit 80 columns. Below the width where 80 fit at
+ * the default size, shrink the code font, to the homepage's floor, until 80
+ * fit beside the copy button's gutter: 4.0625rem is the line's inline
+ * padding and the frame's border.
+ */
+.prose .expressive-code {
+  container-type: inline-size;
+}
+.prose .expressive-code .frame {
+  --ec-codeFontSize: clamp(0.8125rem, calc((100cqi - 4.0625rem) / (80 * 0.6)), 0.875rem);
+}
+
 /* Preserve literal tabs while keeping compact indentation. */
 .expressive-code .code {
   tab-size: 2;
diff --git a/site/test/anchor-navigation.test.ts b/site/test/anchor-navigation.test.ts
index 3e04b94ef..d2d756ca6 100644
--- a/site/test/anchor-navigation.test.ts
+++ b/site/test/anchor-navigation.test.ts
@@ -3,7 +3,10 @@ import { Window } from 'happy-dom'
 import { installAnchorNavigation } from '../public/_shell/anchors.js'
 
 const disposals: (() => void)[] = []
-afterEach(() => { disposals.splice(0).forEach((dispose) => dispose()); vi.restoreAllMocks() })
+afterEach(() => {
+  disposals.splice(0).forEach((dispose) => dispose())
+  vi.restoreAllMocks()
+})
 
 function page(html: string, hash = '', fontsPending = false, hintsPending = false) {
   const win = new Window({ url: `https://libtmux.org/en/ts/latest/reference/${hash}` })
@@ -17,37 +20,54 @@ function page(html: string, hash = '', fontsPending = false, hintsPending = fals
     frames.set(++sequence, fn)
     return sequence as unknown as ReturnType<typeof win.requestAnimationFrame>
   })
-  vi.spyOn(win, 'cancelAnimationFrame').mockImplementation((id) => { frames.delete(Number(id)) })
+  vi.spyOn(win, 'cancelAnimationFrame').mockImplementation((id) => {
+    frames.delete(Number(id))
+  })
   vi.spyOn(win, 'setTimeout').mockImplementation((fn) => {
     timers.set(++sequence, fn as () => void)
     return sequence as unknown as ReturnType<typeof win.setTimeout>
   })
-  vi.spyOn(win, 'clearTimeout').mockImplementation((id) => { timers.delete(Number(id)) })
+  vi.spyOn(win, 'clearTimeout').mockImplementation((id) => {
+    timers.delete(Number(id))
+  })
   vi.spyOn(win.HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue(new win.DOMRect(0, 200, 100, 30))
   const scrolled: { id: string; collapsed: number }[] = []
   win.HTMLElement.prototype.scrollIntoView = function () {
     scrolled.push({ id: this.id, collapsed: win.document.querySelectorAll('details:not([open])').length })
   }
   const dispose = installAnchorNavigation(win as unknown as typeof window)
-  disposals.push(dispose, () => { void win.happyDOM.abort() })
-  const flush = () => { const pending = [...frames.values()]; frames.clear(); pending.forEach((fn) => fn(0)) }
-  const click = (id: string, options = {}) => win.document.getElementById(id)!.dispatchEvent(
-    new win.MouseEvent('click', { bubbles: true, cancelable: true, button: 0, ...options }),
-  )
+  disposals.push(dispose, () => {
+    void win.happyDOM.abort()
+  })
+  const flush = () => {
+    const pending = [...frames.values()]
+    frames.clear()
+    pending.forEach((fn) => fn(0))
+  }
+  const click = (id: string, options = {}) =>
+    win.document
+      .getElementById(id)!
+      .dispatchEvent(new win.MouseEvent('click', { bubbles: true, cancelable: true, button: 0, ...options }))
   flush()
   return { win, doc: win.document, flush, click, scrolled, timers, dispose }
 }
 
 describe('shared anchor arrival', () => {
   it('opens every containing disclosure before scrolling and highlights its summary', () => {
-    const p = page('<details><summary>Outer</summary><details id="server"><summary id="server-label">Server</summary>Members</details></details>', '#server')
+    const p = page(
+      '<details><summary>Outer</summary><details id="server"><summary id="server-label">Server</summary>Members</details></details>',
+      '#server',
+    )
     expect(p.doc.querySelectorAll('details[open]')).toHaveLength(2)
     expect(p.scrolled).toEqual([{ id: 'server-label', collapsed: 0 }])
     expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('server-label')
   })
 
   it('highlights headings, API objects, and table rows without replacing navigation or focus', () => {
-    const p = page('<input id="editor"><h2 id="overview">Overview</h2><dl><dt id="LibTmux.Server">Server</dt><dd>Behavior</dd></dl><table><tr id="options-json"><td>--json</td></tr></table>', '#overview')
+    const p = page(
+      '<input id="editor"><h2 id="overview">Overview</h2><dl><dt id="LibTmux.Server">Server</dt><dd>Behavior</dd></dl><table><tr id="options-json"><td>--json</td></tr></table>',
+      '#overview',
+    )
     p.doc.querySelector('input')!.focus()
     for (const id of ['LibTmux.Server', 'options-json']) {
       p.win.location.hash = encodeURIComponent(id)
@@ -73,7 +93,10 @@ describe('shared anchor arrival', () => {
   })
 
   it('paints a visible heading for an alias instead of its zero-size anchor', () => {
-    const p = page('<h2 id="capture-options"><span class="section-anchor-alias" id="options"></span>Options</h2>', '#options')
+    const p = page(
+      '<h2 id="capture-options"><span class="section-anchor-alias" id="options"></span>Options</h2>',
+      '#options',
+    )
     expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('capture-options')
   })
 
@@ -81,10 +104,14 @@ describe('shared anchor arrival', () => {
     const p = page('<a id="again" href="#overview">Overview</a><h2 id="overview">Overview</h2>', '#overview')
     for (const callback of [...p.timers.values()]) callback()
     // A router suppresses native navigation after updating history itself.
-    p.win.addEventListener('click', (event) => {
-      event.preventDefault()
-      p.win.history.replaceState(null, '', '#overview')
-    }, { capture: true })
+    p.win.addEventListener(
+      'click',
+      (event) => {
+        event.preventDefault()
+        p.win.history.replaceState(null, '', '#overview')
+      },
+      { capture: true },
+    )
     p.click('again')
     p.flush()
     expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('overview')
@@ -104,45 +131,61 @@ describe('shared anchor arrival', () => {
     expect(p.scrolled).toEqual([{ id: 'server', collapsed: 0 }])
   })
 
-  it.each(['fonts-pending', 'link-hints-pending'])('waits for both visibility gates when %s finishes first', async (first) => {
-    const p = page('<details><summary>API</summary><h2 id="server">Server</h2></details>', '#server', true, true)
-    expect(p.doc.querySelector('details')?.open).toBe(true)
-    expect(p.timers.size).toBe(0)
-    p.doc.documentElement.classList.remove(first)
-    await p.win.happyDOM.waitUntilComplete(); p.flush()
-    expect(p.doc.querySelector('[data-anchor-arrival]')).toBeNull()
-    expect(p.timers.size).toBe(0)
-    p.doc.documentElement.classList.remove('fonts-pending', 'link-hints-pending')
-    await p.win.happyDOM.waitUntilComplete(); p.flush()
-    expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('server')
-    expect(p.win.setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 2600)
-    expect(p.scrolled).toEqual([{ id: 'server', collapsed: 0 }])
-  })
+  it.each(['fonts-pending', 'link-hints-pending'])(
+    'waits for both visibility gates when %s finishes first',
+    async (first) => {
+      const p = page('<details><summary>API</summary><h2 id="server">Server</h2></details>', '#server', true, true)
+      expect(p.doc.querySelector('details')?.open).toBe(true)
+      expect(p.timers.size).toBe(0)
+      p.doc.documentElement.classList.remove(first)
+      await p.win.happyDOM.waitUntilComplete()
+      p.flush()
+      expect(p.doc.querySelector('[data-anchor-arrival]')).toBeNull()
+      expect(p.timers.size).toBe(0)
+      p.doc.documentElement.classList.remove('fonts-pending', 'link-hints-pending')
+      await p.win.happyDOM.waitUntilComplete()
+      p.flush()
+      expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('server')
+      expect(p.win.setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 2600)
+      expect(p.scrolled).toEqual([{ id: 'server', collapsed: 0 }])
+    },
+  )
 
-  it.each([false, true])('starts a full cue after the link gate releases, including suppressed icons: %s', async (suppressed) => {
-    const p = page('<h2 id="server">Server</h2>', '#server', false, true)
-    expect(p.doc.querySelector('[data-anchor-arrival]')).toBeNull()
-    expect(p.timers.size).toBe(0)
-    p.doc.documentElement.classList.toggle('link-hints-suppressed', suppressed)
-    p.doc.documentElement.classList.remove('link-hints-pending')
-    await p.win.happyDOM.waitUntilComplete(); p.flush()
-    expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('server')
-    expect(p.win.setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 2600)
-  })
+  it.each([false, true])(
+    'starts a full cue after the link gate releases, including suppressed icons: %s',
+    async (suppressed) => {
+      const p = page('<h2 id="server">Server</h2>', '#server', false, true)
+      expect(p.doc.querySelector('[data-anchor-arrival]')).toBeNull()
+      expect(p.timers.size).toBe(0)
+      p.doc.documentElement.classList.toggle('link-hints-suppressed', suppressed)
+      p.doc.documentElement.classList.remove('link-hints-pending')
+      await p.win.happyDOM.waitUntilComplete()
+      p.flush()
+      expect(p.doc.querySelector('[data-anchor-arrival]')?.id).toBe('server')
+      expect(p.win.setTimeout).toHaveBeenLastCalledWith(expect.any(Function), 2600)
+    },
+  )
 
   it('disconnects a pending link-gate observer when the page is replaced', async () => {
     const p = page('<h2 id="server">Server</h2>', '#server', false, true)
     p.dispose()
     p.doc.documentElement.classList.remove('link-hints-pending')
-    await p.win.happyDOM.waitUntilComplete(); p.flush()
+    await p.win.happyDOM.waitUntilComplete()
+    p.flush()
     expect(p.doc.querySelector('[data-anchor-arrival]')).toBeNull()
     expect(p.timers.size).toBe(0)
   })
 
   it('ignores malformed fragments, other destinations, modified clicks and downloads', () => {
-    const p = page('<h2 id="target">Target</h2><a id="external" href="https://example.com/#target">External</a><a id="other" href="../other/#target">Other</a><a id="modified" href="#target">Modified</a><a id="download" href="#target" download>Download</a>', '#%E0%A4')
+    const p = page(
+      '<h2 id="target">Target</h2><a id="external" href="https://example.com/#target">External</a><a id="other" href="../other/#target">Other</a><a id="modified" href="#target">Modified</a><a id="download" href="#target" download>Download</a>',
+      '#%E0%A4',
+    )
     expect(p.doc.querySelector('[data-anchor-arrival]')).toBeNull()
-    p.click('external'); p.click('other'); p.click('modified', { ctrlKey: true }); p.click('download')
+    p.click('external')
+    p.click('other')
+    p.click('modified', { ctrlKey: true })
+    p.click('download')
     p.flush()
     expect(p.scrolled).toEqual([])
   })
@@ -159,14 +202,17 @@ describe('shared anchor arrival', () => {
     expect(p.scrolled).toHaveLength(1)
   })
 
-  it.each(['../other/#target', '?view=other#target'])('loads an unowned history destination when the old page remains mounted: %s', (destination) => {
-    const p = page('<h2 id="target">Target</h2>')
-    const reload = vi.spyOn(p.win.location, 'reload').mockImplementation(() => {})
-    p.win.history.replaceState(null, '', destination)
-    p.win.dispatchEvent(new p.win.PopStateEvent('popstate', { state: null }))
-    expect(reload).toHaveBeenCalledOnce()
-    expect(p.win.history.state).toBeNull()
-  })
+  it.each(['../other/#target', '?view=other#target'])(
+    'loads an unowned history destination when the old page remains mounted: %s',
+    (destination) => {
+      const p = page('<h2 id="target">Target</h2>')
+      const reload = vi.spyOn(p.win.location, 'reload').mockImplementation(() => {})
+      p.win.history.replaceState(null, '', destination)
+      p.win.dispatchEvent(new p.win.PopStateEvent('popstate', { state: null }))
+      expect(reload).toHaveBeenCalledOnce()
+      expect(p.win.history.state).toBeNull()
+    },
+  )
 
   it('leaves native same-page fragments and router-owned history to their normal navigation', () => {
     const p = page('<h2 id="target">Target</h2>')
diff --git a/site/test/api-db-mentions.test.ts b/site/test/api-db-mentions.test.ts
index bdf49903a..3efb48648 100644
--- a/site/test/api-db-mentions.test.ts
+++ b/site/test/api-db-mentions.test.ts
@@ -8,13 +8,15 @@ import mentionIndex from '../src/data/mentions.json'
 vi.mock('../src/db/paths', async (original) => {
   const { fileURLToPath } = await import('node:url')
   return {
-    ...await original<typeof import('../src/db/paths')>(),
+    ...(await original<typeof import('../src/db/paths')>()),
     MODEL_DIR: fileURLToPath(new URL('./fixtures/api/', import.meta.url)),
   }
 })
 
 const temporary: string[] = []
-afterAll(() => { for (const path of temporary) rmSync(path, { recursive: true, force: true }) })
+afterAll(() => {
+  for (const path of temporary) rmSync(path, { recursive: true, force: true })
+})
 
 /**
  * The backlink index: which prose mentions a symbol.
@@ -41,11 +43,18 @@ describe('prose mention index', () => {
   it('follows the authored owner instead of guessing from a linked label', () => {
     const guide = '/julia/latest/mcp/source-guide/'
     for (const symbol of ['LibTmux.capture_pane', 'LibTmux.send_keys']) {
-      expect(mentionIndex.mentions.some((row) => row.port === 'julia' && row.symbol === symbol && row.page === guide)).toBe(false)
+      expect(
+        mentionIndex.mentions.some((row) => row.port === 'julia' && row.symbol === symbol && row.page === guide),
+      ).toBe(false)
     }
-    expect(mentionIndex.mentions.some((row) => row.port === 'csharp'
-      && row.symbol === 'LibTmux.Workspace.WorkspaceActionKind.CaptureResult'
-      && row.page === '/powershell/latest/workspace/source-guide/')).toBe(true)
+    expect(
+      mentionIndex.mentions.some(
+        (row) =>
+          row.port === 'csharp' &&
+          row.symbol === 'LibTmux.Workspace.WorkspaceActionKind.CaptureResult' &&
+          row.page === '/powershell/latest/workspace/source-guide/',
+      ),
+    ).toBe(true)
     expect(mentionIndex.dangling.filter((row) => ['powershell', 'julia'].includes(row.port))).toEqual([])
   })
 
@@ -54,7 +63,9 @@ describe('prose mention index', () => {
       ['swift', 'JSONValue.bool(_:)', '/topics/socket-and-servers/'],
       ['csharp', 'LibTmux.ControlModeGuardKind.Error', '/topics/errors-and-exceptions/'],
     ]) {
-      expect(mentionIndex.mentions.some((row) => row.port === port && row.symbol === symbol && row.page === page)).toBe(false)
+      expect(mentionIndex.mentions.some((row) => row.port === port && row.symbol === symbol && row.page === page)).toBe(
+        false,
+      )
     }
   })
 
@@ -82,10 +93,7 @@ describe('prose mention index', () => {
     expect(result.mentions, 'rows indexed').toBe(3)
 
     const found = mentionedIn('py', 'libtmux.Pane.capture_pane')
-    expect(found.map((m) => m.page)).toEqual([
-      '/concepts/server-session-window-pane/',
-      '/topics/traversal/',
-    ])
+    expect(found.map((m) => m.page)).toEqual(['/concepts/server-session-window-pane/', '/topics/traversal/'])
     expect(found[0].title).toBe('Server, session, window, pane')
   })
 
@@ -93,9 +101,7 @@ describe('prose mention index', () => {
     // Ids are unique within a port, never globally, so a mention keyed only by
     // symbol would attach Python's backlinks to Rust's page.
     seed({
-      mentionsPath: mentionsFile([
-        { port: 'py', symbol: 'libtmux.Pane.capture_pane', page: '/topics/traversal/' },
-      ]),
+      mentionsPath: mentionsFile([{ port: 'py', symbol: 'libtmux.Pane.capture_pane', page: '/topics/traversal/' }]),
     })
     expect(mentionedIn('rs', 'libtmux.Pane.capture_pane')).toEqual([])
   })
diff --git a/site/test/api-db-prune.test.ts b/site/test/api-db-prune.test.ts
index 317e8e25f..2cd2096e9 100644
--- a/site/test/api-db-prune.test.ts
+++ b/site/test/api-db-prune.test.ts
@@ -7,13 +7,15 @@ import { allExtractions, seed, symbolsOfKind } from '../src/db'
 vi.mock('../src/db/paths', async (original) => {
   const { fileURLToPath } = await import('node:url')
   return {
-    ...await original<typeof import('../src/db/paths')>(),
+    ...(await original<typeof import('../src/db/paths')>()),
     MODEL_DIR: fileURLToPath(new URL('./fixtures/api/', import.meta.url)),
   }
 })
 
 const temporary: string[] = []
-afterAll(() => { for (const path of temporary) rmSync(path, { recursive: true, force: true }) })
+afterAll(() => {
+  for (const path of temporary) rmSync(path, { recursive: true, force: true })
+})
 
 /**
  * A version that leaves the manifest leaves the store.
diff --git a/site/test/api-db.outer.test.ts b/site/test/api-db.outer.test.ts
index 252723449..c542b589e 100644
--- a/site/test/api-db.outer.test.ts
+++ b/site/test/api-db.outer.test.ts
@@ -34,8 +34,7 @@ describeIfSeeded('api projection', () => {
 
   it('holds every port that has an extracted model', () => {
     const ports = new Set(allExtractions().map((e) => e.port))
-    const expected = PORTS.filter((port) => existsSync(join(MODEL_DIR, `${port.slug}.json`)))
-      .map((port) => port.slug)
+    const expected = PORTS.filter((port) => existsSync(join(MODEL_DIR, `${port.slug}.json`))).map((port) => port.slug)
     expect([...ports].sort()).toEqual(expected.sort())
   })
 
diff --git a/site/test/api-dependency-navigation.test.ts b/site/test/api-dependency-navigation.test.ts
index 429b88f34..d68339ac0 100644
--- a/site/test/api-dependency-navigation.test.ts
+++ b/site/test/api-dependency-navigation.test.ts
@@ -1,5 +1,11 @@
 import { describe, expect, it } from 'vitest'
-import { firstEntry, navTree, referenceNavigation, referenceTree, validateNavigationDependency } from '../src/lib/api-tree'
+import {
+  firstEntry,
+  navTree,
+  referenceNavigation,
+  referenceTree,
+  validateNavigationDependency,
+} from '../src/lib/api-tree'
 import { apiTreeHref, searchApi } from '../src/lib/api-search'
 import { API_MODELS, API_NAV, referenceHref } from '../src/lib/api-models'
 import { PORT_BY_SLUG } from '../src/lib/ports'
@@ -7,12 +13,15 @@ import { PORT_BY_SLUG } from '../src/lib/ports'
 const selection = PORT_BY_SLUG.powershell.apiDependencyNavigation![0]
 
 describe('PowerShell returned objects in the reference tree', () => {
-  it.each(['Server', 'Session', 'Window', 'Pane', 'Client'])('exposes the native %s type beside its cmdlets', (name) => {
-    const tree = referenceTree('powershell')
-    const bucket = tree.buckets.find((entry) => entry.id === name.toLowerCase())!
-    expect(bucket.types.map((entry) => entry.id)).toContain(`LibTmux.${name}`)
-    expect(bucket.types.some((entry) => entry.id.startsWith('LibTmux\\'))).toBe(true)
-  })
+  it.each(['Server', 'Session', 'Window', 'Pane', 'Client'])(
+    'exposes the native %s type beside its cmdlets',
+    (name) => {
+      const tree = referenceTree('powershell')
+      const bucket = tree.buckets.find((entry) => entry.id === name.toLowerCase())!
+      expect(bucket.types.map((entry) => entry.id)).toContain(`LibTmux.${name}`)
+      expect(bucket.types.some((entry) => entry.id.startsWith('LibTmux\\'))).toBe(true)
+    },
+  )
 
   it('finds a captured relationship as a property in member search', () => {
     const results = searchApi(referenceTree('powershell'), 'Server.Sessions', 'members')
@@ -30,9 +39,13 @@ describe('PowerShell returned objects in the reference tree', () => {
     const tree = referenceTree('powershell')
     const results = searchApi(tree, '')
     const expectedNative = native.symbols.filter((symbol) => symbol.product === 'core')
-    expect(results.map((entry) => entry.id).sort()).toEqual([
-      ...expectedNative.map((symbol) => symbol.id), ...expectedTypes, ...expectedMembers.map((symbol) => symbol.id),
-    ].sort())
+    expect(results.map((entry) => entry.id).sort()).toEqual(
+      [
+        ...expectedNative.map((symbol) => symbol.id),
+        ...expectedTypes,
+        ...expectedMembers.map((symbol) => symbol.id),
+      ].sort(),
+    )
     expect(results.filter((entry) => entry.id.startsWith('LibTmux\\'))).toHaveLength(55)
     expect(results.some((entry) => entry.id.includes('QuerySet'))).toBe(false)
     expect(results.some((entry) => entry.id.startsWith('LibTmux.Testing.'))).toBe(false)
@@ -43,9 +56,12 @@ describe('PowerShell returned objects in the reference tree', () => {
   it('preserves native category destinations while labeling returned types as .NET', () => {
     const native = navTree('powershell')
     const navigation = referenceNavigation('powershell')!
-    const flatten = (buckets: typeof native): typeof native => buckets.flatMap((bucket) => [bucket, ...flatten(bucket.children)])
+    const flatten = (buckets: typeof native): typeof native =>
+      buckets.flatMap((bucket) => [bucket, ...flatten(bucket.children)])
     for (const bucket of flatten(navigation.tree)) {
-      expect(firstEntry(bucket)?.id, bucket.id).toBe(firstEntry(flatten(native).find((entry) => entry.id === bucket.id)!)?.id)
+      expect(firstEntry(bucket)?.id, bucket.id).toBe(
+        firstEntry(flatten(native).find((entry) => entry.id === bucket.id)!)?.id,
+      )
     }
     for (const [id, names] of Object.entries(selection.sections)) {
       const bucket = flatten(navigation.tree).find((entry) => entry.id === id)!
@@ -56,16 +72,19 @@ describe('PowerShell returned objects in the reference tree', () => {
   it('links every dependency type and member to a real canonical C# page', () => {
     const tree = referenceTree('powershell')
     for (const entry of searchApi(tree, '').filter((entry) => tree.hrefs?.[entry.id])) {
-      expect(apiTreeHref('/en/powershell/latest/reference/', entry, tree.hrefs), entry.id)
-        .toBe(referenceHref('csharp', entry.id))
+      expect(apiTreeHref('/en/powershell/latest/reference/', entry, tree.hrefs), entry.id).toBe(
+        referenceHref('csharp', entry.id),
+      )
       expect(tree.hrefs![entry.id]).toContain('/csharp/')
     }
     const member = searchApi(tree, 'Server.Sessions', 'members')[0]
-    expect(apiTreeHref('/en/powershell/latest/reference/', member, tree.hrefs))
-      .toContain('/csharp/latest/reference/libtmux-server-sessions/')
+    expect(apiTreeHref('/en/powershell/latest/reference/', member, tree.hrefs)).toContain(
+      '/csharp/latest/reference/libtmux-server-sessions/',
+    )
     const command = searchApi(tree, 'Get-TmuxPane', 'members').find((entry) => entry.symbolName === 'Get-TmuxPane')!
-    expect(apiTreeHref('/en/powershell/latest/reference/', command, tree.hrefs))
-      .toBe('/en/powershell/latest/reference/libtmux-get-tmuxpane/')
+    expect(apiTreeHref('/en/powershell/latest/reference/', command, tree.hrefs)).toBe(
+      '/en/powershell/latest/reference/libtmux-get-tmuxpane/',
+    )
   })
 
   it('keeps type and member filters accurate and includes only existing canonical members', () => {
@@ -88,15 +107,24 @@ describe('PowerShell returned objects in the reference tree', () => {
     expect(() => validateNavigationDependency(API_MODELS.powershell, API_MODELS.csharp, selection)).not.toThrow()
     const changedVersion = structuredClone(API_MODELS.csharp)
     changedVersion.sources!.find((source) => source.product === 'core')!.version = '0.0.0-alpha.21'
-    expect(() => validateNavigationDependency(API_MODELS.powershell, changedVersion, selection)).toThrow('requires LibTmux 0.0.0-alpha.20')
+    expect(() => validateNavigationDependency(API_MODELS.powershell, changedVersion, selection)).toThrow(
+      'requires LibTmux 0.0.0-alpha.20',
+    )
     const changedRevision = { ...API_MODELS.csharp, revision: '0'.repeat(40) }
-    expect(() => validateNavigationDependency(API_MODELS.powershell, changedRevision, selection)).toThrow('requires LibTmux')
+    expect(() => validateNavigationDependency(API_MODELS.powershell, changedRevision, selection)).toThrow(
+      'requires LibTmux',
+    )
     const changedPackageSource = structuredClone(API_MODELS.csharp)
     changedPackageSource.sources!.find((source) => source.product === 'core')!.extractedRevision = '0'.repeat(40)
-    expect(() => validateNavigationDependency(API_MODELS.powershell, changedPackageSource, selection)).toThrow('requires LibTmux')
+    expect(() => validateNavigationDependency(API_MODELS.powershell, changedPackageSource, selection)).toThrow(
+      'requires LibTmux',
+    )
     const changedDeclaration = structuredClone(API_MODELS.powershell)
-    changedDeclaration.nativeProvenance!.files.find((file) => file.path === selection.declaration.path)!.sha256 = '0'.repeat(64)
-    expect(() => validateNavigationDependency(changedDeclaration, API_MODELS.csharp, selection)).toThrow('changed Directory.Packages.props')
+    changedDeclaration.nativeProvenance!.files.find((file) => file.path === selection.declaration.path)!.sha256 =
+      '0'.repeat(64)
+    expect(() => validateNavigationDependency(changedDeclaration, API_MODELS.csharp, selection)).toThrow(
+      'changed Directory.Packages.props',
+    )
   })
 
   it('leaves ports without dependency navigation on their existing catalogs', () => {
diff --git a/site/test/api-example-verification.test.ts b/site/test/api-example-verification.test.ts
index fa06bffa7..1e529e6a4 100644
--- a/site/test/api-example-verification.test.ts
+++ b/site/test/api-example-verification.test.ts
@@ -7,13 +7,24 @@ import { describe, expect, it } from 'vitest'
 import { assertCompleteApiExample } from '../scripts/check-clipboard.mjs'
 
 const root = fileURLToPath(new URL('../../', import.meta.url))
-const python = (code: string) => JSON.parse(execFileSync('python3', ['-B', '-c', `
+const python = (code: string) =>
+  JSON.parse(
+    execFileSync(
+      'python3',
+      [
+        '-B',
+        '-c',
+        `
 import importlib.util, json, pathlib, re
 spec = importlib.util.spec_from_file_location('runner', 'scripts/check-example-prose.py')
 runner = importlib.util.module_from_spec(spec)
 spec.loader.exec_module(runner)
 ${code}
-`], { cwd: root, encoding: 'utf8' }))
+`,
+      ],
+      { cwd: root, encoding: 'utf8' },
+    ),
+  )
 const hash = (code: string) => createHash('sha256').update(code).digest('hex')
 
 describe('complete API example selection', () => {
@@ -40,7 +51,8 @@ print(json.dumps(results))`)
   })
 
   it('selects one program on a shared page without including another setup', () => {
-    expect(python(`
+    expect(
+      python(`
 examples = [{'port': 'java', 'page': 'ports/java/reference/server-sessions', 'sourceProgramId': name}
             for name in ['java-ListSessions', 'java-Query']]
 manifest = {'examples': examples}
@@ -52,12 +64,13 @@ assert selected == [examples[1]]
 blocks = [{'lang': 'console', 'code': 'first setup'}, {'lang': 'java', 'code': 'first program'},
           {'lang': 'console', 'code': 'first run'}, {'lang': 'console', 'code': 'second setup'},
           {'lang': 'java', 'code': 'second program'}, {'lang': 'console', 'code': 'second run'}]
-print(json.dumps(runner.api_command_blocks(blocks, {'consoleBlocks': [3, 5]})))`))
-      .toEqual(['second setup', 'second run'])
+print(json.dumps(runner.api_command_blocks(blocks, {'consoleBlocks': [3, 5]})))`),
+    ).toEqual(['second setup', 'second run'])
   })
 
   it('rejects duplicate, non-console, invalid and empty command selections', () => {
-    expect(python(`
+    expect(
+      python(`
 blocks = [{'lang': 'console', 'code': 'setup'}, {'lang': 'java', 'code': 'program'}]
 for indices in [[0, 0], [1], [-1], [2], [True], []]:
     try:
@@ -65,13 +78,15 @@ for indices in [[0, 0], [1], [-1], [2], [True], []]:
     except ValueError:
         continue
     raise AssertionError(indices)
-print(json.dumps(runner.api_command_blocks(blocks, {})))`)).toEqual(['setup'])
+print(json.dumps(runner.api_command_blocks(blocks, {})))`),
+    ).toEqual(['setup'])
   })
 })
 
 describe('homepage native verification ownership', () => {
   it('preserves an existing parent when a probed socket was never created', () => {
-    expect(python(`
+    expect(
+      python(`
 import os, sys, tempfile
 from unittest.mock import patch
 sys.path.insert(0, str(pathlib.Path('scripts').resolve()))
@@ -84,11 +99,13 @@ with tempfile.TemporaryDirectory(prefix='home-parent-test-') as directory:
         sandbox = ExampleTmuxSandbox(output, dict(os.environ))
     sandbox.trace.write_text(json.dumps(dict(socket=str(parent / 'absent.sock'), existed=False)) + '\\n')
     sandbox.finish(True)
-    print(json.dumps(parent.is_dir()))`)).toBe(true)
+    print(json.dumps(parent.is_dir()))`),
+    ).toBe(true)
   })
 
   it('does not treat permission errors and timeouts as proof of socket exit', () => {
-    expect(python(`
+    expect(
+      python(`
 import errno, sys
 from unittest.mock import patch
 sys.path.insert(0, str(pathlib.Path('scripts').resolve()))
@@ -106,11 +123,13 @@ with patch('example_tmux_sandbox.socket.socket') as socket:
     for number in [errno.ENOENT, errno.ECONNREFUSED]:
         connect.side_effect = OSError(number, 'stopped')
         assert not socket_running('/private/stopped.sock')
-print(json.dumps(True))`)).toBe(true)
+print(json.dumps(True))`),
+    ).toBe(true)
   })
 
   it('kills surviving descendants even when their shell already exited', () => {
-    expect(python(`
+    expect(
+      python(`
 import signal
 from unittest.mock import Mock, call, patch
 process = Mock(pid=12345)
@@ -118,11 +137,13 @@ process.wait.return_value = 0
 with patch.object(runner.os, 'killpg') as kill:
     runner.stop_process_group(process)
     assert kill.call_args_list == [call(12345, signal.SIGTERM), call(12345, signal.SIGKILL)]
-print(json.dumps(True))`)).toBe(true)
+print(json.dumps(True))`),
+    ).toBe(true)
   })
 
   it('records joined socket flags without changing the tmux arguments', () => {
-    expect(python(`
+    expect(
+      python(`
 import os, sys, tempfile
 from unittest.mock import patch
 sys.path.insert(0, str(pathlib.Path('scripts').resolve()))
@@ -147,11 +168,13 @@ with tempfile.TemporaryDirectory(prefix='home-native-test-') as directory:
     assert trace['socket'] == str(socket) and not trace['existed']
     report = sandbox.finish(True)
     assert report['passed']
-    print(json.dumps(report['endpoints'][0]['runningAfterHarness']))`)).toBe(false)
+    print(json.dumps(report['endpoints'][0]['runningAfterHarness']))`),
+    ).toBe(false)
   })
 
   it('fails verification without stopping or unlinking a pre-existing socket', () => {
-    expect(python(`
+    expect(
+      python(`
 import os, socket, sys, tempfile
 from unittest.mock import patch
 sys.path.insert(0, str(pathlib.Path('scripts').resolve()))
@@ -170,7 +193,8 @@ with tempfile.TemporaryDirectory(prefix='home-foreign-test-') as directory:
             stop.assert_not_called()
         assert path.exists()
         assert report['endpoints'][0]['runningAfterHarness']
-        print(json.dumps(report['passed']))`)).toBe(false)
+        print(json.dumps(report['passed']))`),
+    ).toBe(false)
   })
 })
 
@@ -179,13 +203,29 @@ describe('API example source and clipboard receipts', () => {
     const revision = 'a'.repeat(40)
     const href = `https://github.com/libtmux/libtmux-java/blob/${revision}/examples/api/run.sh`
     const link = { href, label: 'View source' }
-    const rendered = { text: '', links: [link, link], sourceLinks: [[link], [], [link], []],
-      files: ['whole launcher', 'first recipe', 'whole launcher', 'second recipe'] }
-    const example = { symbol: 'Server.sessions', sourceRepository: 'libtmux/libtmux-java',
-      sourceRevision: revision, sourceFile: 'examples/api/run.sh', consoleBlocks: [3],
-      shellRecipe: ['second recipe'], files: [{ block: 2, name: 'run.sh',
-        sourceFile: 'examples/api/run.sh', sha256: hash('whole launcher\n'),
-        clipboardSha256: hash('whole launcher') }] }
+    const rendered = {
+      text: '',
+      links: [link, link],
+      sourceLinks: [[link], [], [link], []],
+      files: ['whole launcher', 'first recipe', 'whole launcher', 'second recipe'],
+    }
+    const example = {
+      symbol: 'Server.sessions',
+      sourceRepository: 'libtmux/libtmux-java',
+      sourceRevision: revision,
+      sourceFile: 'examples/api/run.sh',
+      consoleBlocks: [3],
+      shellRecipe: ['second recipe'],
+      files: [
+        {
+          block: 2,
+          name: 'run.sh',
+          sourceFile: 'examples/api/run.sh',
+          sha256: hash('whole launcher\n'),
+          clipboardSha256: hash('whole launcher'),
+        },
+      ],
+    }
     return { rendered, example }
   }
 
@@ -195,16 +235,24 @@ describe('API example source and clipboard receipts', () => {
     for (const example of manifest.examples) {
       let model = models.get(example.port)
       if (!model) {
-        model = JSON.parse(readFileSync(new URL(`../src/data/api/${example.port}.json`, import.meta.url), 'utf8')) as ApiModel
+        model = JSON.parse(
+          readFileSync(new URL(`../src/data/api/${example.port}.json`, import.meta.url), 'utf8'),
+        ) as ApiModel
         models.set(example.port, model)
       }
       const symbol = model.symbols.find((entry) => entry.id === example.symbol)!
       const blocks = symbol.doc!.examples as { sourceUrl?: string; code: string; lang: string }[]
-      const sourceLinks = blocks.map((block) => block.sourceUrl
-        ? [{ href: block.sourceUrl, label: 'View source' }] : [])
-      const rendered = { text: '', links: sourceLinks.flat(), sourceLinks,
-        files: blocks.map((block) => block.lang === 'console'
-          ? block.code.replace(/^\$ /gm, '').trim() : block.code.replace(/\n$/, '')) }
+      const sourceLinks = blocks.map((block) =>
+        block.sourceUrl ? [{ href: block.sourceUrl, label: 'View source' }] : [],
+      )
+      const rendered = {
+        text: '',
+        links: sourceLinks.flat(),
+        sourceLinks,
+        files: blocks.map((block) =>
+          block.lang === 'console' ? block.code.replace(/^\$ /gm, '').trim() : block.code.replace(/\n$/, ''),
+        ),
+      }
       expect(() => assertCompleteApiExample(rendered, example), example.symbol).not.toThrow()
     }
   })
@@ -225,7 +273,9 @@ describe('API example source and clipboard receipts', () => {
     duplicate.rendered.sourceLinks[2].push(duplicate.rendered.sourceLinks[2][0])
     expect(() => assertCompleteApiExample(duplicate.rendered, duplicate.example)).toThrow('exact pinned source')
     const wrong = fixture()
-    wrong.rendered.sourceLinks[2] = [{ href: 'https://github.com/libtmux/libtmux-java/blob/main/run.sh', label: 'View source' }]
+    wrong.rendered.sourceLinks[2] = [
+      { href: 'https://github.com/libtmux/libtmux-java/blob/main/run.sh', label: 'View source' },
+    ]
     expect(() => assertCompleteApiExample(wrong.rendered, wrong.example)).toThrow('exact pinned source')
   })
 
diff --git a/site/test/api-examples.test.ts b/site/test/api-examples.test.ts
index 545835c28..c89bfb997 100644
--- a/site/test/api-examples.test.ts
+++ b/site/test/api-examples.test.ts
@@ -10,30 +10,38 @@ const model = go as unknown as ApiModel
 const hash = (code: string) => createHash('sha256').update(code).digest('hex')
 
 describe('verified complete API programs', () => {
-  it.each(receipt.examples.filter((example) => example.port === 'go'))('preserves the executed $symbol files and setup', (example) => {
-    const symbols = model.symbols.filter((symbol) => symbol.id === example.symbol)
-    expect(symbols).toHaveLength(1)
-    const symbol = symbols[0]
-    const blocks = symbol.doc?.examples ?? []
-    const markdown = symbolMarkdown({ model, symbol })
-    const exported = fromMarkdown(markdown).children.filter((node) => node.type === 'code')
-    expect(symbol.source.revision).toBe(example.sourceRevision)
-    expect(example.page).toBe(`ports/go/reference/${symbol.slug}`)
-    for (const file of example.files) {
-      expect(hash(blocks[file.block].code), `${example.symbol}/${file.name}`).toBe(file.sha256)
-      expect(exported.some((block) => hash(block.value + '\n') === file.sha256),
-        `${example.symbol}/${file.name} Markdown`).toBe(true)
-    }
-    expect(blocks.filter((block) => block.lang === 'console')
-      .map((block) => block.code.replace(/^\$ /gm, '').trim())).toEqual(example.shellRecipe)
-    expect(blocks[2].sourceUrl).toBe(`https://github.com/${model.repo}/blob/${example.sourceRevision}/${example.sourceFile}`)
-    expect(blocks[2].intro).not.toContain('[source example](')
-    expect(markdown).toContain(`[Source example](${blocks[2].sourceUrl}).`)
-    expect(blocks[2].code).toMatch(/^package tmux_test\n/)
-    expect(blocks[2].code).toMatch(/func Example\w+_complete\(\)/)
-    expect(blocks[2].code).toContain('// Output:')
-    for (const line of blocks[2].code.split('\n').filter((line) => /^\s*\/\//.test(line))) {
-      expect(line.replaceAll('\t', '    ').length).toBeLessThanOrEqual(100)
-    }
-  })
+  it.each(receipt.examples.filter((example) => example.port === 'go'))(
+    'preserves the executed $symbol files and setup',
+    (example) => {
+      const symbols = model.symbols.filter((symbol) => symbol.id === example.symbol)
+      expect(symbols).toHaveLength(1)
+      const symbol = symbols[0]
+      const blocks = symbol.doc?.examples ?? []
+      const markdown = symbolMarkdown({ model, symbol })
+      const exported = fromMarkdown(markdown).children.filter((node) => node.type === 'code')
+      expect(symbol.source.revision).toBe(example.sourceRevision)
+      expect(example.page).toBe(`ports/go/reference/${symbol.slug}`)
+      for (const file of example.files) {
+        expect(hash(blocks[file.block].code), `${example.symbol}/${file.name}`).toBe(file.sha256)
+        expect(
+          exported.some((block) => hash(block.value + '\n') === file.sha256),
+          `${example.symbol}/${file.name} Markdown`,
+        ).toBe(true)
+      }
+      expect(
+        blocks.filter((block) => block.lang === 'console').map((block) => block.code.replace(/^\$ /gm, '').trim()),
+      ).toEqual(example.shellRecipe)
+      expect(blocks[2].sourceUrl).toBe(
+        `https://github.com/${model.repo}/blob/${example.sourceRevision}/${example.sourceFile}`,
+      )
+      expect(blocks[2].intro).not.toContain('[source example](')
+      expect(markdown).toContain(`[Source example](${blocks[2].sourceUrl}).`)
+      expect(blocks[2].code).toMatch(/^package tmux_test\n/)
+      expect(blocks[2].code).toMatch(/func Example\w+_complete\(\)/)
+      expect(blocks[2].code).toContain('// Output:')
+      for (const line of blocks[2].code.split('\n').filter((line) => /^\s*\/\//.test(line))) {
+        expect(line.replaceAll('\t', '    ').length).toBeLessThanOrEqual(100)
+      }
+    },
+  )
 })
diff --git a/site/test/api-fidelity.test.ts b/site/test/api-fidelity.test.ts
index a42c4baea..3844e2bb8 100644
--- a/site/test/api-fidelity.test.ts
+++ b/site/test/api-fidelity.test.ts
@@ -9,19 +9,24 @@ import { sourceUrl } from '@libtmux/api-model'
 import { API_MODEL_PORTS } from '../src/lib/ports'
 
 const root = fileURLToPath(new URL('../../', import.meta.url))
-const models = Object.fromEntries(API_MODEL_PORTS.map((port) => [port.slug,
-  JSON.parse(readFileSync(join(root, `site/src/data/api/${port.slug}.json`), 'utf8')) as ApiModel,
-]))
+const models = Object.fromEntries(
+  API_MODEL_PORTS.map((port) => [
+    port.slug,
+    JSON.parse(readFileSync(join(root, `site/src/data/api/${port.slug}.json`), 'utf8')) as ApiModel,
+  ]),
+)
 const scratch: string[] = []
 afterEach(() => scratch.splice(0).forEach((path) => rmSync(path, { recursive: true, force: true })))
 
-const escape = (value: string) => value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
+const escape = (value: string) =>
+  value.replaceAll('&', '&amp;').replaceAll('"', '&quot;').replaceAll('<', '&lt;').replaceAll('>', '&gt;')
 
 function entry(model: ApiModel, symbol: ApiSymbol, linked = true, declaration = false, responsive = false): string {
   const id = escape(`${symbol.publicId ?? symbol.id}${declaration ? '.declaration' : ''}`)
   const source = linked ? sourceUrl(model, symbol) : undefined
   const links = `<a class="headerlink" href="#${id}">¶</a>${source ? `<a href="${escape(source)}">source</a>` : ''}`
-  const layout = responsive ? `<span class="gp-sphinx-api-layout--responsive">${links}</span>`
+  const layout = responsive
+    ? `<span class="gp-sphinx-api-layout--responsive">${links}</span>`
     : `<span class="gp-sphinx-api-layout--desktop">${links}</span><span class="gp-sphinx-api-layout--mobile">${links}</span>`
   return `<dl><dt class="gp-sphinx-api-header" id="${id}" data-symbol-id="${escape(symbol.id)}" data-domain="std" data-objtype="${symbol.kind}" data-badge-count="0" data-has-badges="false" data-has-source="${Boolean(source)}" data-signature-expanded="true">${layout}</dt><dd>Reference fixture</dd></dl>`
 }
@@ -42,7 +47,8 @@ function fixture(responsive = false): string {
   return path
 }
 
-const audit = (path: string) => spawnSync(process.execPath, ['scripts/check-api-fidelity.mjs', path], { cwd: root, encoding: 'utf8' })
+const audit = (path: string) =>
+  spawnSync(process.execPath, ['scripts/check-api-fidelity.mjs', path], { cwd: root, encoding: 'utf8' })
 
 describe('API source fidelity gate', () => {
   it('accepts one responsive header per entry', () => {
@@ -87,11 +93,17 @@ describe('API source fidelity gate', () => {
     const model = models.py
     const declarations = model.symbols.filter((symbol) => sourceUrl(model, symbol)).slice(0, 20)
     expect(declarations).toHaveLength(20)
-    page(path, 'py', declarations.map((symbol, index) => entry(model, symbol, index !== 0, true)))
+    page(
+      path,
+      'py',
+      declarations.map((symbol, index) => entry(model, symbol, index !== 0, true)),
+    )
     const result = audit(path)
     expect(result.status).toBe(1)
     expect(result.stdout).toMatch(/py\s+1\s+20\s+20\s+19\s+95%/)
-    expect(result.stderr).toContain(`#${declarations[0].publicId ?? declarations[0].id}.declaration omits its known source link`)
+    expect(result.stderr).toContain(
+      `#${declarations[0].publicId ?? declarations[0].id}.declaration omits its known source link`,
+    )
     expect(result.stderr).not.toContain('source-eligible entries link to source')
   })
 })
diff --git a/site/test/api-glossary.test.ts b/site/test/api-glossary.test.ts
index fcd171744..a57281f3f 100644
--- a/site/test/api-glossary.test.ts
+++ b/site/test/api-glossary.test.ts
@@ -5,7 +5,14 @@ import { afterEach, describe, expect, it, vi } from 'vitest'
 import ts from 'typescript'
 import { experimental_AstroContainer } from 'astro/container'
 import { Window } from 'happy-dom'
-import { API_GLOSSARY_GROUPS, ALL_GLOSSARY_GROUPS, MCP_GLOSSARY_GROUPS, API_GLOSSARY_PATH, apiGlossaryHref, apiGlossaryMarkdown } from '../src/lib/api-glossary'
+import {
+  API_GLOSSARY_GROUPS,
+  ALL_GLOSSARY_GROUPS,
+  MCP_GLOSSARY_GROUPS,
+  API_GLOSSARY_PATH,
+  apiGlossaryHref,
+  apiGlossaryMarkdown,
+} from '../src/lib/api-glossary'
 import { glossaryPreview } from '../src/lib/link-preview'
 import { GET as markdownRoute } from '../src/pages/reference/glossary.md'
 import { GET as jsonRoute } from '../src/pages/reference/glossary.json'
@@ -13,7 +20,12 @@ import { GET as jsonRoute } from '../src/pages/reference/glossary.json'
 const terms = ALL_GLOSSARY_GROUPS.flatMap((group) => group.terms)
 const ids = new Set(terms.map((term) => term.id))
 const modelPath = new URL('../../packages/api-model/src/model.ts', import.meta.url)
-const modelSource = ts.createSourceFile(modelPath.pathname, readFileSync(modelPath, 'utf8'), ts.ScriptTarget.Latest, true)
+const modelSource = ts.createSourceFile(
+  modelPath.pathname,
+  readFileSync(modelPath, 'utf8'),
+  ts.ScriptTarget.Latest,
+  true,
+)
 const astroRequire = createRequire(realpathSync(new URL('../node_modules/astro/package.json', import.meta.url)))
 const windows: Window[] = []
 
@@ -23,7 +35,9 @@ afterEach(async () => {
 })
 
 function declaredLabels(name: string): string[] {
-  const declaration = modelSource.statements.find((node): node is ts.TypeAliasDeclaration => ts.isTypeAliasDeclaration(node) && node.name.text === name)
+  const declaration = modelSource.statements.find(
+    (node): node is ts.TypeAliasDeclaration => ts.isTypeAliasDeclaration(node) && node.name.text === name,
+  )
   expect(declaration, `${name} remains a declared type`).toBeDefined()
   expect(ts.isUnionTypeNode(declaration!.type)).toBe(true)
   return (declaration!.type as ts.UnionTypeNode).types.map((node) => {
@@ -37,21 +51,38 @@ async function badgeComponent() {
   const { transform } = await import(astroRequire.resolve('@astrojs/compiler-rs'))
   const source = new URL('../src/components/api/ApiBadge.astro', import.meta.url)
   const compiled = await transform(readFileSync(source, 'utf8'), {
-    filename: source.pathname, internalURL: 'astro/compiler-runtime', resultScopedSlot: true,
+    filename: source.pathname,
+    internalURL: 'astro/compiler-runtime',
+    resultScopedSlot: true,
     resolvePath: (specifier: string) => specifier,
   })
   expect(compiled.diagnostics.filter((item: { severity: string }) => item.severity === 'error')).toEqual([])
-  let code = compiled.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
+  let code = compiled.code.replaceAll(
+    '"astro/compiler-runtime"',
+    JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+  )
   for (const name of ['api-labels', 'api-glossary']) {
-    code = code.replaceAll(`"../../lib/${name}"`, JSON.stringify(new URL(`../src/lib/${name}.ts`, import.meta.url).href))
+    code = code.replaceAll(
+      `"../../lib/${name}"`,
+      JSON.stringify(new URL(`../src/lib/${name}.ts`, import.meta.url).href),
+    )
   }
-  return (await import(/* @vite-ignore */ `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`)).default
+  return (await import(/* @vite-ignore */ `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`))
+    .default
 }
 
 describe('API glossary coverage', () => {
   it('defines every kind and modifier supported by the API model, including unused kinds', () => {
-    expect(API_GLOSSARY_GROUPS.find((group) => group.id === 'symbol-kinds')!.terms.map((term) => term.id).sort()).toEqual([...declaredLabels('SymbolKind'), 'cmdlet'].sort())
-    expect(API_GLOSSARY_GROUPS.find((group) => group.id === 'modifiers')!.terms.map((term) => term.id).sort()).toEqual([...declaredLabels('Modifier'), 'inherited'].sort())
+    expect(
+      API_GLOSSARY_GROUPS.find((group) => group.id === 'symbol-kinds')!
+        .terms.map((term) => term.id)
+        .sort(),
+    ).toEqual([...declaredLabels('SymbolKind'), 'cmdlet'].sort())
+    expect(
+      API_GLOSSARY_GROUPS.find((group) => group.id === 'modifiers')!
+        .terms.map((term) => term.id)
+        .sort(),
+    ).toEqual([...declaredLabels('Modifier'), 'inherited'].sort())
     expect(ids.size).toBe(terms.length)
     expect(ids.has('package')).toBe(true)
   })
@@ -64,7 +95,13 @@ describe('API glossary coverage', () => {
       const model = JSON.parse(readFileSync(new URL(file, folder), 'utf8'))
       for (const symbol of model.symbols ?? []) {
         symbols++
-        const labels = [symbol.kind, ...(symbol.modifiers ?? []), ...(symbol.command ? [symbol.command.kind] : []), ...(symbol.package ? ['package'] : []), ...(symbol.inheritedFrom ? ['inherited'] : [])]
+        const labels = [
+          symbol.kind,
+          ...(symbol.modifiers ?? []),
+          ...(symbol.command ? [symbol.command.kind] : []),
+          ...(symbol.package ? ['package'] : []),
+          ...(symbol.inheritedFrom ? ['inherited'] : []),
+        ]
         for (const label of labels) if (!apiGlossaryHref(label)) missing.push(`${file}:${symbol.id}:${label}`)
       }
     }
@@ -73,7 +110,19 @@ describe('API glossary coverage', () => {
   })
 
   it('uses stable unique anchors and language references for every term', () => {
-    const primaryHosts = new Set(['docs.python.org', 'docs.julialang.org', 'go.dev', 'docs.swift.org', 'eel.is', 'learn.microsoft.com', 'doc.rust-lang.org', 'www.typescriptlang.org', 'kotlinlang.org', 'packaging.python.org', 'modelcontextprotocol.io'])
+    const primaryHosts = new Set([
+      'docs.python.org',
+      'docs.julialang.org',
+      'go.dev',
+      'docs.swift.org',
+      'eel.is',
+      'learn.microsoft.com',
+      'doc.rust-lang.org',
+      'www.typescriptlang.org',
+      'kotlinlang.org',
+      'packaging.python.org',
+      'modelcontextprotocol.io',
+    ])
     for (const term of terms) {
       expect(term.id).toMatch(/^[a-z][a-zA-Z]*$/)
       expect(apiGlossaryHref(term.id)).toBe(`${API_GLOSSARY_PATH}#${term.id}`)
@@ -86,18 +135,29 @@ describe('API glossary coverage', () => {
         expect(reference.title.length).toBeGreaterThan(0)
       }
     }
-    for (const unknown of ['', 'not-a-kind', 'constructor', '__proto__', '2 overloads']) expect(apiGlossaryHref(unknown)).toBeUndefined()
+    for (const unknown of ['', 'not-a-kind', 'constructor', '__proto__', '2 overloads'])
+      expect(apiGlossaryHref(unknown)).toBeUndefined()
   })
 
   it('keeps MCP annotation definitions and previews in the current port, version, and preview prefix', () => {
     const annotations = MCP_GLOSSARY_GROUPS.flatMap((group) => group.terms)
-    expect(annotations.map((term) => term.id).sort()).toEqual(['destructiveHint', 'idempotentHint', 'openWorldHint', 'readOnlyHint', 'title'])
+    expect(annotations.map((term) => term.id).sort()).toEqual([
+      'destructiveHint',
+      'idempotentHint',
+      'openWorldHint',
+      'readOnlyHint',
+      'title',
+    ])
     for (const base of ['/en/cxx/latest/', '/preview-17/en/rs/stable/', '/en/julia/latest/']) {
       const href = `${base}mcp/reference/glossary/`
       const preview = glossaryPreview(href)
       for (const term of annotations) {
         expect(apiGlossaryHref(term.id, `${base}mcp/tools/create_session/`)).toBe(`${href}#${term.id}`)
-        expect(preview.terms![term.id]).toMatchObject({ href: `${href}#${term.id}`, description: term.definition, detail: term.detail })
+        expect(preview.terms![term.id]).toMatchObject({
+          href: `${href}#${term.id}`,
+          description: term.definition,
+          detail: term.detail,
+        })
       }
       expect(apiGlossaryHref('attribute', `${base}mcp/reference/tooldefinition/`)).toBe(`${href}#attribute`)
       expect(apiGlossaryHref('inventedHint', `${base}mcp/tools/create_session/`)).toBeUndefined()
@@ -131,7 +191,9 @@ describe('API glossary coverage', () => {
     for (const term of terms) {
       expect(markdown).toContain(`### ${term.id}\n`)
       expect(markdown).toContain(term.definition)
-      const exported = json.groups.flatMap((group: { terms: { id: string }[] }) => group.terms).find((entry: { id: string }) => entry.id === term.id)
+      const exported = json.groups
+        .flatMap((group: { terms: { id: string }[] }) => group.terms)
+        .find((entry: { id: string }) => entry.id === term.id)
       expect(exported).toEqual({ ...term, url: `https://libtmux.org${API_GLOSSARY_PATH}#${term.id}` })
       for (const reference of term.references) expect(markdown).toContain(`](${reference.url})`)
     }
@@ -160,15 +222,21 @@ describe('rendered API badges', () => {
       expect(link.getAttribute('aria-label')).toContain(`${target} definition`)
       expect(link.classList.contains(`api-badge--${variant}-${value}`)).toBe(true)
     }
-    const compact = await container.renderToString(component, { props: { label: 'class', variant: 'kind', value: 'class', compact: true } })
+    const compact = await container.renderToString(component, {
+      props: { label: 'class', variant: 'kind', value: 'class', compact: true },
+    })
     win.document.body.innerHTML = `<a href="/en/reference/symbol/">${compact} A type</a>`
     expect(win.document.querySelectorAll('a')).toHaveLength(1)
     expect(win.document.querySelector('span.api-nav__kind')!.getAttribute('aria-hidden')).toBe('true')
-    const command = await container.renderToString(component, { props: { label: 'cmdlet', variant: 'kind', value: 'cmdlet', compact: true } })
+    const command = await container.renderToString(component, {
+      props: { label: 'cmdlet', variant: 'kind', value: 'cmdlet', compact: true },
+    })
     win.document.body.innerHTML = `<a href="/en/reference/command/">${command} A command</a>`
     expect(win.document.querySelector('span.api-nav__kind.api-badge--kind-function')?.textContent).toBe('f')
     expect(win.document.querySelector('span')?.getAttribute('title')).toBe('cmdlet')
-    const unknown = await container.renderToString(component, { props: { label: 'future-kind', variant: 'kind', value: 'future-kind' } })
+    const unknown = await container.renderToString(component, {
+      props: { label: 'future-kind', variant: 'kind', value: 'future-kind' },
+    })
     win.document.body.innerHTML = unknown
     expect(win.document.querySelector('a')).toBeNull()
     expect(win.document.querySelector('span')!.textContent).toBe('future-kind')
diff --git a/site/test/api-prose.test.ts b/site/test/api-prose.test.ts
index d2e00e0f0..edd110df6 100644
--- a/site/test/api-prose.test.ts
+++ b/site/test/api-prose.test.ts
@@ -7,7 +7,11 @@ import { parseApiProse } from '../src/lib/api-prose'
 
 describe('shared API prose blocks', () => {
   it('preserves fenced source instead of treating prompts, comments and bullets as prose', () => {
-    expect(parseApiProse('Before.\n\n```python\n>>> values = [\n...     1,\n... ]\n[1]\n\n# literal\n- literal\n```\n\nAfter.')).toEqual([
+    expect(
+      parseApiProse(
+        'Before.\n\n```python\n>>> values = [\n...     1,\n... ]\n[1]\n\n# literal\n- literal\n```\n\nAfter.',
+      ),
+    ).toEqual([
       { kind: 'p', text: 'Before.' },
       { kind: 'code', lang: 'python', code: '>>> values = [\n...     1,\n... ]\n[1]\n\n# literal\n- literal' },
       { kind: 'p', text: 'After.' },
@@ -16,7 +20,10 @@ describe('shared API prose blocks', () => {
 
   it('keeps existing nested lists and rubrics around a longer literal fence', () => {
     expect(parseApiProse('- Server\n\n  - Session\n\n    - Window\n\n# Details\n\n````text\n```\n````')).toEqual([
-      { kind: 'ul', items: [{ text: 'Server', children: [{ text: 'Session', children: [{ text: 'Window', children: [] }] }] }] },
+      {
+        kind: 'ul',
+        items: [{ text: 'Server', children: [{ text: 'Session', children: [{ text: 'Window', children: [] }] }] }],
+      },
       { kind: 'rubric', text: 'Details' },
       { kind: 'code', lang: 'text', code: '```' },
     ])
@@ -27,14 +34,20 @@ describe('shared API prose blocks', () => {
   })
 })
 
-
 describe('generated Python docstring parity', () => {
   it('keeps all source sessions and experimental emphasis in HTML input and Markdown', () => {
     const model = API_MODELS.py
     const symbol = model.symbols.find((entry) => entry.id === 'libtmux._internal.query_list.QueryList')!
-    const source = readFileSync(new URL('../../packages/api-model/test/fixtures/python-querylist-docstring.txt', import.meta.url), 'utf8')
+    const source = readFileSync(
+      new URL('../../packages/api-model/test/fixtures/python-querylist-docstring.txt', import.meta.url),
+      'utf8',
+    )
     const expected = [...source.matchAll(/^>>>[^\n]*(?:\n[^\n]+)*/gm)].map((match) => match[0])
-    expect(parseApiProse(symbol.doc!.body!).filter((block) => block.kind === 'code').map((block) => block.code)).toEqual(expected)
+    expect(
+      parseApiProse(symbol.doc!.body!)
+        .filter((block) => block.kind === 'code')
+        .map((block) => block.code),
+    ).toEqual(expected)
     const markdown = symbolMarkdown({ model, symbol })
     const tree = fromMarkdown(markdown)
     expect(tree.children.filter((node) => node.type === 'code').map((node) => node.value)).toEqual(expected)
diff --git a/site/test/api-qualified-name.test.ts b/site/test/api-qualified-name.test.ts
index 0687fbb3f..ddad8bc2c 100644
--- a/site/test/api-qualified-name.test.ts
+++ b/site/test/api-qualified-name.test.ts
@@ -21,12 +21,19 @@ async function component() {
   const { transform } = await import(astroRequire.resolve('@astrojs/compiler-rs'))
   async function compile(url: URL, imports: Record<string, string>) {
     const source = readFileSync(url, 'utf8').replace(/<script>[\s\S]*?<\/script>/g, '')
-    const result = await transform(source, { filename: url.pathname,
-      internalURL: 'astro/compiler-runtime', resultScopedSlot: true,
-      resolvePath: (specifier: string) => specifier })
+    const result = await transform(source, {
+      filename: url.pathname,
+      internalURL: 'astro/compiler-runtime',
+      resultScopedSlot: true,
+      resolvePath: (specifier: string) => specifier,
+    })
     expect(result.diagnostics.filter((item: { severity: string }) => item.severity === 'error')).toEqual([])
-    let code = result.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
-    for (const [specifier, href] of Object.entries(imports)) code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(href))
+    let code = result.code.replaceAll(
+      '"astro/compiler-runtime"',
+      JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+    )
+    for (const [specifier, href] of Object.entries(imports))
+      code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(href))
     return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`
   }
   const symbolName = await compile(new URL('../src/components/api/SymbolName.astro', import.meta.url), {
@@ -49,9 +56,15 @@ async function render(props: { name: string; namespace?: string; href?: string }
 
 describe('qualified namespace labels', () => {
   it.each([
-    '', 'libtmux', 'libtmux.common', 'libtmux._internal.constants',
-    'LibTmux.Query.Json', 'LibTmux.Workspace', 'LibTmux\\Workspace',
-    'libtmux::workspace', 'github.com/libtmux/libtmux-go/tmux',
+    '',
+    'libtmux',
+    'libtmux.common',
+    'libtmux._internal.constants',
+    'LibTmux.Query.Json',
+    'LibTmux.Workspace',
+    'LibTmux\\Workspace',
+    'libtmux::workspace',
+    'github.com/libtmux/libtmux-go/tmux',
     'io.github.libtmux.scaladsl.streaming',
   ])('keeps an ordinary namespace fully spelled: %s', (namespace) => {
     expect(abbreviateNamespace(namespace)).toBe(namespace)
@@ -109,7 +122,13 @@ describe('qualified namespace labels', () => {
     expect(expand.getAttribute('aria-controls')).toBe('api-namespace-path')
     expect(expand.getAttribute('aria-expanded')).toBe('false')
     const copied: string[] = []
-    Object.defineProperty(win.navigator, 'clipboard', { value: { writeText: async (text: string) => { copied.push(text) } } })
+    Object.defineProperty(win.navigator, 'clipboard', {
+      value: {
+        writeText: async (text: string) => {
+          copied.push(text)
+        },
+      },
+    })
     const script = /<script>([\s\S]*?)<\/script>/.exec(componentSource)?.[1]
     if (!script) throw new Error('Qualified-name client script is missing')
     win.eval(ts.transpileModule(script, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText)
@@ -120,7 +139,9 @@ describe('qualified namespace labels', () => {
     win.document.querySelector<HTMLButtonElement>('[data-api-copy-name]')!.click()
     await Promise.resolve()
     expect(copied).toEqual([name])
-    await expect.poll(() => win.document.querySelector('[role="status"]')?.textContent, { timeout: 1000 }).toBe('Name copied')
+    await expect
+      .poll(() => win.document.querySelector('[role="status"]')?.textContent, { timeout: 1000 })
+      .toBe('Name copied')
     expand.click()
     expect(expand.getAttribute('aria-expanded')).toBe('false')
     expect(expand.textContent).toBe('Show full name')
diff --git a/site/test/api-relationships.test.ts b/site/test/api-relationships.test.ts
index 6849bac14..cbb0298dc 100644
--- a/site/test/api-relationships.test.ts
+++ b/site/test/api-relationships.test.ts
@@ -3,13 +3,21 @@ import type { ApiModelBase, ApiSymbol } from '@libtmux/api-model'
 import { apiRelationshipPath, apiRelationshipSections, apiRelationships } from '../src/lib/api-relationships'
 
 const symbol = (id: string, references: ApiSymbol['references'] = []): ApiSymbol => ({
-  id, name: id, kind: 'function', modifiers: [], signatures: [], source: { file: 'source.c' }, references,
+  id,
+  name: id,
+  kind: 'function',
+  modifiers: [],
+  signatures: [],
+  source: { file: 'source.c' },
+  references,
 })
 const callback = symbol('callback')
 const child = symbol('child', [{ target: 'child', kind: 'call' }])
 const caller = symbol('caller', [
-  { target: 'child', kind: 'call' }, { target: 'child', kind: 'reference' },
-  { target: 'callback', kind: 'reference' }, { target: 'external', kind: 'call' },
+  { target: 'child', kind: 'call' },
+  { target: 'child', kind: 'reference' },
+  { target: 'callback', kind: 'reference' },
+  { target: 'external', kind: 'call' },
 ])
 const model: ApiModelBase = { extractor: 'fixture', symbols: [caller, child, callback] }
 
@@ -17,8 +25,14 @@ describe('shared function relationships', () => {
   it('distinguishes calls, recursion and callback references in both directions', () => {
     const groups = apiRelationshipSections(model, caller)
     expect(groups.find((group) => group.label === 'Calls')?.items.map((item) => item.id)).toEqual(['child'])
-    expect(groups.find((group) => group.label === 'Other function references')?.items.map((item) => item.id)).toEqual(['callback'])
-    expect(apiRelationshipSections(model, child).find((group) => group.label === 'Called by')?.items.map((item) => item.id)).toEqual(['caller', 'child'])
+    expect(groups.find((group) => group.label === 'Other function references')?.items.map((item) => item.id)).toEqual([
+      'callback',
+    ])
+    expect(
+      apiRelationshipSections(model, child)
+        .find((group) => group.label === 'Called by')
+        ?.items.map((item) => item.id),
+    ).toEqual(['caller', 'child'])
     expect(apiRelationshipSections(model, callback).map((group) => group.label)).toEqual(['Referenced by'])
     expect(apiRelationships(model, caller).outgoing.some((edge) => edge.to.id === 'external')).toBe(false)
   })
diff --git a/site/test/api-search.test.ts b/site/test/api-search.test.ts
index 84e1ce522..cae02f4cc 100644
--- a/site/test/api-search.test.ts
+++ b/site/test/api-search.test.ts
@@ -9,8 +9,16 @@ describe('reference symbol search', () => {
     const tree = referenceTree('java')
     for (const [query, id, slug] of [
       ['io.github.libtmux.Server', 'io.github.libtmux.Server.Server', 'io-github-libtmux-server-server'],
-      ['io.github.libtmux.Server.Builder', 'io.github.libtmux.Server.Server.Builder', 'io-github-libtmux-server-server-builder-dv7l'],
-      ['io.github.libtmux.Server.sessions', 'io.github.libtmux.Server.Server.sessions', 'io-github-libtmux-server-server-sessions'],
+      [
+        'io.github.libtmux.Server.Builder',
+        'io.github.libtmux.Server.Server.Builder',
+        'io-github-libtmux-server-server-builder-dv7l',
+      ],
+      [
+        'io.github.libtmux.Server.sessions',
+        'io.github.libtmux.Server.Server.sessions',
+        'io-github-libtmux-server-server-sessions',
+      ],
     ]) {
       expect(searchApi(tree, query)[0]).toMatchObject({ id, qualifiedName: query, slug })
       expect(searchApi(tree, id)[0].id).toBe(id)
@@ -51,8 +59,15 @@ describe('reference symbol search', () => {
 
   it.each(API_MODEL_PORTS.map((port) => port.slug))('retains %s native kinds and searchable identities', (port) => {
     const inventory = referenceTree(port)
-    const symbols = new Map(referenceNavigation(port)!.model.symbols.flatMap((symbol) =>
-      [[symbol.id, symbol], [symbol.publicId ?? symbol.id, symbol]] as const))
+    const symbols = new Map(
+      referenceNavigation(port)!.model.symbols.flatMap(
+        (symbol) =>
+          [
+            [symbol.id, symbol],
+            [symbol.publicId ?? symbol.id, symbol],
+          ] as const,
+      ),
+    )
     const results = searchApi(inventory, '')
     expect(results.length).toBeGreaterThan(0)
     expect(new Set(results.map((entry) => entry.id)).size).toBe(results.length)
diff --git a/site/test/api-sections.test.ts b/site/test/api-sections.test.ts
index 9ea25c759..ceb0f12fe 100644
--- a/site/test/api-sections.test.ts
+++ b/site/test/api-sections.test.ts
@@ -1,12 +1,26 @@
 import { readFileSync } from 'node:fs'
 import { describe, expect, it } from 'vitest'
 import { compareMembers, extractPowerShell, memberSignals, SymbolIndex, type ApiSymbol } from '@libtmux/api-model'
-import { apiCommandFacts, apiEntryFields, apiEntrySections, apiMemberGroups, apiMethodDetails, parameterBindingFacts, parameterBindingText, relatedApiTypes } from '../src/lib/api-sections'
+import {
+  apiCommandFacts,
+  apiEntryFields,
+  apiEntrySections,
+  apiMemberGroups,
+  apiMethodDetails,
+  parameterBindingFacts,
+  parameterBindingText,
+  relatedApiTypes,
+} from '../src/lib/api-sections'
 import { API_MODELS } from '../src/lib/api-models'
 
 const symbol = (id: string, overrides: Partial<ApiSymbol> = {}): ApiSymbol => ({
-  id, name: id.split('.').at(-1)!, kind: 'class', modifiers: [], signatures: [],
-  source: { file: 'example.ts', line: 1 }, ...overrides,
+  id,
+  name: id.split('.').at(-1)!,
+  kind: 'class',
+  modifiers: [],
+  signatures: [],
+  source: { file: 'example.ts', line: 1 },
+  ...overrides,
 })
 
 describe('reference page navigation', () => {
@@ -19,13 +33,20 @@ describe('reference page navigation', () => {
       for (const parameter of fields.params) {
         for (const label of parameter.overloads) {
           const target = methods.find((method) => method.overloadLabel === label)
-          expect(target?.signature.params.some((param) => param.name === parameter.name && param.type === parameter.type), label).toBe(true)
+          expect(
+            target?.signature.params.some((param) => param.name === parameter.name && param.type === parameter.type),
+            label,
+          ).toBe(true)
         }
       }
     }
   })
   it('renders native commands without a default parameter set', () => {
-    const model = extractPowerShell(JSON.parse(readFileSync(new URL('../../packages/api-model/test/fixtures/powershell-native.json', import.meta.url), 'utf8')))
+    const model = extractPowerShell(
+      JSON.parse(
+        readFileSync(new URL('../../packages/api-model/test/fixtures/powershell-native.json', import.meta.url), 'utf8'),
+      ),
+    )
     const index = new SymbolIndex(model.symbols, (entry) => `#${entry.id}`, 'powershell')
     const control = model.symbols.find((entry) => entry.name === 'Connect-TmuxControl')!
     const facts = apiCommandFacts(control)
@@ -34,39 +55,64 @@ describe('reference page navigation', () => {
   })
 
   it('keeps native parameter sets and binding details in the rendered section order', () => {
-    const model = extractPowerShell(JSON.parse(readFileSync(new URL('../../packages/api-model/test/fixtures/powershell-native.json', import.meta.url), 'utf8')))
+    const model = extractPowerShell(
+      JSON.parse(
+        readFileSync(new URL('../../packages/api-model/test/fixtures/powershell-native.json', import.meta.url), 'utf8'),
+      ),
+    )
     const pane = model.symbols.find((entry) => entry.name === 'Get-TmuxPane')!
     const fields = apiEntryFields(pane, 'powershell')
     const server = fields.params.find((entry) => entry.name === 'Server')!
     expect(server.overloads).toEqual(['Server'])
     expect(parameterBindingText(server)).toContain('Required. Position 0. Accepts pipeline input by value.')
-    expect(parameterBindingFacts(server)).toEqual(expect.arrayContaining([
-      { label: 'Required', value: 'Yes' },
-      { label: 'Position', value: '0' },
-      { label: 'Pipeline input', value: 'By value' },
-    ]))
+    expect(parameterBindingFacts(server)).toEqual(
+      expect.arrayContaining([
+        { label: 'Required', value: 'Yes' },
+        { label: 'Position', value: '0' },
+        { label: 'Pipeline input', value: 'By value' },
+      ]),
+    )
     const id = fields.params.find((entry) => entry.name === 'Id')!
     expect(parameterBindingText(id)).toContain('ValidateNotNullOrEmpty()')
-    expect(parameterBindingFacts(id)).toContainEqual({ label: 'Validation', value: '[`ValidateNotNullOrEmpty()`](https://learn.microsoft.com/dotnet/api/system.management.automation.validatenotnulloremptyattribute?view=powershellsdk-7.4.0)' })
+    expect(parameterBindingFacts(id)).toContainEqual({
+      label: 'Validation',
+      value:
+        '[`ValidateNotNullOrEmpty()`](https://learn.microsoft.com/dotnet/api/system.management.automation.validatenotnulloremptyattribute?view=powershellsdk-7.4.0)',
+    })
     expect(apiEntrySections(pane, 'powershell').map((entry) => entry.label)).toEqual([
-      'Description', 'Command details', 'Examples', 'Parameters', 'Returns',
+      'Description',
+      'Command details',
+      'Examples',
+      'Parameters',
+      'Returns',
     ])
     const control = model.symbols.find((entry) => entry.name === 'Connect-TmuxControl')!
-    expect(apiCommandFacts(control).find((entry) => entry.label === 'Confirmation')?.value).toContain('`-WhatIf` and `-Confirm`')
+    expect(apiCommandFacts(control).find((entry) => entry.label === 'Confirmation')?.value).toContain(
+      '`-WhatIf` and `-Confirm`',
+    )
     expect(apiCommandFacts(pane).find((entry) => entry.label === 'Outputs')?.value).toBe('`LibTmux.Pane`')
   })
 
   it('preserves distinct overload fields and identifies which calls they describe', () => {
-    const method = symbol('Server.session', { kind: 'method', signatures: [
-      { params: [{ name: 'value', type: 'Expr', doc: 'Match exactly one session.' }],
-        returnsDoc: 'The matching session.', raises: [{ type: 'CardinalityError', doc: 'Zero or multiple matches.' }] },
-      { params: [{ name: 'value', type: 'string', doc: 'Look up a session name.' }],
-        returnsDoc: 'The named session or null.' },
-      { params: [{ name: 'id', type: 'SessionId' }] },
-    ] })
+    const method = symbol('Server.session', {
+      kind: 'method',
+      signatures: [
+        {
+          params: [{ name: 'value', type: 'Expr', doc: 'Match exactly one session.' }],
+          returnsDoc: 'The matching session.',
+          raises: [{ type: 'CardinalityError', doc: 'Zero or multiple matches.' }],
+        },
+        {
+          params: [{ name: 'value', type: 'string', doc: 'Look up a session name.' }],
+          returnsDoc: 'The named session or null.',
+        },
+        { params: [{ name: 'id', type: 'SessionId' }] },
+      ],
+    })
     const fields = apiEntryFields(method, 'kotlin')
     expect(fields.params.map((param) => [param.name, param.type, param.doc])).toEqual([
-      ['value', 'Expr', 'Match exactly one session.'], ['value', 'string', 'Look up a session name.'],
+      ['value', 'Expr', 'Match exactly one session.'],
+      ['value', 'string', 'Look up a session name.'],
       ['id', 'SessionId', undefined],
     ])
     expect(fields.returns).toEqual([
@@ -76,7 +122,11 @@ describe('reference page navigation', () => {
     expect(fields.raises).toEqual([
       { type: 'CardinalityError', doc: 'Zero or multiple matches.', overloads: ['session(value) [overload 1]'] },
     ])
-    expect(apiEntrySections(method, 'kotlin').map((section) => section.label)).toEqual(['Parameters', 'Returns', 'Errors'])
+    expect(apiEntrySections(method, 'kotlin').map((section) => section.label)).toEqual([
+      'Parameters',
+      'Returns',
+      'Errors',
+    ])
   })
 
   it('treats the Python implementation docstring as documentation for every overload', () => {
@@ -91,14 +141,15 @@ describe('reference page navigation', () => {
   it('distinguishes Swift overloads without duplicating its name parentheses', () => {
     const next = API_MODELS.swift.symbols.find((entry) => entry.id === 'ControlNotificationStream.Iterator.next()')!
     const fields = apiEntryFields(next, 'swift')
-    expect(fields.raises.map((entry) => entry.overloads)).toEqual([
-      ['next() [overload 1]'], ['next() [overload 2]'],
-    ])
+    expect(fields.raises.map((entry) => entry.overloads)).toEqual([['next() [overload 1]'], ['next() [overload 2]']])
   })
 
   it('renders a shared field once without an unnecessary overload qualifier', () => {
-    const common = { params: [{ name: 'value', type: 'string', doc: 'The name.' }],
-      returnsDoc: 'The matching session.', raises: [{ type: 'TransportError', doc: 'The server is unavailable.' }] }
+    const common = {
+      params: [{ name: 'value', type: 'string', doc: 'The name.' }],
+      returnsDoc: 'The matching session.',
+      raises: [{ type: 'TransportError', doc: 'The server is unavailable.' }],
+    }
     const method = symbol('Server.session', { signatures: [common, { ...common, returns: 'Session?' }] })
     const fields = apiEntryFields(method, 'kotlin')
     expect(fields.params).toHaveLength(1)
@@ -123,7 +174,10 @@ describe('reference page navigation', () => {
       symbol('Server.sessions', { kind: 'property' }),
       symbol('Server.panes', { kind: 'property' }),
       symbol('Server.listPanes', { kind: 'method', modifiers: ['deprecated'] }),
-      symbol('Server.create', { kind: 'method', doc: { summary: 'Create a session.', examples: [{ code: 'create()', lang: 'ts' }] } }),
+      symbol('Server.create', {
+        kind: 'method',
+        doc: { summary: 'Create a session.', examples: [{ code: 'create()', lang: 'ts' }] },
+      }),
     ].sort(compareMembers(signals))
     const groups = apiMemberGroups(members, signals)
     expect(groups[0].members.map((member) => member.name)).toEqual(['sessions', 'windows', 'panes'])
@@ -142,16 +196,21 @@ describe('reference page navigation', () => {
     expect(relatedApiTypes(member, [], index, owner)).toEqual([owner])
   })
 
-  it.each(['py', 'ts', 'java', 'kotlin', 'scala', 'csharp'])('groups %s parent objects before its other members', (port) => {
-    const signals = memberSignals(port)
-    const owner = API_MODELS[port].symbols.find((entry) => entry.name === 'Pane' && entry.kind === 'class')!
-    const members = API_MODELS[port].symbols.filter((entry) => entry.parent === owner.id).sort(compareMembers(signals))
-    const groups = apiMemberGroups(members, signals)
-    expect(groups[0].id).toBe('api-parent-objects')
-    expect(groups[0].label).toBe('Parent objects')
-    expect(groups[0].members.map((member) => member.name.toLowerCase())).toEqual(
-      ['py', 'ts', 'csharp'].includes(port) ? ['window', 'session', 'server'] : ['window', 'server'],
-    )
-    expect(groups.flatMap((group) => group.members)).toEqual(members)
-  })
+  it.each(['py', 'ts', 'java', 'kotlin', 'scala', 'csharp'])(
+    'groups %s parent objects before its other members',
+    (port) => {
+      const signals = memberSignals(port)
+      const owner = API_MODELS[port].symbols.find((entry) => entry.name === 'Pane' && entry.kind === 'class')!
+      const members = API_MODELS[port].symbols
+        .filter((entry) => entry.parent === owner.id)
+        .sort(compareMembers(signals))
+      const groups = apiMemberGroups(members, signals)
+      expect(groups[0].id).toBe('api-parent-objects')
+      expect(groups[0].label).toBe('Parent objects')
+      expect(groups[0].members.map((member) => member.name.toLowerCase())).toEqual(
+        ['py', 'ts', 'csharp'].includes(port) ? ['window', 'session', 'server'] : ['window', 'server'],
+      )
+      expect(groups.flatMap((group) => group.members)).toEqual(members)
+    },
+  )
 })
diff --git a/site/test/api-tree-catalog.test.ts b/site/test/api-tree-catalog.test.ts
index 389917e30..10e081a9c 100644
--- a/site/test/api-tree-catalog.test.ts
+++ b/site/test/api-tree-catalog.test.ts
@@ -1,31 +1,65 @@
 import { describe, expect, it } from 'vitest'
 import type { ApiModelBase, ApiSymbol } from '@libtmux/api-model'
 import type { PortNavData } from '../src/lib/api-models'
-import { bucketTotal, firstEntry, membersByTypeFor, navTreeFor, referenceIndexSectionsFor, referenceTreeFor } from '../src/lib/api-tree'
+import {
+  bucketTotal,
+  firstEntry,
+  membersByTypeFor,
+  navTreeFor,
+  referenceIndexSectionsFor,
+  referenceTreeFor,
+} from '../src/lib/api-tree'
 import { searchApi } from '../src/lib/api-search'
 
 const symbol = (id: string, kind: ApiSymbol['kind'], parent?: string): ApiSymbol => ({
-  id, name: id, qualifiedName: id, kind, parent, slug: id.replaceAll(':', '-'),
-  apiScope: 'internal', modifiers: [], signatures: [], source: { file: 'tmux.h' },
+  id,
+  name: id,
+  qualifiedName: id,
+  kind,
+  parent,
+  slug: id.replaceAll(':', '-'),
+  apiScope: 'internal',
+  modifiers: [],
+  signatures: [],
+  source: { file: 'tmux.h' },
 })
-const model: ApiModelBase = { extractor: 'fixture', symbols: [
-  symbol('value', 'union'), symbol('value:nested', 'union', 'value'),
-  symbol('value:nested:integer', 'attribute', 'value:nested'), symbol('read', 'function'),
-  { ...symbol('one:callback', 'function'), name: 'callback' },
-  { ...symbol('two:callback', 'function'), name: 'callback' },
-] }
+const model: ApiModelBase = {
+  extractor: 'fixture',
+  symbols: [
+    symbol('value', 'union'),
+    symbol('value:nested', 'union', 'value'),
+    symbol('value:nested:integer', 'attribute', 'value:nested'),
+    symbol('read', 'function'),
+    { ...symbol('one:callback', 'function'), name: 'callback' },
+    { ...symbol('two:callback', 'function'), name: 'callback' },
+  ],
+}
 const entry = (id: string) => {
   const item = model.symbols.find((candidate) => candidate.id === id)!
   return { id, name: item.name, kind: item.kind, slug: item.slug! }
 }
 const nav: PortNavData = {
   port: 'tmux',
-  buckets: [{ id: 'source', label: 'Source', collapsed: false, children: [
-    { id: 'header', label: 'Header', collapsed: true, children: [
-      { id: 'types', label: 'Types', collapsed: true },
-    ] },
-  ] }],
-  assignments: { source: [entry('read'), entry('one:callback'), entry('two:callback')], header: [], types: [entry('value')] },
+  buckets: [
+    {
+      id: 'source',
+      label: 'Source',
+      collapsed: false,
+      children: [
+        {
+          id: 'header',
+          label: 'Header',
+          collapsed: true,
+          children: [{ id: 'types', label: 'Types', collapsed: true }],
+        },
+      ],
+    },
+  ],
+  assignments: {
+    source: [entry('read'), entry('one:callback'), entry('two:callback')],
+    header: [],
+    types: [entry('value')],
+  },
   placement: { read: 'source', 'one:callback': 'source', 'two:callback': 'source', value: 'types' },
   unplaced: [],
 }
@@ -38,14 +72,25 @@ describe('source catalog reference navigation', () => {
     expect(firstEntry(tree[0])?.slug).toBe('value')
     const sections = referenceIndexSectionsFor(model, tree)
     expect(sections.map((section) => [section.id, section.name, section.collapsed])).toEqual([
-      ['source', 'Source', false], ['types', 'Source — Header — Types', true],
+      ['source', 'Source', false],
+      ['types', 'Source — Header — Types', true],
     ])
     expect(sections[1].types.map((item) => item.id)).toEqual(['value'])
     const json = referenceTreeFor('tmux:3.7c', model, tree)
     expect(json.port).toBe('tmux:3.7c')
-    expect(json.members.value[0].slice(0, 5)).toEqual(['value:nested', 'value-nested', 'value:nested', 'union', 'types'])
+    expect(json.members.value[0].slice(0, 5)).toEqual([
+      'value:nested',
+      'value-nested',
+      'value:nested',
+      'union',
+      'types',
+    ])
     expect(json.members['value:nested'][0][2]).toBe('value:nested:integer')
-    expect(searchApi(json, '').map((item) => item.id).sort()).toEqual(model.symbols.map((item) => item.id).sort())
+    expect(
+      searchApi(json, '')
+        .map((item) => item.id)
+        .sort(),
+    ).toEqual(model.symbols.map((item) => item.id).sort())
     expect(searchApi(json, 'value:nested', 'types').map((item) => item.id)).toContain('value:nested')
     expect(searchApi(json, 'value:nested:integer', 'members').map((item) => item.id)).toEqual(['value:nested:integer'])
     expect(model).not.toHaveProperty('port')
@@ -78,20 +123,38 @@ describe('source catalog reference navigation', () => {
   })
 
   it('filters products only when requested and preserves internal declarations and input records', () => {
-    const catalog: ApiModelBase = { extractor: 'fixture', symbols: [
-      { ...symbol('workspace', 'struct'), product: 'workspace', apiScope: 'exported' },
-      { ...symbol('workspace:public', 'attribute', 'workspace'), product: 'workspace', apiScope: 'exported' },
-      { ...symbol('internal', 'union'), product: 'workspace' },
-      symbol('internal:field', 'attribute', 'internal'),
-    ] }
-    const compiled: PortNavData = { port: 'fixture', buckets: [{ id: 'all', label: 'All', collapsed: false }],
-      assignments: { all: catalog.symbols.filter((item) => !item.parent).map((item) => ({ id: item.id, name: item.name, kind: item.kind, slug: item.slug! })) },
-      placement: { workspace: 'all', internal: 'all' }, unplaced: [] }
+    const catalog: ApiModelBase = {
+      extractor: 'fixture',
+      symbols: [
+        { ...symbol('workspace', 'struct'), product: 'workspace', apiScope: 'exported' },
+        { ...symbol('workspace:public', 'attribute', 'workspace'), product: 'workspace', apiScope: 'exported' },
+        { ...symbol('internal', 'union'), product: 'workspace' },
+        symbol('internal:field', 'attribute', 'internal'),
+      ],
+    }
+    const compiled: PortNavData = {
+      port: 'fixture',
+      buckets: [{ id: 'all', label: 'All', collapsed: false }],
+      assignments: {
+        all: catalog.symbols
+          .filter((item) => !item.parent)
+          .map((item) => ({ id: item.id, name: item.name, kind: item.kind, slug: item.slug! })),
+      },
+      placement: { workspace: 'all', internal: 'all' },
+      unplaced: [],
+    }
     const cached = membersByTypeFor('fixture', catalog)
     const before = structuredClone([...cached])
     const all = referenceTreeFor('fixture', catalog, navTreeFor(catalog, compiled))
-    expect(searchApi(all, '').map((item) => item.id).sort()).toEqual(catalog.symbols.map((item) => item.id).sort())
-    const core = referenceTreeFor('fixture', catalog, navTreeFor(catalog, compiled, { excludeProducts: true }), { excludeProducts: true, members: cached })
+    expect(
+      searchApi(all, '')
+        .map((item) => item.id)
+        .sort(),
+    ).toEqual(catalog.symbols.map((item) => item.id).sort())
+    const core = referenceTreeFor('fixture', catalog, navTreeFor(catalog, compiled, { excludeProducts: true }), {
+      excludeProducts: true,
+      members: cached,
+    })
     expect(searchApi(core, '').map((item) => item.id)).toEqual(['internal', 'internal:field'])
     expect(Object.keys(core.members)).toEqual(['internal'])
     expect([...cached]).toEqual(before)
diff --git a/site/test/api-tree-interaction.test.ts b/site/test/api-tree-interaction.test.ts
index 0e2eba17a..899f41abc 100644
--- a/site/test/api-tree-interaction.test.ts
+++ b/site/test/api-tree-interaction.test.ts
@@ -24,8 +24,16 @@ async function navigation(options: { json?: ApiTreeJson; base?: string; search?:
   })
   const json: ApiTreeJson = options.json ?? {
     port: 'tmux',
-    buckets: [{ id: 'args', label: 'Arguments', count: 1, slug: 'args-entry', children: [],
-      types: [{ id: 'c:args_entry', name: 'args_entry', slug: 'args-entry', kind: 'struct', m: 1 }] }],
+    buckets: [
+      {
+        id: 'args',
+        label: 'Arguments',
+        count: 1,
+        slug: 'args-entry',
+        children: [],
+        types: [{ id: 'c:args_entry', name: 'args_entry', slug: 'args-entry', kind: 'struct', m: 1 }],
+      },
+    ],
     members: {
       'c:args_entry': [
         ['entry', 'entry', 'c:args_entry:entry', 'struct'],
@@ -54,7 +62,11 @@ async function navigation(options: { json?: ApiTreeJson; base?: string; search?:
     item.dispatchEvent(new win.KeyboardEvent('keydown', { key: name, bubbles: true, cancelable: true }))
     await vi.waitFor(() => expect(item.hasAttribute('aria-busy')).toBe(false))
   }
-  const children = (item: HTMLElement) => [...item.querySelectorAll<HTMLElement>(':scope > [role="group"] > [role="treeitem"], :scope > [role="group"] > [role="none"] > [role="treeitem"]')]
+  const children = (item: HTMLElement) => [
+    ...item.querySelectorAll<HTMLElement>(
+      ':scope > [role="group"] > [role="treeitem"], :scope > [role="group"] > [role="none"] > [role="treeitem"]',
+    ),
+  ]
   return { tree, bucket, key, children, fetch, initApiTree, saveApiTreeState }
 }
 
@@ -103,8 +115,12 @@ it('discards stale cached rows and treats cached labels as text', async () => {
   const nav = win.document.querySelector<HTMLElement>('.api-nav')!
   nav.dataset.version = 'model-b'
   const key = 'libtmux:api-tree:/en/tmux/3.7c/reference/'
-  const value = { top: 0, branches: { 'bucket:args': true }, version: 'model-a',
-    groups: { 'bucket:args': [{ label: ['<img src=x onerror=alert(1)>'], href: 'javascript:alert(1)' }] } }
+  const value = {
+    top: 0,
+    branches: { 'bucket:args': true },
+    version: 'model-a',
+    groups: { 'bucket:args': [{ label: ['<img src=x onerror=alert(1)>'], href: 'javascript:alert(1)' }] },
+  }
   win.sessionStorage.setItem(key, JSON.stringify(value))
   win.eval(`(${initializeApiTree.toString()})(document.querySelector('.api-nav'))`)
   expect(nav.querySelector('[role="group"]')).toBeNull()
@@ -120,12 +136,51 @@ it('keeps dependency destinations in lazy branches and filtered search under a l
   const dependencyBase = '/pr-138/ja/csharp/latest/reference/'
   const json: ApiTreeJson = {
     port: 'powershell',
-    buckets: [{ id: 'args', label: 'Server', count: 2, slug: 'libtmux-get-tmuxserver', children: [], types: [
-      { id: 'LibTmux.Server', name: 'Server (.NET)', symbolName: 'Server', slug: 'libtmux-server', kind: 'class', category: 'types', m: 1 },
-      { id: 'LibTmux\\Get-TmuxServer', name: 'Get-TmuxServer', slug: 'libtmux-get-tmuxserver', kind: 'function', category: 'members', m: 0 },
-    ] }],
-    members: { 'LibTmux.Server': [['Sessions', 'libtmux-server-sessions', 'LibTmux.Server.Sessions', 'property', 'members', '', 'LibTmux.Server.Sessions']] },
-    hrefs: { 'LibTmux.Server': `${dependencyBase}libtmux-server/`, 'LibTmux.Server.Sessions': `${dependencyBase}libtmux-server-sessions/` },
+    buckets: [
+      {
+        id: 'args',
+        label: 'Server',
+        count: 2,
+        slug: 'libtmux-get-tmuxserver',
+        children: [],
+        types: [
+          {
+            id: 'LibTmux.Server',
+            name: 'Server (.NET)',
+            symbolName: 'Server',
+            slug: 'libtmux-server',
+            kind: 'class',
+            category: 'types',
+            m: 1,
+          },
+          {
+            id: 'LibTmux\\Get-TmuxServer',
+            name: 'Get-TmuxServer',
+            slug: 'libtmux-get-tmuxserver',
+            kind: 'function',
+            category: 'members',
+            m: 0,
+          },
+        ],
+      },
+    ],
+    members: {
+      'LibTmux.Server': [
+        [
+          'Sessions',
+          'libtmux-server-sessions',
+          'LibTmux.Server.Sessions',
+          'property',
+          'members',
+          '',
+          'LibTmux.Server.Sessions',
+        ],
+      ],
+    },
+    hrefs: {
+      'LibTmux.Server': `${dependencyBase}libtmux-server/`,
+      'LibTmux.Server.Sessions': `${dependencyBase}libtmux-server-sessions/`,
+    },
   }
   const n = await navigation({ base, json, search: true })
   await n.key(n.bucket, 'ArrowRight')
@@ -138,10 +193,16 @@ it('keeps dependency destinations in lazy branches and filtered search under a l
   input.value = 'Server'
   win.document.querySelector<HTMLButtonElement>('[data-api-search-kind="types"]')!.click()
   await vi.waitFor(() => expect(win.document.querySelectorAll('[data-api-search-results] a')).toHaveLength(1))
-  expect(win.document.querySelector('[data-api-search-results] a')?.getAttribute('href')).toBe(`${dependencyBase}libtmux-server/`)
+  expect(win.document.querySelector('[data-api-search-results] a')?.getAttribute('href')).toBe(
+    `${dependencyBase}libtmux-server/`,
+  )
   input.value = 'Server.Sessions'
   win.document.querySelector<HTMLButtonElement>('[data-api-search-kind="members"]')!.click()
-  await vi.waitFor(() => expect(win.document.querySelector('[data-api-search-results] a')?.getAttribute('href')).toBe(`${dependencyBase}libtmux-server-sessions/`))
+  await vi.waitFor(() =>
+    expect(win.document.querySelector('[data-api-search-results] a')?.getAttribute('href')).toBe(
+      `${dependencyBase}libtmux-server-sessions/`,
+    ),
+  )
   expect(n.fetch).toHaveBeenCalledExactlyOnceWith(`${base}tree.json`)
 })
 
@@ -149,14 +210,20 @@ it('builds a lazy branch once when the reader opens it during restoration', asyn
   const n = await navigation()
   const originalFetch = n.fetch.getMockImplementation()!
   let release!: () => void
-  const pending = new Promise<void>((resolve) => { release = resolve })
+  const pending = new Promise<void>((resolve) => {
+    release = resolve
+  })
   n.fetch.mockImplementationOnce(async () => {
     await pending
     return originalFetch()
   })
-  win.sessionStorage.setItem('libtmux:api-tree:/en/tmux/3.7c/reference/', JSON.stringify({
-    top: 240, branches: { 'bucket:args': true },
-  }))
+  win.sessionStorage.setItem(
+    'libtmux:api-tree:/en/tmux/3.7c/reference/',
+    JSON.stringify({
+      top: 240,
+      branches: { 'bucket:args': true },
+    }),
+  )
   n.initApiTree()
   expect(n.fetch).toHaveBeenCalledTimes(1)
   const row = n.bucket.querySelector<HTMLElement>('.api-nav__row')!
@@ -174,11 +241,21 @@ it('builds a lazy branch once when the reader opens it during restoration', asyn
 
 it('links contextual shortcuts without marking a second current declaration', async () => {
   const json: ApiTreeJson = {
-    port: 'julia', members: {},
-    buckets: [{ id: 'args', label: 'Server', count: 2, slug: 'entry', children: [], types: [
-      { id: 'LibTmux.sessions', name: 'sessions', slug: 'entry', kind: 'function', m: 0, shortcut: true },
-      { id: 'LibTmux.sessions', name: 'sessions', slug: 'entry', kind: 'function', m: 0 },
-    ] }],
+    port: 'julia',
+    members: {},
+    buckets: [
+      {
+        id: 'args',
+        label: 'Server',
+        count: 2,
+        slug: 'entry',
+        children: [],
+        types: [
+          { id: 'LibTmux.sessions', name: 'sessions', slug: 'entry', kind: 'function', m: 0, shortcut: true },
+          { id: 'LibTmux.sessions', name: 'sessions', slug: 'entry', kind: 'function', m: 0 },
+        ],
+      },
+    ],
   }
   const n = await navigation({ json, base: '/en/julia/latest/reference/' })
   await n.key(n.bucket, 'ArrowRight')
@@ -190,7 +267,8 @@ it('links contextual shortcuts without marking a second current declaration', as
 
 it('keeps a visible destination at the saved scroll position', async () => {
   const n = await navigation()
-  n.tree.innerHTML = '<li role="none"><a role="treeitem" class="api-nav__row" aria-current="page" href="/entry/">Entry</a></li>'
+  n.tree.innerHTML =
+    '<li role="none"><a role="treeitem" class="api-nav__row" aria-current="page" href="/entry/">Entry</a></li>'
   Object.defineProperty(n.tree, 'clientHeight', { value: 300 })
   const row = n.tree.querySelector<HTMLElement>('a')!
   vi.spyOn(n.tree, 'getBoundingClientRect').mockReturnValue(new win.DOMRect(0, 100, 100, 300))
@@ -207,7 +285,8 @@ it('does not restore a different reference tree and centers within the visible v
   n.tree.scrollTop = 240
   n.saveApiTreeState()
   n.tree.closest('.api-nav')!.setAttribute('data-base', '/en/julia/latest/reference/')
-  n.tree.innerHTML = '<li role="none"><a role="treeitem" class="api-nav__row" aria-current="page" href="/entry/">Entry</a></li>'
+  n.tree.innerHTML =
+    '<li role="none"><a role="treeitem" class="api-nav__row" aria-current="page" href="/entry/">Entry</a></li>'
   Object.defineProperty(n.tree, 'clientHeight', { value: 600 })
   Object.defineProperty(win, 'innerHeight', { value: 500 })
   const row = n.tree.querySelector<HTMLElement>('a')!
@@ -221,7 +300,8 @@ it('does not restore a different reference tree and centers within the visible v
 
 it('centers an offscreen active row on initialization without moving document focus', async () => {
   const n = await navigation()
-  n.tree.innerHTML = '<li role="none"><a role="treeitem" class="api-nav__row" aria-current="page" href="/entry/">Entry</a></li>'
+  n.tree.innerHTML =
+    '<li role="none"><a role="treeitem" class="api-nav__row" aria-current="page" href="/entry/">Entry</a></li>'
   Object.defineProperty(n.tree, 'clientHeight', { value: 300 })
   const row = n.tree.querySelector<HTMLElement>('a')!
   vi.spyOn(n.tree, 'getBoundingClientRect').mockReturnValue(new win.DOMRect(0, 100, 100, 300))
@@ -273,7 +353,9 @@ it('keeps terminal, empty-owner and legacy members as ordered leaves', async ()
   await n.key(owner, 'ArrowRight')
   const leaves = n.children(owner).slice(1)
   expect(leaves.map((item) => item.getAttribute('href'))).toEqual([
-    '/en/tmux/3.7c/reference/value/', '/en/tmux/3.7c/reference/empty/', '/en/tmux/3.7c/reference/legacy/',
+    '/en/tmux/3.7c/reference/value/',
+    '/en/tmux/3.7c/reference/empty/',
+    '/en/tmux/3.7c/reference/legacy/',
   ])
   for (const leaf of leaves) {
     expect(leaf.tagName).toBe('A')
@@ -283,7 +365,6 @@ it('keeps terminal, empty-owner and legacy members as ordered leaves', async ()
   }
 })
 
-
 it('keeps empty protocol filters disabled when search initializes and after a page swap', async () => {
   const n = await navigation({ search: true })
   const empty = win.document.createElement('button')
diff --git a/site/test/api-tree-shortcuts.test.ts b/site/test/api-tree-shortcuts.test.ts
index e50933765..22468f625 100644
--- a/site/test/api-tree-shortcuts.test.ts
+++ b/site/test/api-tree-shortcuts.test.ts
@@ -33,18 +33,38 @@ async function fixture(base = '/en/julia/latest/reference/') {
     Object.defineProperty(value, 'matches', { value: query === '(prefers-reduced-motion: reduce)' })
     return value
   })
-  const fetch = vi.fn(async () => ({ ok: true, json: async () => ({ port: 'julia', members: {}, buckets: [
-    { id: 'server', label: 'Server', count: 2, children: [], types: [
-      { id: 'Server', name: 'Server', slug: 'server', kind: 'struct', m: 0 },
-      { id: 'snapshot', name: 'snapshot', slug: 'snapshot', kind: 'function', m: 0, shortcut: true },
-    ] },
-    { id: 'snapshots', label: 'Snapshots', count: 1, children: [], types: [
-      { id: 'snapshot', name: 'snapshot', slug: 'snapshot', kind: 'function', m: 0 },
-    ] },
-  ] }) }))
+  const fetch = vi.fn(async () => ({
+    ok: true,
+    json: async () => ({
+      port: 'julia',
+      members: {},
+      buckets: [
+        {
+          id: 'server',
+          label: 'Server',
+          count: 2,
+          children: [],
+          types: [
+            { id: 'Server', name: 'Server', slug: 'server', kind: 'struct', m: 0 },
+            { id: 'snapshot', name: 'snapshot', slug: 'snapshot', kind: 'function', m: 0, shortcut: true },
+          ],
+        },
+        {
+          id: 'snapshots',
+          label: 'Snapshots',
+          count: 1,
+          children: [],
+          types: [{ id: 'snapshot', name: 'snapshot', slug: 'snapshot', kind: 'function', m: 0 }],
+        },
+      ],
+    }),
+  }))
   vi.stubGlobal('fetch', fetch)
-  const leaf = (slug: string, current = false, shortcut = false) => `<li role="none"><a role="treeitem" class="api-nav__row api-nav__leaf" href="${base}${slug}/" tabindex="${current ? 0 : -1}" ${current ? 'aria-current="page"' : ''} ${shortcut ? 'data-api-shortcut' : ''}><span class="api-nav__label">${slug}</span></a></li>`
-  const markup = (page: 'server' | 'snapshot') => `<div class="api-nav" data-base="${base}" data-src="${base}tree.json" data-version="model-v1"><ul role="tree" class="api-nav__tree">
+  const leaf = (slug: string, current = false, shortcut = false) =>
+    `<li role="none"><a role="treeitem" class="api-nav__row api-nav__leaf" href="${base}${slug}/" tabindex="${current ? 0 : -1}" ${current ? 'aria-current="page"' : ''} ${shortcut ? 'data-api-shortcut' : ''}><span class="api-nav__label">${slug}</span></a></li>`
+  const markup = (
+    page: 'server' | 'snapshot',
+  ) => `<div class="api-nav" data-base="${base}" data-src="${base}tree.json" data-version="model-v1"><ul role="tree" class="api-nav__tree">
     <li role="treeitem" data-lazy="bucket:server" aria-level="1" aria-expanded="${page === 'server'}" tabindex="-1"><div class="api-nav__row"><span class="api-nav__label">Server</span></div>${page === 'server' ? `<ul role="group">${leaf('server', true)}${leaf('snapshot', false, true)}</ul>` : ''}</li>
     <li role="treeitem" data-lazy="bucket:snapshots" aria-level="1" aria-expanded="${page === 'snapshot'}" tabindex="-1"><div class="api-nav__row"><span class="api-nav__label">Snapshots</span></div>${page === 'snapshot' ? `<ul role="group">${leaf('snapshot', true)}</ul>` : ''}</li>
   </ul></div>`
@@ -59,10 +79,14 @@ async function fixture(base = '/en/julia/latest/reference/') {
   const swap = (page: 'server' | 'snapshot', link?: HTMLElement, traverse = false) => {
     const next = win.document.implementation.createHTMLDocument()
     next.body.innerHTML = markup(page)
-    runtime.saveApiTreeState(Object.assign(new win.Event('astro:before-swap'), {
-      newDocument: next, to: new URL(`${base}${page}/`, win.location.href), sourceElement: link,
-      navigationType: traverse ? 'traverse' : 'push',
-    }) as unknown as Event)
+    runtime.saveApiTreeState(
+      Object.assign(new win.Event('astro:before-swap'), {
+        newDocument: next,
+        to: new URL(`${base}${page}/`, win.location.href),
+        sourceElement: link,
+        navigationType: traverse ? 'traverse' : 'push',
+      }) as unknown as Event,
+    )
     if (!traverse) win.history.pushState({ index: 1, scrollX: 0, scrollY: 0, other: 'next' }, '', `${base}${page}/`)
     win.document.body.innerHTML = next.body.innerHTML
     inline()
@@ -82,7 +106,11 @@ it('retains a clicked shortcut before paint, with one current row and unchanged
   expect(f.tree().querySelectorAll('[role="treeitem"][tabindex="0"]')).toHaveLength(1)
   expect(f.tree().scrollTop).toBe(73)
   expect(win.location.pathname).toBe(`${f.base}snapshot/`)
-  expect(win.history.state).toMatchObject({ index: 1, other: 'next', libtmuxApiTree: { base: f.base, path: ['bucket:server'], top: 73 } })
+  expect(win.history.state).toMatchObject({
+    index: 1,
+    other: 'next',
+    libtmuxApiTree: { base: f.base, path: ['bucket:server'], top: 73 },
+  })
   expect(f.fetch).not.toHaveBeenCalled()
 })
 
@@ -115,10 +143,14 @@ it('retains a branch shortcut activated through the tree keyboard model', async
   const original = f.tree().querySelector<HTMLElement>('a[data-api-shortcut]')!
   original.parentElement!.outerHTML = `<li role="treeitem" data-lazy="type:snapshot" aria-level="2" aria-expanded="false" tabindex="-1"><div class="api-nav__row"><a class="api-nav__label" data-api-shortcut href="${f.base}snapshot/" tabindex="-1">snapshot</a></div></li>`
   const branch = f.tree().querySelector<HTMLElement>('[data-lazy="type:snapshot"]')!
-  win.document.addEventListener('click', (event) => {
-    event.preventDefault()
-    f.swap('snapshot', event.target as HTMLElement)
-  }, { once: true })
+  win.document.addEventListener(
+    'click',
+    (event) => {
+      event.preventDefault()
+      f.swap('snapshot', event.target as HTMLElement)
+    },
+    { once: true },
+  )
   branch.focus()
   branch.dispatchEvent(new win.KeyboardEvent('keydown', { key: 'Enter', bubbles: true, cancelable: true }))
   expect(f.current()).toHaveLength(1)
@@ -141,24 +173,33 @@ it('selects canonical rows for a new direct visit or an ordinary canonical link'
   expect(f.current()[0].hasAttribute('data-api-shortcut')).toBe(false)
 })
 
-it.each(['/en/julia/latest/reference/', '/pr-24/ja/julia/v1.2.3/mcp/reference/'])('scopes shortcut context to exact base and renderer version: %s', async (base) => {
-  const f = await fixture(base)
-  f.swap('snapshot', f.tree().querySelector<HTMLElement>('a[data-api-shortcut]')!)
-  const selection = shortcutHistoryState().libtmuxApiTree
-  expect(selection.base).toBe(base)
-  for (const override of [{ version: 'model-v2' }, { base: '/en/powershell/latest/reference/' }, { href: `${base}other/` }]) {
-    win.history.replaceState({ index: 2, libtmuxApiTree: { ...selection, ...override } }, '')
-    win.document.body.innerHTML = f.markup('snapshot')
-    f.inline()
-    expect(f.current()).toHaveLength(1)
-    expect(f.current()[0].hasAttribute('data-api-shortcut')).toBe(false)
-  }
-})
+it.each(['/en/julia/latest/reference/', '/pr-24/ja/julia/v1.2.3/mcp/reference/'])(
+  'scopes shortcut context to exact base and renderer version: %s',
+  async (base) => {
+    const f = await fixture(base)
+    f.swap('snapshot', f.tree().querySelector<HTMLElement>('a[data-api-shortcut]')!)
+    const selection = shortcutHistoryState().libtmuxApiTree
+    expect(selection.base).toBe(base)
+    for (const override of [
+      { version: 'model-v2' },
+      { base: '/en/powershell/latest/reference/' },
+      { href: `${base}other/` },
+    ]) {
+      win.history.replaceState({ index: 2, libtmuxApiTree: { ...selection, ...override } }, '')
+      win.document.body.innerHTML = f.markup('snapshot')
+      f.inline()
+      expect(f.current()).toHaveLength(1)
+      expect(f.current()[0].hasAttribute('data-api-shortcut')).toBe(false)
+    }
+  },
+)
 
 it('loads the selected branch from history when session storage is unavailable', async () => {
   const f = await fixture()
   f.swap('snapshot', f.tree().querySelector<HTMLElement>('a[data-api-shortcut]')!)
-  vi.spyOn(win.sessionStorage, 'getItem').mockImplementation(() => { throw new Error('unavailable') })
+  vi.spyOn(win.sessionStorage, 'getItem').mockImplementation(() => {
+    throw new Error('unavailable')
+  })
   win.document.body.innerHTML = f.markup('snapshot')
   f.inline()
   f.runtime.initApiTree()
@@ -171,10 +212,14 @@ it('reconciles a cached shortcut before the swap module yields or its inline scr
   const f = await fixture()
   const next = win.document.implementation.createHTMLDocument()
   next.body.innerHTML = f.markup('snapshot')
-  f.runtime.saveApiTreeState(Object.assign(new win.Event('astro:before-swap'), { newDocument: next,
-    to: new URL(`${f.base}snapshot/`, win.location.href), navigationType: 'push',
-    sourceElement: f.tree().querySelector('a[data-api-shortcut]'),
-  }) as unknown as Event)
+  f.runtime.saveApiTreeState(
+    Object.assign(new win.Event('astro:before-swap'), {
+      newDocument: next,
+      to: new URL(`${f.base}snapshot/`, win.location.href),
+      navigationType: 'push',
+      sourceElement: f.tree().querySelector('a[data-api-shortcut]'),
+    }) as unknown as Event,
+  )
   win.history.pushState({ index: 1 }, '', `${f.base}snapshot/`)
   win.document.body.innerHTML = next.body.innerHTML
   f.runtime.initApiTree()
@@ -209,10 +254,15 @@ it('rejects saved rows from the renderer that did not serialize shortcut identit
   win.history.pushState({ index: 1 }, '', `${f.base}snapshot/`)
   win.document.body.innerHTML = f.markup('snapshot')
   win.document.querySelector<HTMLElement>('.api-nav')!.dataset.version = version
-  win.sessionStorage.setItem(`libtmux:api-tree:${f.base}`, JSON.stringify({
-    version: oldVersion, top: 0, branches: { 'bucket:server': true },
-    groups: { 'bucket:server': [{ label: ['old unmarked snapshot'], href: `${f.base}snapshot/`, kind: 'function' }] },
-  }))
+  win.sessionStorage.setItem(
+    `libtmux:api-tree:${f.base}`,
+    JSON.stringify({
+      version: oldVersion,
+      top: 0,
+      branches: { 'bucket:server': true },
+      groups: { 'bucket:server': [{ label: ['old unmarked snapshot'], href: `${f.base}snapshot/`, kind: 'function' }] },
+    }),
+  )
   f.inline()
   expect(f.tree().textContent).not.toContain('old unmarked snapshot')
   f.runtime.initApiTree()
@@ -225,8 +275,12 @@ it('rejects saved rows from the renderer that did not serialize shortcut identit
 
 it('keeps the canonical page usable when history or storage is unavailable', async () => {
   const f = await fixture()
-  vi.spyOn(win.sessionStorage, 'getItem').mockImplementation(() => { throw new Error('unavailable') })
-  vi.spyOn(win.history, 'replaceState').mockImplementation(() => { throw new Error('unavailable') })
+  vi.spyOn(win.sessionStorage, 'getItem').mockImplementation(() => {
+    throw new Error('unavailable')
+  })
+  vi.spyOn(win.history, 'replaceState').mockImplementation(() => {
+    throw new Error('unavailable')
+  })
   f.swap('snapshot', f.tree().querySelector<HTMLElement>('a[data-api-shortcut]')!)
   expect(f.current()).toHaveLength(1)
   expect(f.current()[0].getAttribute('href')).toBe(`${f.base}snapshot/`)
diff --git a/site/test/api-tree.test.ts b/site/test/api-tree.test.ts
index 8222da509..beba7afe9 100644
--- a/site/test/api-tree.test.ts
+++ b/site/test/api-tree.test.ts
@@ -4,7 +4,14 @@ import { describe, expect, it, vi } from 'vitest'
 import { compareMembers, membersOf, memberSignals } from '@libtmux/api-model'
 import mentions from '../src/data/mentions.json'
 import { API_MODELS, API_NAV, OWNER_KINDS, topLevelTypesOf } from '../src/lib/api-models'
-import { bucketForSymbol, firstEntry, membersByType, navTree, referenceNavigation, referenceIndexSections } from '../src/lib/api-tree'
+import {
+  bucketForSymbol,
+  firstEntry,
+  membersByType,
+  navTree,
+  referenceNavigation,
+  referenceIndexSections,
+} from '../src/lib/api-tree'
 import { API_MODEL_PORTS } from '../src/lib/ports'
 import type { ApiTreeBucket, ApiTreeJson } from '../src/lib/api-search'
 import { GET as referenceTreeRoute } from '../src/pages/reference/tree.json'
@@ -27,8 +34,10 @@ describe('active API sidebar category', () => {
   })
 
   it.each([
-    ['Connect-TmuxServer', 'server'], ['Get-TmuxPane', 'pane'],
-    ['Get-TmuxClient', 'client'], ['Connect-TmuxControl', 'control'],
+    ['Connect-TmuxServer', 'server'],
+    ['Get-TmuxPane', 'pane'],
+    ['Get-TmuxClient', 'client'],
+    ['Connect-TmuxControl', 'control'],
   ])('opens %s in %s instead of its parent module under Other', (name, expected) => {
     const model = API_MODELS.powershell
     const symbol = model.symbols.find((item) => item.name === name)!
@@ -87,20 +96,29 @@ describe('shared reference index sections', () => {
   it.each(PORTS)('leads the %s index and exports with the primary server', (port) => {
     const sections = referenceIndexSections(port)
     expect(sections[0].id).toBe('server')
-    if (port === 'powershell') expect(sections[0].free.map((symbol) => symbol.name))
-      .toEqual(expect.arrayContaining(['Connect-TmuxServer', 'Get-TmuxServer', 'New-TmuxServer']))
+    if (port === 'powershell')
+      expect(sections[0].free.map((symbol) => symbol.name)).toEqual(
+        expect.arrayContaining(['Connect-TmuxServer', 'Get-TmuxServer', 'New-TmuxServer']),
+      )
     else expect(sections[0].types[0].name).toBe('Server')
     const ids = sections.flatMap((section) => [...section.types, ...section.free]).map((symbol) => symbol.id)
     expect(new Set(ids).size).toBe(ids.length)
     const available = new Set(sections.map((section) => section.id))
-    expect(sections.map((section) => section.id).filter((id) => PRIMARY_OBJECT_BUCKETS.has(id)))
-      .toEqual([...PRIMARY_OBJECT_BUCKETS].filter((id) => available.has(id)))
+    expect(sections.map((section) => section.id).filter((id) => PRIMARY_OBJECT_BUCKETS.has(id))).toEqual(
+      [...PRIMARY_OBJECT_BUCKETS].filter((id) => available.has(id)),
+    )
   })
 
   it('lists every core PowerShell cmdlet under its module without workspace-only commands', () => {
-    const expected = API_MODELS.powershell.symbols.filter((symbol) => symbol.command && symbol.product === 'core').map((symbol) => symbol.id).sort()
-    const listed = referenceIndexSections('powershell').flatMap((section) => [...section.types, ...section.free])
-      .filter((symbol) => symbol.command).map((symbol) => symbol.id).sort()
+    const expected = API_MODELS.powershell.symbols
+      .filter((symbol) => symbol.command && symbol.product === 'core')
+      .map((symbol) => symbol.id)
+      .sort()
+    const listed = referenceIndexSections('powershell')
+      .flatMap((section) => [...section.types, ...section.free])
+      .filter((symbol) => symbol.command)
+      .map((symbol) => symbol.id)
+      .sort()
     expect(expected).toHaveLength(55)
     expect(listed).toEqual(expected)
   })
@@ -110,12 +128,20 @@ describe('core reference inventory', () => {
   it.each(PORTS)('publishes every reachable %s core declaration without product-only records', async (port) => {
     const navigation = referenceNavigation(port)!
     const model = navigation.model
-    const core = model.symbols.filter((symbol) =>
-      !['mcp', 'workspace'].includes(symbol.product ?? 'core') || symbol.apiScope === 'internal')
+    const core = model.symbols.filter(
+      (symbol) => !['mcp', 'workspace'].includes(symbol.product ?? 'core') || symbol.apiScope === 'internal',
+    )
     const coreIds = new Set(core.map((symbol) => symbol.id))
     const expected = [...coreIds].sort()
-    const identities = new Map(model.symbols.flatMap((symbol) =>
-      [[symbol.id, symbol.id], [symbol.publicId ?? symbol.id, symbol.id]] as const))
+    const identities = new Map(
+      model.symbols.flatMap(
+        (symbol) =>
+          [
+            [symbol.id, symbol.id],
+            [symbol.publicId ?? symbol.id, symbol.id],
+          ] as const,
+      ),
+    )
     const allMembers = navigation.members
     const before = structuredClone([...membersByType(port)])
     vi.stubEnv('LIBTMUX_DOCS_PORT', port)
@@ -127,9 +153,12 @@ describe('core reference inventory', () => {
     } finally {
       vi.unstubAllEnvs()
     }
-    const roots = (buckets: ApiTreeBucket[]): string[] => buckets.flatMap((bucket) =>
-      [...bucket.types.map((entry) => entry.id), ...roots(bucket.children)])
-    const listed = [...roots(tree.buckets), ...Object.values(tree.members).flatMap((rows) => rows.map((row) => row[2]!))]
+    const roots = (buckets: ApiTreeBucket[]): string[] =>
+      buckets.flatMap((bucket) => [...bucket.types.map((entry) => entry.id), ...roots(bucket.children)])
+    const listed = [
+      ...roots(tree.buckets),
+      ...Object.values(tree.members).flatMap((rows) => rows.map((row) => row[2]!)),
+    ]
     expect([...new Set(listed.map((id) => identities.get(id) ?? id))].sort()).toEqual(expected)
     const reachable = new Set<string>()
     const visit = (id: string) => {
@@ -141,9 +170,12 @@ describe('core reference inventory', () => {
     expect([...new Set([...reachable].map((id) => identities.get(id) ?? id))].sort()).toEqual(expected)
     for (const [owner, rows] of Object.entries(tree.members)) {
       expect(reachable.has(owner), `${port}: orphan owner ${owner}`).toBe(true)
-      expect(rows.map((row) => row.slice(0, 3))).toEqual(allMembers.get(owner)!
-        .filter((member) => coreIds.has(member.id))
-        .map((member) => [member.name, member.slug, member.id]))
+      expect(rows.map((row) => row.slice(0, 3))).toEqual(
+        allMembers
+          .get(owner)!
+          .filter((member) => coreIds.has(member.id))
+          .map((member) => [member.name, member.slug, member.id]),
+      )
     }
     expect([...membersByType(port)]).toEqual(before)
   })
@@ -153,17 +185,28 @@ describe('major tmux object domains', () => {
   it('exposes Julia snapshot discovery in Server without inventing Server methods', () => {
     const server = navTree('julia').find((bucket) => bucket.id === 'server')!
     expect(server.entries.slice(0, 6).map((entry) => entry.name)).toEqual([
-      'Server', 'snapshot', 'sessions', 'windows', 'panes', 'clients',
+      'Server',
+      'snapshot',
+      'sessions',
+      'windows',
+      'panes',
+      'clients',
     ])
     expect(API_NAV.julia.placement['LibTmux.sessions']).toBe('session')
-    expect(membersByType('julia').get('LibTmux.Server')?.map((member) => member.name))
-      .not.toContain('sessions')
+    expect(
+      membersByType('julia')
+        .get('LibTmux.Server')
+        ?.map((member) => member.name),
+    ).not.toContain('sessions')
     const sections = referenceIndexSections('julia')
     for (const name of ['sessions', 'windows', 'panes', 'clients']) {
-      const entries = sections.flatMap((section) => [...section.types, ...section.free])
+      const entries = sections
+        .flatMap((section) => [...section.types, ...section.free])
         .filter((symbol) => symbol.id === `LibTmux.${name}`)
       expect(entries, name).toHaveLength(1)
-      expect(entries[0].signatures.some((signature) => signature.params.some((param) => param.type === 'LibTmux.Snapshot'))).toBe(true)
+      expect(
+        entries[0].signatures.some((signature) => signature.params.some((param) => param.type === 'LibTmux.Snapshot')),
+      ).toBe(true)
     }
   })
 
@@ -174,17 +217,54 @@ describe('major tmux object domains', () => {
     ['client', ['clients', 'switch_client', 'detach_client']],
   ])('puts Julia %s operations before supporting identities and predicates', (id, names) => {
     const bucket = navTree('julia').find((bucket) => bucket.id === id)!
-    expect(bucket.entries.slice(0, names.length).map((entry) => entry.name))
-      .toEqual(names)
+    expect(bucket.entries.slice(0, names.length).map((entry) => entry.name)).toEqual(names)
     expect(firstEntry(bucket)?.name).toBe(names[0])
   })
 
   it.each([
     ['server', ['New-TmuxServer', 'Get-TmuxServer', 'Connect-TmuxServer']],
-    ['session', ['Get-TmuxSession', 'Select-TmuxSession', 'New-TmuxSession', 'Enter-TmuxSession', 'Remove-TmuxSession']],
-    ['window', ['Get-TmuxWindow', 'Select-TmuxWindow', 'New-TmuxWindow', 'New-TmuxWindowLink', 'Set-TmuxWindowSize', 'Move-TmuxWindow', 'Remove-TmuxWindowLink', 'Remove-TmuxWindow']],
-    ['pane', ['Get-TmuxPane', 'Select-TmuxPane', 'Get-TmuxPaneContent', 'Split-TmuxPane', 'Send-TmuxText', 'Invoke-TmuxPaneCommand', 'Wait-TmuxPaneText', 'Update-TmuxPane', 'Set-TmuxPaneSize', 'Remove-TmuxPane']],
-    ['control', ['Connect-TmuxControl', 'Watch-TmuxEvent', 'Wait-TmuxChannel', 'Invoke-TmuxControlCommand', 'Disconnect-TmuxControl']],
+    [
+      'session',
+      ['Get-TmuxSession', 'Select-TmuxSession', 'New-TmuxSession', 'Enter-TmuxSession', 'Remove-TmuxSession'],
+    ],
+    [
+      'window',
+      [
+        'Get-TmuxWindow',
+        'Select-TmuxWindow',
+        'New-TmuxWindow',
+        'New-TmuxWindowLink',
+        'Set-TmuxWindowSize',
+        'Move-TmuxWindow',
+        'Remove-TmuxWindowLink',
+        'Remove-TmuxWindow',
+      ],
+    ],
+    [
+      'pane',
+      [
+        'Get-TmuxPane',
+        'Select-TmuxPane',
+        'Get-TmuxPaneContent',
+        'Split-TmuxPane',
+        'Send-TmuxText',
+        'Invoke-TmuxPaneCommand',
+        'Wait-TmuxPaneText',
+        'Update-TmuxPane',
+        'Set-TmuxPaneSize',
+        'Remove-TmuxPane',
+      ],
+    ],
+    [
+      'control',
+      [
+        'Connect-TmuxControl',
+        'Watch-TmuxEvent',
+        'Wait-TmuxChannel',
+        'Invoke-TmuxControlCommand',
+        'Disconnect-TmuxControl',
+      ],
+    ],
   ])('orders PowerShell %s cmdlets around reading, selection, work and teardown', (id, names) => {
     const bucket = navTree('powershell').find((bucket) => bucket.id === id)!
     expect(bucket.entries.map((entry) => entry.name)).toEqual(names)
@@ -192,14 +272,28 @@ describe('major tmux object domains', () => {
   })
 
   it('puts Kotlin handles before builders and Rust Server before helpers', () => {
-    for (const [port, bucket, name] of [['rs', 'server', 'Server'], ['kotlin', 'session', 'Session'], ['kotlin', 'window', 'Window']]) {
+    for (const [port, bucket, name] of [
+      ['rs', 'server', 'Server'],
+      ['kotlin', 'session', 'Session'],
+      ['kotlin', 'window', 'Window'],
+    ]) {
       expect(navTree(port).find((entry) => entry.id === bucket)?.entries[0].name).toBe(name)
     }
-    expect(navTree('rs').find((entry) => entry.id === 'server')?.entries.some((entry) => entry.name.startsWith('__fuzz_'))).toBe(false)
-    expect(navTree('rs').find((entry) => entry.id === 'internal')?.entries.some((entry) => entry.name.startsWith('__fuzz_'))).toBe(true)
+    expect(
+      navTree('rs')
+        .find((entry) => entry.id === 'server')
+        ?.entries.some((entry) => entry.name.startsWith('__fuzz_')),
+    ).toBe(false)
+    expect(
+      navTree('rs')
+        .find((entry) => entry.id === 'internal')
+        ?.entries.some((entry) => entry.name.startsWith('__fuzz_')),
+    ).toBe(true)
   })
   it('distinguishes Scala variants without long package labels', () => {
-    const names = navTree('scala').find((entry) => entry.id === 'window')!.entries.map((entry) => entry.name)
+    const names = navTree('scala')
+      .find((entry) => entry.id === 'window')!
+      .entries.map((entry) => entry.name)
     expect(names).toContain('Window (Direct API)')
     expect(names).toContain('Window (Cats Effect)')
   })
@@ -211,22 +305,33 @@ describe('major tmux object domains', () => {
     const model = API_MODELS[port]!
     const branches = membersByType(port)
     const compare = compareMembers(memberSignals(port, mentions.mentions))
-    const owners = model.symbols.filter((symbol) => port === 'powershell'
-      ? symbol.kind === 'module'
-      : OWNER_KINDS.has(symbol.kind) && ['Server', 'Session', 'Window', 'Pane', 'Client', 'Snapshot'].includes(symbol.name))
-    if (port === 'powershell') expect(owners.map((owner) => owner.name).sort()).toEqual(['LibTmux', 'LibTmux.Workspace'])
-    else expect(owners.some((owner) => owner.name === 'Server'), port).toBe(true)
+    const owners = model.symbols.filter((symbol) =>
+      port === 'powershell'
+        ? symbol.kind === 'module'
+        : OWNER_KINDS.has(symbol.kind) &&
+          ['Server', 'Session', 'Window', 'Pane', 'Client', 'Snapshot'].includes(symbol.name),
+    )
+    if (port === 'powershell')
+      expect(owners.map((owner) => owner.name).sort()).toEqual(['LibTmux', 'LibTmux.Workspace'])
+    else
+      expect(
+        owners.some((owner) => owner.name === 'Server'),
+        port,
+      ).toBe(true)
     for (const owner of owners) {
       const displayed = membersOf(model, owner, memberSignals(port, mentions.mentions)).sort(compare)
-      expect(branches.get(owner.publicId ?? owner.id)?.map((member) => member.id) ?? [], `${port}:${owner.id}`)
-        .toEqual(displayed.map((member) => member.id))
+      expect(branches.get(owner.publicId ?? owner.id)?.map((member) => member.id) ?? [], `${port}:${owner.id}`).toEqual(
+        displayed.map((member) => member.id),
+      )
     }
   })
   it.each(['kotlin', 'scala', 'ts'])('puts %s listings first in lazily expanded branches', (port) => {
     const servers = API_MODELS[port]!.symbols.filter((symbol) => symbol.name === 'Server' && !symbol.parent)
     expect(servers.length).toBeGreaterThan(0)
     for (const server of servers) {
-      const names = membersByType(port).get(server.publicId ?? server.id)!.map((member) => member.name)
+      const names = membersByType(port)
+        .get(server.publicId ?? server.id)!
+        .map((member) => member.name)
       for (const listing of ['sessions', 'windows', 'panes', 'clients']) {
         expect(names.indexOf(listing), `${server.id}.${listing}`).toBeGreaterThanOrEqual(0)
         expect(names.indexOf(listing), `${server.id}.${listing}`).toBeLessThan(names.indexOf('newSession'))
@@ -238,7 +343,10 @@ describe('major tmux object domains', () => {
     for (const port of PORTS) {
       for (const bucket of navTree(port).filter((candidate) => PRIMARY_OBJECT_BUCKETS.has(candidate.id))) {
         const primary = bucket.entries
-          .filter((entry) => OWNER_KINDS.has(entry.kind) && segments(entry.id).at(-1)?.toLowerCase() === bucket.label.toLowerCase())
+          .filter(
+            (entry) =>
+              OWNER_KINDS.has(entry.kind) && segments(entry.id).at(-1)?.toLowerCase() === bucket.label.toLowerCase(),
+          )
           .toSorted((left, right) => segments(left.id).length - segments(right.id).length)[0]
 
         if (primary) expect(bucket.entries[0]?.id, `${port}:${bucket.id}`).toBe(primary.id)
@@ -263,32 +371,47 @@ describe.skipIf(!SITE_BUILT)('rendered reference ordering', () => {
         const cardIds = new Set(topLevelTypesOf(API_MODELS[port]!).map((symbol) => symbol.publicId ?? symbol.id))
         for (const bucket of tree) {
           const section = template.content.getElementById(`section-${bucket.id}`)?.closest('details')
-          const cards = [...section?.querySelectorAll('.api-index-card__link') ?? []]
-            .map((link) => new URL(link.getAttribute('href')!, 'https://libtmux.org').pathname.split('/').filter(Boolean).at(-1))
+          const cards = [...(section?.querySelectorAll('.api-index-card__link') ?? [])].map((link) =>
+            new URL(link.getAttribute('href')!, 'https://libtmux.org').pathname.split('/').filter(Boolean).at(-1),
+          )
           const types = bucket.entries.filter((entry) => !entry.shortcut && cardIds.has(entry.id))
           const free = bucket.entries.filter((entry) => !entry.shortcut && !cardIds.has(entry.id))
           expect(cards, `${port}/${version}:${bucket.id}`).toEqual([...types, ...free].map((entry) => entry.slug))
-          const declarations = [...section?.querySelectorAll(':scope > div > dl > dt[id]') ?? []]
-            .map((entry) => entry.id)
-          expect(declarations, `${port}/${version}:${bucket.id} inline declarations`)
-            .toEqual([])
+          const declarations = [...(section?.querySelectorAll(':scope > div > dl > dt[id]') ?? [])].map(
+            (entry) => entry.id,
+          )
+          expect(declarations, `${port}/${version}:${bucket.id} inline declarations`).toEqual([])
           for (const entry of free) {
-            expect(template.content.getElementById(entry.id)?.querySelector('.api-index-card__link')?.getAttribute('href'),
-              `${port}/${version}:${entry.id} retains its index fragment`).toContain(`/${entry.slug}/`)
+            expect(
+              template.content.getElementById(entry.id)?.querySelector('.api-index-card__link')?.getAttribute('href'),
+              `${port}/${version}:${entry.id} retains its index fragment`,
+            ).toContain(`/${entry.slug}/`)
           }
-          expect(lazy.buckets.find((entry: { id: string }) => entry.id === bucket.id)?.types.map((entry: { id: string }) => entry.id))
-            .toEqual(navigation.tree.find((entry) => entry.id === bucket.id)!.entries.map((entry) => entry.id))
+          expect(
+            lazy.buckets
+              .find((entry: { id: string }) => entry.id === bucket.id)
+              ?.types.map((entry: { id: string }) => entry.id),
+          ).toEqual(navigation.tree.find((entry) => entry.id === bucket.id)!.entries.map((entry) => entry.id))
         }
-        const coreIds = new Set(navigation.model.symbols.filter((symbol) =>
-          !['mcp', 'workspace'].includes(symbol.product ?? 'core') || symbol.apiScope === 'internal')
-          .flatMap((symbol) => [symbol.id, symbol.publicId ?? symbol.id]))
-        const coreMembers = [...navigation.members].filter(([owner]) => coreIds.has(owner))
+        const coreIds = new Set(
+          navigation.model.symbols
+            .filter(
+              (symbol) => !['mcp', 'workspace'].includes(symbol.product ?? 'core') || symbol.apiScope === 'internal',
+            )
+            .flatMap((symbol) => [symbol.id, symbol.publicId ?? symbol.id]),
+        )
+        const coreMembers = [...navigation.members]
+          .filter(([owner]) => coreIds.has(owner))
           .map(([owner, members]) => [owner, members.filter((member) => coreIds.has(member.id))] as const)
           .filter(([, members]) => members.length)
-        expect(Object.keys(lazy.members), `${port}/${version}: core owner keys`).toEqual(coreMembers.map(([owner]) => owner))
+        expect(Object.keys(lazy.members), `${port}/${version}: core owner keys`).toEqual(
+          coreMembers.map(([owner]) => owner),
+        )
         for (const [owner, members] of coreMembers) {
-          expect(lazy.members[owner]?.map((member: string[]) => member.slice(0, 2)), `${port}/${version}:${owner}`)
-            .toEqual(members.map((member) => [member.name, member.slug]))
+          expect(
+            lazy.members[owner]?.map((member: string[]) => member.slice(0, 2)),
+            `${port}/${version}:${owner}`,
+          ).toEqual(members.map((member) => [member.name, member.slug]))
         }
       } finally {
         window.happyDOM.abort()
diff --git a/site/test/branding.test.ts b/site/test/branding.test.ts
index eed4f2b27..dbd090910 100644
--- a/site/test/branding.test.ts
+++ b/site/test/branding.test.ts
@@ -8,29 +8,44 @@ import { nativeBrandHead } from '../../scripts/brand-native-pages.mjs'
 
 const publicFile = (path: string) => fileURLToPath(new URL(`../public${path}`, import.meta.url))
 const luminance = (hex: string) => {
-  const c = [1, 3, 5].map((n) => Number.parseInt(hex.slice(n, n + 2), 16) / 255)
-    .map((x) => x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4)
-  return c[0]! * .2126 + c[1]! * .7152 + c[2]! * .0722
+  const c = [1, 3, 5]
+    .map((n) => Number.parseInt(hex.slice(n, n + 2), 16) / 255)
+    .map((x) => (x <= 0.04045 ? x / 12.92 : ((x + 0.055) / 1.055) ** 2.4))
+  return c[0]! * 0.2126 + c[1]! * 0.7152 + c[2]! * 0.0722
 }
 const contrast = (a: string, b: string) => {
   const [hi, lo] = [luminance(a), luminance(b)].sort((x, y) => y - x)
-  return (hi! + .05) / (lo! + .05)
+  return (hi! + 0.05) / (lo! + 0.05)
 }
 
 describe('route branding', () => {
   it('identifies tmux pages by their section and hosting site', () => {
-    expect(tmuxDocumentationTitle('Getting started', 'tmux/guides/getting-started')).toBe('Getting started | Guides | tmux | libtmux.org')
+    expect(tmuxDocumentationTitle('Getting started', 'tmux/guides/getting-started')).toBe(
+      'Getting started | Guides | tmux | libtmux.org',
+    )
     expect(tmuxDocumentationTitle('Guides', 'tmux/guides')).toBe('Guides | tmux | libtmux.org')
-    expect(tmuxDocumentationTitle('capture-pane', 'tmux/3.7c/manual/capture-pane')).toBe('capture-pane | Manual | tmux | libtmux.org')
+    expect(tmuxDocumentationTitle('capture-pane', 'tmux/3.7c/manual/capture-pane')).toBe(
+      'capture-pane | Manual | tmux | libtmux.org',
+    )
     expect(tmuxDocumentationTitle('tmux', 'tmux')).toBe('tmux | libtmux.org')
   })
   it('uses project titles independently of package names and shared source repositories', () => {
     const names = {
-      py: 'libtmux', ruby: 'libtmux-ruby', lua: 'libtmux-lua', ts: 'libtmux-ts',
-      powershell: 'libtmux-powershell', julia: 'LibTmux.jl',
-      rs: 'libtmux-rs', go: 'libtmux-go', java: 'libtmux-java', kotlin: 'libtmux-kotlin',
-      scala: 'libtmux-scala', csharp: 'libtmux-dotnet', fsharp: 'libtmux-fsharp',
-      cxx: 'libtmux-cxx', swift: 'libtmux-swift',
+      py: 'libtmux',
+      ruby: 'libtmux-ruby',
+      lua: 'libtmux-lua',
+      ts: 'libtmux-ts',
+      powershell: 'libtmux-powershell',
+      julia: 'LibTmux.jl',
+      rs: 'libtmux-rs',
+      go: 'libtmux-go',
+      java: 'libtmux-java',
+      kotlin: 'libtmux-kotlin',
+      scala: 'libtmux-scala',
+      csharp: 'libtmux-dotnet',
+      fsharp: 'libtmux-fsharp',
+      cxx: 'libtmux-cxx',
+      swift: 'libtmux-swift',
     }
     expect(Object.fromEntries(PORTS.map((port) => [port.slug, branding(port.slug).projectName]))).toEqual(names)
     expect(branding('java', 'reference/libtmux-scala-cats').projectName).toBe('libtmux-scala')
@@ -72,31 +87,48 @@ describe('route branding', () => {
     expect(pageBrand(undefined, 'mcp/').variant).toBe('mcp')
   })
   it('keeps preview and locale prefixes on all artwork URLs', () => {
-    expect(branding('rs', 'workspace/', '/pr-42/ja/').asset('logo.svg'))
-      .toBe('/pr-42/ja/brand/rust/workspace/logo.svg')
+    expect(branding('rs', 'workspace/', '/pr-42/ja/').asset('logo.svg')).toBe('/pr-42/ja/brand/rust/workspace/logo.svg')
   })
   it('ships raster and vector fallbacks for every port and product', () => {
-    for (const port of PORTS) for (const product of ['', 'mcp/', 'workspace/']) {
-      const brand = branding(port.slug, product)
-      for (const file of ['logo.svg', 'favicon.ico', 'logo-32.png', 'logo-512.png', 'apple-touch-icon-light.png', 'opengraph-light.png', 'twitter-light.png', 'site.webmanifest']) {
-        expect(existsSync(publicFile(brand.asset(file))), brand.asset(file)).toBe(true)
+    for (const port of PORTS)
+      for (const product of ['', 'mcp/', 'workspace/']) {
+        const brand = branding(port.slug, product)
+        for (const file of [
+          'logo.svg',
+          'favicon.ico',
+          'logo-32.png',
+          'logo-512.png',
+          'apple-touch-icon-light.png',
+          'opengraph-light.png',
+          'twitter-light.png',
+          'site.webmanifest',
+        ]) {
+          expect(existsSync(publicFile(brand.asset(file))), brand.asset(file)).toBe(true)
+        }
+        const png = readFileSync(publicFile(brand.asset('opengraph-light.png')))
+        expect([png.readUInt32BE(16), png.readUInt32BE(20)]).toEqual([1200, 630])
+        const manifest = JSON.parse(readFileSync(publicFile(brand.asset('site.webmanifest')), 'utf8'))
+        for (const icon of manifest.icons) {
+          expect(existsSync(publicFile(brand.asset(icon.src))), icon.src).toBe(true)
+        }
       }
-      const png = readFileSync(publicFile(brand.asset('opengraph-light.png')))
-      expect([png.readUInt32BE(16), png.readUInt32BE(20)]).toEqual([1200, 630])
-      const manifest = JSON.parse(readFileSync(publicFile(brand.asset('site.webmanifest')), 'utf8'))
-      for (const icon of manifest.icons) {
-        expect(existsSync(publicFile(brand.asset(icon.src))), icon.src).toBe(true)
-      }
-    }
   })
   it('keeps text and links readable on light and dark surfaces', () => {
-    for (const [language, palette] of Object.entries(palettes)) for (const mode of ['light', 'dark'] as const) {
-      expect(palette[mode].onSolid).toBe('#ffffff')
-      expect(contrast(palette[mode].solid, palette[mode].onSolid), `${language} ${mode} filled surface`).toBeGreaterThanOrEqual(4.5)
-      for (const foreground of ['text', 'muted', 'link'] as const) for (const background of ['background', 'surface', 'hover'] as const) {
-        expect(contrast(palette[mode][foreground], palette[mode][background]), `${language} ${mode} ${foreground}/${background}`).toBeGreaterThanOrEqual(4.5)
+    for (const [language, palette] of Object.entries(palettes))
+      for (const mode of ['light', 'dark'] as const) {
+        expect(palette[mode].onSolid).toBe('#ffffff')
+        expect(
+          contrast(palette[mode].solid, palette[mode].onSolid),
+          `${language} ${mode} filled surface`,
+        ).toBeGreaterThanOrEqual(4.5)
+        for (const foreground of ['text', 'muted', 'link'] as const)
+          for (const background of ['background', 'surface', 'hover'] as const) {
+            expect(
+              contrast(palette[mode][foreground], palette[mode][background]),
+              `${language} ${mode} ${foreground}/${background}`,
+            ).toBeGreaterThanOrEqual(4.5)
+          }
       }
-    }
   })
   it.each(['light', 'dark'] as const)('keeps %s surfaces and body text neutral across languages', (mode) => {
     for (const role of ['background', 'surface', 'hover', 'border', 'text', 'muted'] as const) {
@@ -128,7 +160,8 @@ describe('native metadata', () => {
   })
 
   it.each(PORTS)('normalizes $slug page and social titles without changing canonical policy', (port) => {
-    const source = '<html><head><title>Server &amp; &quot;Clients&quot; | libtmux</title><meta property="og:title" content="Old"><meta property="og:site_name" content="libtmux"><meta name="twitter:title" content="Old"><link rel="canonical" href="https://libtmux.org/unchanged/"><meta name="robots" content="noindex, follow"></head><body>Server</body></html>'
+    const source =
+      '<html><head><title>Server &amp; &quot;Clients&quot; | libtmux</title><meta property="og:title" content="Old"><meta property="og:site_name" content="libtmux"><meta name="twitter:title" content="Old"><link rel="canonical" href="https://libtmux.org/unchanged/"><meta name="robots" content="noindex, follow"></head><body>Server</body></html>'
     const options = { port: port.slug, pagePath: 'reference/server/', root: '/en' }
     const html = nativeBrandHead(source, options)
     const title = `Server &amp; &quot;Clients&quot; | ${port.projectName}`
@@ -144,7 +177,8 @@ describe('native metadata', () => {
     expect(nativeBrandHead(html, options)).toBe(html)
   })
   it('uses current artwork for both native sidebar schemes without changing content images', () => {
-    const source = '<html><head></head><body><img class="sidebar-logo only-light" src="old-light.svg"><img src="old-dark.svg" class="only-dark sidebar-logo" srcset="old-dark@2x.png 2x"/><img src="guide.png" alt="Example"></body></html>'
+    const source =
+      '<html><head></head><body><img class="sidebar-logo only-light" src="old-light.svg"><img src="old-dark.svg" class="only-dark sidebar-logo" srcset="old-dark@2x.png 2x"/><img src="guide.png" alt="Example"></body></html>'
     const options = { port: 'py', pagePath: 'api/server/', root: '/pr-42/en' }
     const html = nativeBrandHead(source, options)
     expect(html.match(/src="\/pr-42\/en\/brand\/python\/library\/logo.svg"/g)).toHaveLength(2)
@@ -153,7 +187,8 @@ describe('native metadata', () => {
     expect(nativeBrandHead(html, options)).toBe(html)
   })
   it('replaces legacy image tags, preserves policy, and is idempotent', () => {
-    const source = '<html lang="en"><head><title>Server</title><link rel="canonical" href="https://libtmux.org/en/py/stable/api/server/"><meta name="robots" content="noindex, follow"><link rel="icon" href="old.ico"><meta property="og:image" content="old.png"></head><body>Server API</body></html>'
+    const source =
+      '<html lang="en"><head><title>Server</title><link rel="canonical" href="https://libtmux.org/en/py/stable/api/server/"><meta name="robots" content="noindex, follow"><link rel="icon" href="old.ico"><meta property="og:image" content="old.png"></head><body>Server API</body></html>'
     const options = { port: 'py', pagePath: 'api/server/', root: '/pr-42/en' }
     const html = nativeBrandHead(source, options)
     expect(html).toContain('data-brand="python"')
diff --git a/site/test/browse-cards.test.ts b/site/test/browse-cards.test.ts
index e023c9599..682a240de 100644
--- a/site/test/browse-cards.test.ts
+++ b/site/test/browse-cards.test.ts
@@ -10,15 +10,18 @@ interface Card {
   ports?: string[]
 }
 
-const index = (section: string) => parseFrontmatter(readFileSync(
-  new URL(`../src/content/docs/${section}/index.md`, import.meta.url), 'utf8'),
-  { frontmatter: 'remove' })
-const cards = (section: string, port?: string) =>
-  selectPortCards(index(section).frontmatter.cards as Card[], port)
+const index = (section: string) =>
+  parseFrontmatter(readFileSync(new URL(`../src/content/docs/${section}/index.md`, import.meta.url), 'utf8'), {
+    frontmatter: 'remove',
+  })
+const cards = (section: string, port?: string) => selectPortCards(index(section).frontmatter.cards as Card[], port)
 
 describe('shared browse cards', () => {
   it.each([
-    ['guides', 6], ['concepts', 4], ['topics', 10], ['examples', 3],
+    ['guides', 6],
+    ['concepts', 4],
+    ['topics', 10],
+    ['examples', 3],
   ] as const)('keeps the %s destinations in shared and native version mounts', (section, count) => {
     const shared = cards(section)
     expect(shared).toHaveLength(count)
@@ -27,15 +30,15 @@ describe('shared browse cards', () => {
       const selected = cards(section, port)
       if (section === 'guides' && port === 'rs') {
         expect(selected.filter((card) => shared.some((item) => item.href === card.href))).toEqual(shared)
-        expect(selected.filter((card) => !shared.some((item) => item.href === card.href))
-          .map((card) => card.href)).toEqual(['batching-commands/', 'control-mode/'])
+        expect(
+          selected.filter((card) => !shared.some((item) => item.href === card.href)).map((card) => card.href),
+        ).toEqual(['batching-commands/', 'control-mode/'])
         expect(selected).toHaveLength(count + 2)
       } else expect(selected).toEqual(shared)
       for (const version of ['latest', 'stable', 'v0.1']) {
         const base = `https://libtmux.org/pr-42/en/${port}/${version}/${section}/`
         for (const card of selected) {
-          expect(new URL(card.href, base).pathname)
-            .toBe(`/pr-42/en/${port}/${version}/${section}/${card.href}`)
+          expect(new URL(card.href, base).pathname).toBe(`/pr-42/en/${port}/${version}/${section}/${card.href}`)
         }
       }
     }
@@ -44,9 +47,7 @@ describe('shared browse cards', () => {
 
   it.each(['ruby', 'lua'])('offers only covered concepts and native guides for %s', (port) => {
     const selected = cards('concepts', port)
-    expect(selected.map((card) => card.label)).toEqual([
-      'Server, session, window, pane', 'Native guides',
-    ])
+    expect(selected.map((card) => card.label)).toEqual(['Server, session, window, pane', 'Native guides'])
     for (const version of ['latest', 'stable', 'v0.1']) {
       const base = `https://libtmux.org/pr-42/en/${port}/${version}/concepts/`
       expect(selected.map((card) => new URL(card.href, base).pathname)).toEqual([
diff --git a/site/test/code-block-width.outer.test.ts b/site/test/code-block-width.outer.test.ts
new file mode 100644
index 000000000..f67ad70ff
--- /dev/null
+++ b/site/test/code-block-width.outer.test.ts
@@ -0,0 +1,157 @@
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { createServer, type Server } from 'node:http'
+import type { AddressInfo } from 'node:net'
+import { extname, join, normalize, sep } from 'node:path'
+import { chromium, type Browser } from 'playwright'
+import { afterAll, beforeAll, describe, expect, it } from 'vitest'
+import { BUCKET_ROOT, SITE_BUILT, SITE_PREFIX } from './site-root'
+
+/**
+ * A code block on a rendered page holds the 80 columns WRITING.md promises.
+ *
+ * The width check holds hand-written fences to 80 columns in the source. This
+ * measures the other half in a real browser: how many characters of the code
+ * font fit in the block's content box at 1024 and 1280 px viewports, once
+ * the reader's sidebar, margins and the block's own padding are taken out. A
+ * block that fits fewer scrolls sideways on a line the check passed.
+ *
+ * The measurement can fail: the control runs the same assertion at a phone
+ * width and expects it to throw.
+ */
+const PAGE = `/${SITE_PREFIX}concepts/queries/`
+const COLUMNS = 80
+const DESKTOP = 1024
+// The width where the page's contents column appears and narrows the article.
+const LAPTOP = 1280
+const PHONE = 390
+
+const TYPES: Record<string, string> = {
+  '.html': 'text/html',
+  '.js': 'text/javascript',
+  '.css': 'text/css',
+  '.woff2': 'font/woff2',
+  '.svg': 'image/svg+xml',
+  '.json': 'application/json',
+}
+
+/** Serve the assembled tree read-only on a loopback port the OS picks. */
+function serve(root: string): Promise<Server> {
+  const server = createServer((request, response) => {
+    let path = normalize(join(root, decodeURIComponent(new URL(request.url ?? '/', 'http://x').pathname)))
+    if (path !== root && !path.startsWith(root + sep)) path = ''
+    if (path && existsSync(path) && statSync(path).isDirectory()) path = join(path, 'index.html')
+    if (!path || !existsSync(path)) {
+      response.statusCode = 404
+      response.end()
+      return
+    }
+    response.setHeader('content-type', TYPES[extname(path)] ?? 'application/octet-stream')
+    response.end(readFileSync(path))
+  })
+  return new Promise((resolve) => server.listen(0, '127.0.0.1', () => resolve(server)))
+}
+
+const describeIfBuilt = SITE_BUILT && existsSync(join(BUCKET_ROOT, PAGE, 'index.html')) ? describe : describe.skip
+
+describeIfBuilt('code block width', () => {
+  let server: Server
+  let browser: Browser
+
+  beforeAll(async () => {
+    server = await serve(BUCKET_ROOT)
+    // Playwright's bundled Chromium draws the code font narrower than Chrome, Firefox and
+    // WebKit, so it would pass a block readers see scroll; measure in Chrome by default.
+    browser = await chromium.launch({ channel: process.env.LIBTMUX_DOCS_BROWSER_CHANNEL ?? 'chrome' })
+  })
+
+  afterAll(async () => {
+    await browser?.close()
+    await new Promise((resolve) => server?.close(resolve))
+  })
+
+  /**
+   * The fewest code-font characters any block on the page fits per line: the
+   * scrolling element's width less the line's own padding, over the width of
+   * one character measured from an 80-character run in the block's font.
+   */
+  async function columnsAt(
+    width: number,
+    blockFonts = false,
+  ): Promise<{ blocks: number; fewest: number; where: string }> {
+    const page = await browser.newPage({ viewport: { width, height: 1000 } })
+    if (blockFonts) await page.route('**/*.woff2', (route) => route.abort())
+    try {
+      const response = await page.goto(`http://127.0.0.1:${(server.address() as AddressInfo).port}${PAGE}`)
+      expect(response?.ok(), `${PAGE}: HTTP ${response?.status()}`).toBe(true)
+      // fonts.ready can settle before a lazily used face starts loading, which
+      // measures the fallback font, so load the code font itself and refuse
+      // to measure without it.
+      const font = await page.evaluate(async () => {
+        const line = document.querySelector<HTMLElement>('.expressive-code pre .ec-line .code')
+        if (!line) return ''
+        const style = getComputedStyle(line)
+        const spec = `${style.fontSize} ${style.fontFamily.split(',')[0]}`
+        const loaded = await document.fonts.load(spec).then(
+          (faces) => faces.length > 0,
+          () => false,
+        )
+        return loaded && document.fonts.check(spec) ? '' : spec
+      })
+      expect(font, `the code font did not load: ${font}`).toBe('')
+      return await page.evaluate((columns) => {
+        const fits: { columns: number; where: string }[] = []
+        for (const pre of document.querySelectorAll('.expressive-code pre')) {
+          const line = pre.querySelector<HTMLElement>('.ec-line .code')
+          if (!line) continue
+          const style = getComputedStyle(line)
+          const run = document.createElement('span')
+          run.style.cssText = 'position:absolute;visibility:hidden;white-space:pre'
+          run.textContent = '0'.repeat(columns)
+          line.append(run)
+          const character = run.getBoundingClientRect().width / columns
+          run.remove()
+          const content = pre.clientWidth - parseFloat(style.paddingLeft) - parseFloat(style.paddingRight)
+          if (!(character > 0 && Number.isFinite(content))) continue
+          // Name the block so a failure says which container narrows it.
+          let heading = ''
+          for (const h of document.querySelectorAll('h2, h3')) {
+            if (h.compareDocumentPosition(pre) & Node.DOCUMENT_POSITION_FOLLOWING) heading = h.textContent ?? ''
+          }
+          const inside = ['[role=tabpanel]', 'li', 'aside', 'details', 'table']
+            .filter((selector) => pre.closest(selector))
+            .join(', ')
+          const where =
+            `under "${heading.trim()}"${inside ? ` inside ${inside}` : ''}, ` +
+            `${content.toFixed(0)} px of ${character.toFixed(2)} px characters in ${style.fontFamily}`
+          fits.push({ columns: content / character, where })
+        }
+        fits.sort((a, b) => a.columns - b.columns)
+        return { blocks: fits.length, fewest: fits[0]?.columns ?? Number.NaN, where: fits[0]?.where ?? '' }
+      }, COLUMNS)
+    } finally {
+      await page.close()
+    }
+  }
+
+  const holdsEighty = async (width: number) => {
+    const { blocks, fewest, where } = await columnsAt(width)
+    expect(blocks, 'no code block was measured').toBeGreaterThan(0)
+    expect(fewest, `a block fits ${fewest.toFixed(1)} columns at ${width}px (${where})`).toBeGreaterThanOrEqual(COLUMNS)
+  }
+
+  it('fits 80 columns in every code block at 1024 px', async () => {
+    await holdsEighty(DESKTOP)
+  }, 30_000)
+
+  it('fits 80 columns in every code block at 1280 px', async () => {
+    await holdsEighty(LAPTOP)
+  }, 30_000)
+
+  it('control: without the code font it refuses to measure', async () => {
+    await expect(columnsAt(DESKTOP, true)).rejects.toThrow(/code font did not load/)
+  }, 30_000)
+
+  it('control: the same assertion fails at 390 px', async () => {
+    await expect(holdsEighty(PHONE)).rejects.toThrow(/columns at 390px/)
+  }, 30_000)
+})
diff --git a/site/test/code-tabs.test.ts b/site/test/code-tabs.test.ts
index b6d3099c0..98e22696e 100644
--- a/site/test/code-tabs.test.ts
+++ b/site/test/code-tabs.test.ts
@@ -81,8 +81,10 @@ describeIfBuilt('code tabs', () => {
      * by the script under test.
      */
     const isModuleOnly = (source: string) =>
-      /\bimport\.meta\b/.test(source) || /\bimport\s*\(/.test(source) ||
-      /\bimport\b\s*(?:[\w*{]|['"])/.test(source) || /\bexport\s/.test(source)
+      /\bimport\.meta\b/.test(source) ||
+      /\bimport\s*\(/.test(source) ||
+      /\bimport\b\s*(?:[\w*{]|['"])/.test(source) ||
+      /\bexport\s/.test(source)
 
     for (const script of [...document.querySelectorAll('script')]) {
       if (!isJs(script)) continue
@@ -136,9 +138,7 @@ describeIfBuilt('code tabs', () => {
 
     // A fresh page load with that preference stored opens on Go, not Python.
     const fresh = load('go')
-    const panel = [...fresh.document.querySelectorAll<HTMLElement>('.code-tab-panel')].find(
-      (p) => !p.hidden,
-    )
+    const panel = [...fresh.document.querySelectorAll<HTMLElement>('.code-tab-panel')].find((p) => !p.hidden)
     expect(panel?.dataset.port).toBe('go')
   })
 
@@ -147,9 +147,7 @@ describeIfBuilt('code tabs', () => {
     // block would be a worse answer than showing what it does have.
     const fresh = load('swift')
     for (const group of fresh.document.querySelectorAll('libtmux-code-tabs')) {
-      const shown = [...group.querySelectorAll<HTMLElement>('.code-tab-panel')].filter(
-        (p) => !p.hidden,
-      )
+      const shown = [...group.querySelectorAll<HTMLElement>('.code-tab-panel')].filter((p) => !p.hidden)
       expect(shown.length, 'exactly one panel per group').toBe(1)
     }
   })
diff --git a/site/test/complete-examples.test.ts b/site/test/complete-examples.test.ts
index 85341de77..c24fd02b0 100644
--- a/site/test/complete-examples.test.ts
+++ b/site/test/complete-examples.test.ts
@@ -19,25 +19,43 @@ import { docsPath, docsRedirects, docsRoutePath } from '../src/lib/docs-paths'
 const readPage = (page: string) => readFileSync(new URL(`../src/content/docs/${page}.md`, import.meta.url), 'utf8')
 const parsePage = (page: string) => parseFrontmatter(readPage(page), { frontmatter: 'remove' })
 const bodyOf = (page: string) => parsePage(page).content
-const fences = (markdown: string) => [...markdown.matchAll(/^```(\S+)([^\n]*)\n([\s\S]*?)^```/gm)]
-  .map((match) => ({ language: match[1], title: /title="([^"]+)"/.exec(match[2])?.[1], code: match[3] }))
+const fences = (markdown: string) =>
+  [...markdown.matchAll(/^```(\S+)([^\n]*)\n([\s\S]*?)^```/gm)].map((match) => ({
+    language: match[1],
+    title: /title="([^"]+)"/.exec(match[2])?.[1],
+    code: match[3],
+  }))
 const sha256 = (code: string) => createHash('sha256').update(code).digest('hex')
-const examples = [...receipt.examples, ...attach.examples, ...products.examples, ...queries.examples,
-  ...concepts.examples, ...guides.examples, ...programs.examples]
+const examples = [
+  ...receipt.examples,
+  ...attach.examples,
+  ...products.examples,
+  ...queries.examples,
+  ...concepts.examples,
+  ...guides.examples,
+  ...programs.examples,
+]
 
 afterEach(() => vi.unstubAllEnvs())
 
 describe('verified complete programs', () => {
   it.each(programs.examples)('copies every setup command on $page', (example) => {
-    const copied = fences(bodyOf(example.page)).filter((block) => block.language === 'console')
-      .map((block) => sessionLines(block.code.trimEnd().split('\n'))
-        .filter((line) => line.kind !== 'output').map((line) => line.text).join('\n').trim())
+    const copied = fences(bodyOf(example.page))
+      .filter((block) => block.language === 'console')
+      .map((block) =>
+        sessionLines(block.code.trimEnd().split('\n'))
+          .filter((line) => line.kind !== 'output')
+          .map((line) => line.text)
+          .join('\n')
+          .trim(),
+      )
     expect(copied).toEqual(example.shellRecipe)
   })
 
   it.each([
     ...['kotlin', 'scala', 'fsharp'].map((port) => ({
-      port, paths: ['index', 'server-session-window-pane', 'queries', 'transports', 'workspaces'],
+      port,
+      paths: ['index', 'server-session-window-pane', 'queries', 'transports', 'workspaces'],
     })),
     { port: 'go', paths: ['server-session-window-pane', 'queries'] },
     { port: 'rs', paths: ['queries', 'transports'] },
@@ -68,12 +86,16 @@ describe('verified complete programs', () => {
     }
     expect(selected).toContain(example.sourceRevision)
     expect(selected).not.toMatch(/^```[^\n]*(?:\bregion|\bfile)="|^>>> /m)
-    const commands = [...selected.matchAll(/^```console\n([\s\S]*?)^```/gm)]
-      .map((match) => match[1].replace(/^\$ /gm, '').trim())
+    const commands = [...selected.matchAll(/^```console\n([\s\S]*?)^```/gm)].map((match) =>
+      match[1].replace(/^\$ /gm, '').trim(),
+    )
     expect(commands).toEqual(example.shellRecipe)
     for (const block of blocks) {
       const comment = ['python', 'sh', 'ruby', 'toml', 'cmake', 'yaml', 'properties'].includes(block.language)
-        ? /^\s*#/ : block.language === 'lua' ? /^\s*--/ : /^\s*(?:\/\/|\/\*|\* )/
+        ? /^\s*#/
+        : block.language === 'lua'
+          ? /^\s*--/
+          : /^\s*(?:\/\/|\/\*|\* )/
       for (const line of block.code.split('\n').filter((line) => comment.test(line))) {
         expect(line.replaceAll('\t', '  ').length, `${example.port}: ${line}`).toBeLessThanOrEqual(100)
       }
@@ -85,7 +107,9 @@ describe('verified complete programs', () => {
     for (const port of 'rootOnly' in example ? [''] : ['', example.port]) {
       vi.stubEnv('LIBTMUX_DOCS_PORT', port)
       const renderer = await createMarkdownProcessor({
-        remarkPlugins: [remarkPortCode], rehypePlugins: [rehypeCodeTabs], syntaxHighlight: false,
+        remarkPlugins: [remarkPortCode],
+        rehypePlugins: [rehypeCodeTabs],
+        syntaxHighlight: false,
       })
       const html = (await renderer.render(body, { frontmatter })).code
       const window = new Window()
@@ -94,11 +118,14 @@ describe('verified complete programs', () => {
         const markdown = fences(resolvePortCode(body, port, frontmatter.port))
         for (const file of example.files) {
           const expected = fences(body).find((block) => block.title === file.name)!
-          const rendered = [...window.document.querySelectorAll(`pre > code.language-${expected.language}`)]
-            .map((code) => code.textContent)
+          const rendered = [...window.document.querySelectorAll(`pre > code.language-${expected.language}`)].map(
+            (code) => code.textContent,
+          )
           expect(rendered, `${example.port}/${file.name} HTML`).toContain(expected.code)
-          expect(markdown.find((block) => block.title === file.name)?.code,
-            `${example.port}/${file.name} Markdown`).toBe(expected.code)
+          expect(
+            markdown.find((block) => block.title === file.name)?.code,
+            `${example.port}/${file.name} Markdown`,
+          ).toBe(expected.code)
         }
         expect(window.document.querySelectorAll('libtmux-code-tabs')).toHaveLength(0)
       } finally {
@@ -117,15 +144,24 @@ describe('verified complete programs', () => {
       const variant = parsePage(id)
       expect(variant.frontmatter.port).toBe(port)
       expect(variant.frontmatter.route).toBe(example.page)
-      expect(variant.content).toMatch(/\]\((?:\.\.\/)+examples\/capture-pane-output\/\)|\]\(\.\.\/attaching-to-tmux\/\)/)
+      expect(variant.content).toMatch(
+        /\]\((?:\.\.\/)+examples\/capture-pane-output\/\)|\]\(\.\.\/attaching-to-tmux\/\)/,
+      )
       return { id, data: { port, route: example.page } }
     })
     const docs = [{ id: example.page, data: { supportedPorts: [] as string[] } }, ...variants]
     for (const port of ports) {
-      expect(docs.filter((doc) => docsEntryAvailable(doc, port))).toEqual([variants.find((doc) => doc.data.port === port)])
+      expect(docs.filter((doc) => docsEntryAvailable(doc, port))).toEqual([
+        variants.find((doc) => doc.data.port === port),
+      ])
     }
     const links = pagePortLinks({ pagePath: example.page, version: 'latest', defaults: {}, docs })
-    expect(links.filter((link) => link.links.length).map((link) => link.port).sort()).toEqual(ports.sort())
+    expect(
+      links
+        .filter((link) => link.links.length)
+        .map((link) => link.port)
+        .sort(),
+    ).toEqual(ports.sort())
   })
 
   it.each([receipt, attach])('keeps $page about tmux and routes each program to its port', async (receipt) => {
@@ -134,24 +170,32 @@ describe('verified complete programs', () => {
     const blocks = fences(bodyOf(receipt.page))
     expect(blocks.length).toBeGreaterThan(0)
     expect(blocks.every((block) => ['bash', 'sh', 'shell', 'console'].includes(block.language))).toBe(true)
-    expect(sha256(blocks.find((block) => block.title === receipt.rootExample.file)!.code))
-      .toBe(receipt.rootExample.sha256)
+    expect(sha256(blocks.find((block) => block.title === receipt.rootExample.file)!.code)).toBe(
+      receipt.rootExample.sha256,
+    )
     expect(root).toContain(receipt.rootExample.shellRecipe)
     expect(root).not.toMatch(/import libtmux|use libtmux|using LibTmux|#include|package main/)
-    const docs = [{ id: receipt.page, data: { supportedPorts: [] as string[] } }, ...receipt.examples.map((example) => {
-      expect(readPage(example.page)).toContain(`port: ${example.port}\n`)
-      expect(readPage(example.page)).toContain(`route: ${receipt.page}\n`)
-      expect(root).toContain(`/${example.port}/latest/${receipt.page}/`)
-      return { id: example.page, data: { port: example.port, route: receipt.page } }
-    })]
+    const docs = [
+      { id: receipt.page, data: { supportedPorts: [] as string[] } },
+      ...receipt.examples.map((example) => {
+        expect(readPage(example.page)).toContain(`port: ${example.port}\n`)
+        expect(readPage(example.page)).toContain(`route: ${receipt.page}\n`)
+        expect(root).toContain(`/${example.port}/latest/${receipt.page}/`)
+        return { id: example.page, data: { port: example.port, route: receipt.page } }
+      }),
+    ]
     expect(new Set(docs.map((doc) => docsRoutePath(doc))).size).toBe(receipt.examples.length + 1)
     for (const example of receipt.examples) {
       const available = docs.filter((doc) => docsEntryAvailable(doc, example.port))
       expect(available.map((doc) => docsRoutePath(doc, example.port))).toEqual([receipt.page])
     }
     const links = pagePortLinks({ pagePath: receipt.page, version: 'latest', defaults: {}, docs })
-    expect(links.filter((link) => link.links.length).map((link) => link.port).sort())
-      .toEqual(receipt.examples.map((example) => example.port).sort())
+    expect(
+      links
+        .filter((link) => link.links.length)
+        .map((link) => link.port)
+        .sort(),
+    ).toEqual(receipt.examples.map((example) => example.port).sort())
   })
 
   it('keeps the root workspace runnable and redirects legacy port pages to their owned examples', () => {
@@ -165,28 +209,44 @@ describe('verified complete programs', () => {
       expect(matching).toHaveLength(1)
       expect(sha256(matching[0].code)).toBe(file.sha256)
     }
-    expect(blocks.filter((block) => block.language === 'console')
-      .map((block) => block.code.replace(/^\$ /gm, '').trim())).toEqual(example.shellRecipe)
-    const docs = [{ id: example.page, data: frontmatter }, ...example.ports.map((port) => {
-      const id = `ports/${port}/workspace/${port === 'py' ? '' : 'internals/'}examples`
-      const { frontmatter: data } = parsePage(id)
-      expect(data.port).toBe(port)
-      expect(data.aliases).toContain(example.page)
-      expect(content).toContain(`/${port}/latest/${docsPath({ id, data })}/`)
-      return { id, data }
-    })]
+    expect(
+      blocks.filter((block) => block.language === 'console').map((block) => block.code.replace(/^\$ /gm, '').trim()),
+    ).toEqual(example.shellRecipe)
+    const docs = [
+      { id: example.page, data: frontmatter },
+      ...example.ports.map((port) => {
+        const id = `ports/${port}/workspace/${port === 'py' ? '' : 'internals/'}examples`
+        const { frontmatter: data } = parsePage(id)
+        expect(data.port).toBe(port)
+        expect(data.aliases).toContain(example.page)
+        expect(content).toContain(`/${port}/latest/${docsPath({ id, data })}/`)
+        return { id, data }
+      }),
+    ]
     const links = pagePortLinks({ pagePath: example.page, version: 'latest', defaults: {}, docs })
-    expect(links.filter((link) => link.links.length).map((link) => link.port).sort())
-      .toEqual([...example.ports].sort())
+    expect(
+      links
+        .filter((link) => link.links.length)
+        .map((link) => link.port)
+        .sort(),
+    ).toEqual([...example.ports].sort())
     for (const port of example.ports) {
       const available = docs.filter((doc) => docsEntryAvailable(doc, port))
       expect(available).toHaveLength(1)
-      expect(docsRedirects(available, port)).toEqual([
-        { path: example.page, target: docsPath(available[0]) },
-      ])
-      const reverse = pagePortLinks({ pagePath: docsPath(available[0]), portSlug: port, version: 'latest', defaults: {}, docs })
-      expect(reverse.filter((link) => link.links.length).map((link) => link.port).sort())
-        .toEqual([...example.ports].sort())
+      expect(docsRedirects(available, port)).toEqual([{ path: example.page, target: docsPath(available[0]) }])
+      const reverse = pagePortLinks({
+        pagePath: docsPath(available[0]),
+        portSlug: port,
+        version: 'latest',
+        defaults: {},
+        docs,
+      })
+      expect(
+        reverse
+          .filter((link) => link.links.length)
+          .map((link) => link.port)
+          .sort(),
+      ).toEqual([...example.ports].sort())
     }
   })
 })
diff --git a/site/test/cooldown.test.ts b/site/test/cooldown.test.ts
index 3ec1b6243..8fc62954b 100644
--- a/site/test/cooldown.test.ts
+++ b/site/test/cooldown.test.ts
@@ -1,15 +1,29 @@
 import { execFileSync } from 'node:child_process'
 import { describe, expect, it } from 'vitest'
-import { COOLDOWN_MARKERS, COOLDOWN_SLOTS, formatCooldown, hasCooldownSlot, type CooldownUnit } from '../src/lib/cooldown'
+import {
+  COOLDOWN_MARKERS,
+  COOLDOWN_SLOTS,
+  formatCooldown,
+  hasCooldownSlot,
+  type CooldownUnit,
+} from '../src/lib/cooldown'
 import { highlightWithCooldownSlots } from '../src/lib/highlight'
 import { PORTS, type InstallCommand } from '../src/lib/ports'
 
 /** Every install command that carries a cooldown, with the package it installs. */
 const cooldownCommands = PORTS.flatMap((port) => [
   ...port.installs.map((cmd) => ({ port: port.slug, pkg: port.packageName, cmd })),
-  ...(port.packages ?? []).flatMap((pkg) => (pkg.installs ?? []).map((cmd) => ({ port: port.slug, pkg: pkg.name, cmd }))),
-]).filter((entry): entry is { port: string; pkg: string; cmd: InstallCommand & { cooldown: NonNullable<InstallCommand['cooldown']> } } =>
-  Boolean(entry.cmd.cooldown),
+  ...(port.packages ?? []).flatMap((pkg) =>
+    (pkg.installs ?? []).map((cmd) => ({ port: port.slug, pkg: pkg.name, cmd })),
+  ),
+]).filter(
+  (
+    entry,
+  ): entry is {
+    port: string
+    pkg: string
+    cmd: InstallCommand & { cooldown: NonNullable<InstallCommand['cooldown']> }
+  } => Boolean(entry.cmd.cooldown),
 )
 
 /** A form with every placeholder written out, as the reader would copy it. */
@@ -28,7 +42,11 @@ describe('dependency cooldowns', () => {
   })
 
   it('leaves each placeholder as a slot the widget scripts rewrite', async () => {
-    const html = await highlightWithCooldownSlots(`$ pnpm_config_minimum_release_age=${COOLDOWN_SLOTS.minutes} pnpm add libtmux`, 'console', 7)
+    const html = await highlightWithCooldownSlots(
+      `$ pnpm_config_minimum_release_age=${COOLDOWN_SLOTS.minutes} pnpm add libtmux`,
+      'console',
+      7,
+    )
     expect(html).toContain('data-cooldown-scale="1440"')
     expect(html).toContain('>10080</span>')
     for (const marker of Object.values(COOLDOWN_MARKERS)) expect(html).not.toContain(marker)
diff --git a/site/test/csharp-api-examples.test.ts b/site/test/csharp-api-examples.test.ts
index 98a9ec3e3..f8ad8bb84 100644
--- a/site/test/csharp-api-examples.test.ts
+++ b/site/test/csharp-api-examples.test.ts
@@ -15,18 +15,26 @@ describe('verified complete C# API programs', () => {
     expect(examples).toHaveLength(30)
     expect(new Set(examples.map((example) => 'sourceProgramId' in example && example.sourceProgramId)).size).toBe(7)
     expect(new Set(examples.map((example) => example.page)).size).toBe(30)
-    const covered = model.symbols.filter((symbol) => symbol.doc?.examples?.some(
-      (block) => block.sourceUrl?.includes('/examples/LibTmux.Examples/Programs/'))).map((symbol) => symbol.id)
+    const covered = model.symbols
+      .filter((symbol) =>
+        symbol.doc?.examples?.some((block) => block.sourceUrl?.includes('/examples/LibTmux.Examples/Programs/')),
+      )
+      .map((symbol) => symbol.id)
     expect([...new Set(examples.map((example) => example.symbol))].sort()).toEqual(covered.sort())
-    const targets = examples.flatMap((example) => 'sourceCompilerIds' in example ? example.sourceCompilerIds : [])
+    const targets = examples.flatMap((example) => ('sourceCompilerIds' in example ? example.sourceCompilerIds : []))
     expect(targets).toHaveLength(33)
     expect(new Set(targets).size).toBe(33)
   })
 
   it.each(examples)('keeps complete $sourceProgramId bytes on $symbol in Markdown and copy payloads', (example) => {
-    if (!('sourceProgramId' in example) || typeof example.sourceProgramId !== 'string' ||
-        !('sourceCompilerIds' in example) || !Array.isArray(example.sourceCompilerIds) ||
-        !('consoleBlocks' in example) || !example.consoleBlocks) {
+    if (
+      !('sourceProgramId' in example) ||
+      typeof example.sourceProgramId !== 'string' ||
+      !('sourceCompilerIds' in example) ||
+      !Array.isArray(example.sourceCompilerIds) ||
+      !('consoleBlocks' in example) ||
+      !example.consoleBlocks
+    ) {
       throw new Error(`${example.symbol}: missing source program receipt`)
     }
     const symbols = model.symbols.filter((symbol) => symbol.id === example.symbol)
@@ -38,7 +46,12 @@ describe('verified complete C# API programs', () => {
     expect(symbol.source.revision).toBe(example.sourceRevision)
     expect(example.page).toBe(`ports/csharp/reference/${symbol.slug}`)
     for (const target of example.sourceCompilerIds) {
-      expect(target.slice(2).replace(/\(.*$/, '').replace(/`{1,2}\d+/g, '')).toBe(symbol.id)
+      expect(
+        target
+          .slice(2)
+          .replace(/\(.*$/, '')
+          .replace(/`{1,2}\d+/g, ''),
+      ).toBe(symbol.id)
     }
     expect(example.files).toHaveLength(4)
     for (const file of example.files) {
@@ -57,8 +70,9 @@ describe('verified complete C# API programs', () => {
         expect(line.length).toBeLessThanOrEqual(100)
       }
     }
-    expect(example.consoleBlocks.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim()))
-      .toEqual(example.shellRecipe)
+    expect(example.consoleBlocks.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim())).toEqual(
+      example.shellRecipe,
+    )
     const output = blocks[example.consoleBlocks[1] + 1].code.trimEnd().split('\n')
     expect(example.expectedOutputs[1]).toEqual([...output, ...output])
     for (const index of example.consoleBlocks) {
diff --git a/site/test/cxx-api-examples.test.ts b/site/test/cxx-api-examples.test.ts
index 29c8e3a7a..c1838673d 100644
--- a/site/test/cxx-api-examples.test.ts
+++ b/site/test/cxx-api-examples.test.ts
@@ -14,11 +14,23 @@ describe('complete C++ API programs', () => {
   it('covers construction, listing, creation, queries, input and capture', () => {
     expect(examples).toHaveLength(29)
     expect(new Set(examples.map((example) => example.sourceFile)).size).toBe(7)
-    for (const id of ['libtmux::Server', 'libtmux::Server::sessions', 'libtmux::Server::windows',
-      'libtmux::Server::panes', 'libtmux::Server::clients', 'libtmux::Server::new_session',
-      'libtmux::Session::new_window', 'libtmux::Pane::split', 'libtmux::matching',
-      'libtmux::Pane::send_line', 'libtmux::Pane::capture']) {
-      expect(examples.some((example) => example.symbol === id), id).toBe(true)
+    for (const id of [
+      'libtmux::Server',
+      'libtmux::Server::sessions',
+      'libtmux::Server::windows',
+      'libtmux::Server::panes',
+      'libtmux::Server::clients',
+      'libtmux::Server::new_session',
+      'libtmux::Session::new_window',
+      'libtmux::Pane::split',
+      'libtmux::matching',
+      'libtmux::Pane::send_line',
+      'libtmux::Pane::capture',
+    ]) {
+      expect(
+        examples.some((example) => example.symbol === id),
+        id,
+      ).toBe(true)
     }
     expect(model.symbols.some((symbol) => symbol.id.startsWith('libtmux::workspace::detail::'))).toBe(false)
   })
@@ -40,8 +52,10 @@ describe('complete C++ API programs', () => {
       const block = blocks[file.block]
       expect(hash(block.code), file.name).toBe(file.sha256)
       expect(file).toHaveProperty('clipboardSha256', hash(block.code.replace(/\n$/, '')))
-      expect(exported.some((block) => hash(block.value + '\n') === file.sha256),
-        `${file.name} Markdown`).toBe(true)
+      expect(
+        exported.some((block) => hash(block.value + '\n') === file.sha256),
+        `${file.name} Markdown`,
+      ).toBe(true)
       expect(block.sourceUrl).toBe(`https://github.com/${model.repo}/blob/${example.sourceRevision}/${file.sourceFile}`)
       for (const line of block.code.split('\n').filter((line) => /^\s*\/\//.test(line))) {
         expect(line.length).toBeLessThanOrEqual(100)
@@ -52,11 +66,13 @@ describe('complete C++ API programs', () => {
     expect(program.code).toContain('#include <libtmux/testing/scoped_server.hpp>')
     expect(program.code).toContain('int main()')
     expect(program.intro).toContain('`Server`')
-    const commands = blocks.filter((block) => block.lang === 'console')
+    const commands = blocks
+      .filter((block) => block.lang === 'console')
       .map((block) => block.code.replace(/^\$ /gm, '').trim())
     expect(commands).toEqual(example.shellRecipe)
-    expect(example.consoleBlocks?.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim()))
-      .toEqual(example.shellRecipe)
+    expect(example.consoleBlocks?.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim())).toEqual(
+      example.shellRecipe,
+    )
     expect(commands[1]).toContain('-DLIBTMUX_BUILD_TESTING_LIBRARY=ON')
     expect(commands[2]).toContain('-DCMAKE_PREFIX_PATH="$PWD/libtmux-prefix"')
     expect(example.expectedOutputs.at(-1)).toEqual(blocks.at(-1)!.code.trimEnd().split('\n'))
diff --git a/site/test/deploy-workflow.outer.test.ts b/site/test/deploy-workflow.outer.test.ts
index 437349cb6..7899099a0 100644
--- a/site/test/deploy-workflow.outer.test.ts
+++ b/site/test/deploy-workflow.outer.test.ts
@@ -19,7 +19,8 @@ describe('publication server deadlines', () => {
       // so the real curl must hit its deadline instead of receiving a reply.
       const started = performance.now()
       const result = spawnSync('bash', ['-c', `exec ${probes[0]}`], {
-        encoding: 'utf8', timeout: 5000,
+        encoding: 'utf8',
+        timeout: 5000,
         env: { ...process.env, SERVE_SITE: `http://127.0.0.1:${address.port}` },
       })
       expect(result.error).toBeUndefined()
diff --git a/site/test/deploy-workflow.test.ts b/site/test/deploy-workflow.test.ts
index bed71b96f..82e6c1d1f 100644
--- a/site/test/deploy-workflow.test.ts
+++ b/site/test/deploy-workflow.test.ts
@@ -46,7 +46,9 @@ function publishManifest(responses: ManifestResponse[], env: Record<string, stri
     writeFileSync(join(directory, 'publication-receipt.json'), JSON.stringify(publication))
     writeFileSync(join(directory, 'summary'), '')
     writeFileSync(join(directory, 'responses.json'), JSON.stringify(responses))
-    writeFileSync(join(directory, 'aws'), `#!${process.execPath}
+    writeFileSync(
+      join(directory, 'aws'),
+      `#!${process.execPath}
 const fs = require('node:fs')
 const args = process.argv.slice(2)
 const calls = fs.readFileSync(process.env.CALLS, 'utf8').trim().split('\\n').filter(Boolean)
@@ -66,24 +68,47 @@ if (args[1] === 'get-object') {
   fs.writeFileSync(args.at(-1), JSON.stringify(response.document))
   console.log(response.etag)
 }
-`, { mode: 0o755 })
-    const body = /- name: Upsert manifest\/<port>\.json[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/.exec(reusable)![1]
+`,
+      { mode: 0o755 },
+    )
+    const body = /- name: Upsert manifest\/<port>\.json[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/
+      .exec(reusable)![1]
       .replace(/^ {10}/gm, '')
     const result = spawnSync('bash', ['-c', body], {
-      encoding: 'utf8', timeout: 10000, env: {
-        ...process.env, PATH: `${directory}:${process.env.PATH}`, RUNNER_TEMP: directory,
-        CALLS: calls, RESPONSES: join(directory, 'responses.json'), BUCKET: 'docs-test',
-        PORT: 'go', SLUG: 'next', KIND: 'alias', LABEL: 'Next', IS_DEFAULT: 'true', RESOLVES_TO: 'v2',
-        GITHUB_STEP_SUMMARY: join(directory, 'summary'), PREFIX: 'en/go/next', ...env,
+      encoding: 'utf8',
+      timeout: 10000,
+      env: {
+        ...process.env,
+        PATH: `${directory}:${process.env.PATH}`,
+        RUNNER_TEMP: directory,
+        CALLS: calls,
+        RESPONSES: join(directory, 'responses.json'),
+        BUCKET: 'docs-test',
+        PORT: 'go',
+        SLUG: 'next',
+        KIND: 'alias',
+        LABEL: 'Next',
+        IS_DEFAULT: 'true',
+        RESOLVES_TO: 'v2',
+        GITHUB_STEP_SUMMARY: join(directory, 'summary'),
+        PREFIX: 'en/go/next',
+        ...env,
       },
     })
     expect(result.error, result.stderr).toBeUndefined()
     return {
       ...result,
       summary: readFileSync(join(directory, 'summary'), 'utf8'),
-      calls: readFileSync(calls, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line)) as {
+      calls: readFileSync(calls, 'utf8')
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => JSON.parse(line)) as {
         args: string[]
-        document?: { ports: Record<string, { slug: string; publication?: typeof publication & { operation: string } }[]>; defaultVersion: Record<string, string> }
+        document?: {
+          ports: Record<string, { slug: string; publication?: typeof publication & { operation: string } }[]>
+          defaultVersion: Record<string, string>
+        }
       }[],
     }
   } finally {
@@ -99,9 +124,18 @@ function existingManifest(slugs: string[]) {
   }
 }
 
-function manifestError(operation: ManifestResponse['operation'], code: string, status = 254, prefix = ''): ManifestResponse {
+function manifestError(
+  operation: ManifestResponse['operation'],
+  code: string,
+  status = 254,
+  prefix = '',
+): ManifestResponse {
   const name = operation === 'get-object' ? 'GetObject' : 'PutObject'
-  return { operation, error: `${prefix}An error occurred (${code}) when calling the ${name} operation: request failed`, status }
+  return {
+    operation,
+    error: `${prefix}An error occurred (${code}) when calling the ${name} operation: request failed`,
+    status,
+  }
 }
 
 describe('port manifest publication', () => {
@@ -112,7 +146,11 @@ describe('port manifest publication', () => {
     manifestError('get-object', 'AccessDenied', 254, 'aws: [ERROR]: '),
     manifestError('get-object', 'SlowDown', 254, 'aws: [ERROR]: '),
     manifestError('get-object', 'NoSuchKey', 254, 'Unexpected error: '),
-    { operation: 'get-object', error: 'Could not connect to the endpoint URL: https://docs-test.s3.amazonaws.com', status: 255 },
+    {
+      operation: 'get-object',
+      error: 'Could not connect to the endpoint URL: https://docs-test.s3.amazonaws.com',
+      status: 255,
+    },
   ] satisfies ManifestResponse[])('reports a failed read without writing: $error', (response) => {
     const result = publishManifest([response])
     expect(result.status, result.stderr).toBe(response.status)
@@ -122,12 +160,25 @@ describe('port manifest publication', () => {
   })
 
   it.each(['404', 'NoSuchKey'].flatMap((code) => ['', 'aws: [ERROR]: '].map((prefix) => ({ code, prefix }))))(
-    'creates a missing manifest after $prefix$code with a conditional first write', ({ code, prefix }) => {
+    'creates a missing manifest after $prefix$code with a conditional first write',
+    ({ code, prefix }) => {
       const result = publishManifest([manifestError('get-object', code, 254, prefix), { operation: 'put-object' }])
       expect(result.status, result.stderr).toBe(0)
       expect(result.calls[1].args.slice(-2)).toEqual(['--if-none-match', '*'])
       expect(result.calls[1].document).toEqual({
-        schema: 1, ports: { go: [{ slug: 'next', label: 'Next', kind: 'alias', supported: true, resolvesTo: 'v2', publication: { ...publication, operation: 'published' } }] },
+        schema: 1,
+        ports: {
+          go: [
+            {
+              slug: 'next',
+              label: 'Next',
+              kind: 'alias',
+              supported: true,
+              resolvesTo: 'v2',
+              publication: { ...publication, operation: 'published' },
+            },
+          ],
+        },
         defaultVersion: { go: 'next' },
       })
     },
@@ -165,7 +216,8 @@ describe('port manifest publication', () => {
     const failure = manifestError('get-object', 'SlowDown')
     const result = publishManifest([
       { operation: 'get-object', document: existingManifest(['v1']), etag: '"first"' },
-      manifestError('put-object', '412'), failure,
+      manifestError('put-object', '412'),
+      failure,
     ])
     expect(result.status, result.stderr).toBe(failure.status)
     expect(result.stderr).toContain(failure.error)
@@ -175,7 +227,8 @@ describe('port manifest publication', () => {
   it('reports non-conflict write errors without retrying', () => {
     const failure = manifestError('put-object', 'AccessDenied')
     const result = publishManifest([
-      { operation: 'get-object', document: existingManifest(['v1']), etag: '"first"' }, failure,
+      { operation: 'get-object', document: existingManifest(['v1']), etag: '"first"' },
+      failure,
     ])
     expect(result.status).toBe(1)
     expect(result.stderr).toContain(failure.error)
@@ -185,8 +238,15 @@ describe('port manifest publication', () => {
 
   it('preserves the original receipt only for identical immutable bytes', () => {
     const original = { ...publication, operation: 'published', artifact: { ...publication.artifact, id: 9 } }
-    const document = { schema: 1, ports: { go: [{ slug: 'next', publication: original }] }, defaultVersion: { go: 'next' } }
-    const responses: ManifestResponse[] = [{ operation: 'get-object', document, etag: '"old"' }, { operation: 'put-object' }]
+    const document = {
+      schema: 1,
+      ports: { go: [{ slug: 'next', publication: original }] },
+      defaultVersion: { go: 'next' },
+    }
+    const responses: ManifestResponse[] = [
+      { operation: 'get-object', document, etag: '"old"' },
+      { operation: 'put-object' },
+    ]
     const immutable = publishManifest(responses, { KIND: 'tag', SKIP_SYNC: 'true' })
     expect(immutable.status, immutable.stderr).toBe(0)
     expect(immutable.calls[1].document?.ports.go[0].publication).toEqual(original)
@@ -197,16 +257,28 @@ describe('port manifest publication', () => {
   })
 
   it('describes legacy immutable bytes without a receipt as verified existing', () => {
-    const result = publishManifest([
-      { operation: 'get-object', document: existingManifest(['next']), etag: '"old"' }, { operation: 'put-object' },
-    ], { KIND: 'tag', SKIP_SYNC: 'true' })
+    const result = publishManifest(
+      [{ operation: 'get-object', document: existingManifest(['next']), etag: '"old"' }, { operation: 'put-object' }],
+      { KIND: 'tag', SKIP_SYNC: 'true' },
+    )
     expect(result.status, result.stderr).toBe(0)
     expect(result.calls[1].document?.ports.go[0].publication?.operation).toBe('verified-existing')
   })
 
   it('fails without a successful receipt if an immutable manifest disagrees with the verified build', () => {
-    const document = { schema: 1, ports: { go: [{ slug: 'next', publication: { ...publication, build: { ...publication.build, sha256: 'd'.repeat(64) } } }] }, defaultVersion: {} }
-    const result = publishManifest([{ operation: 'get-object', document, etag: '"old"' }], { KIND: 'tag', SKIP_SYNC: 'true' })
+    const document = {
+      schema: 1,
+      ports: {
+        go: [
+          { slug: 'next', publication: { ...publication, build: { ...publication.build, sha256: 'd'.repeat(64) } } },
+        ],
+      },
+      defaultVersion: {},
+    }
+    const result = publishManifest([{ operation: 'get-object', document, etag: '"old"' }], {
+      KIND: 'tag',
+      SKIP_SYNC: 'true',
+    })
     expect(result.status).not.toBe(0)
     expect(result.stderr).toContain('immutable publication receipt disagrees')
     expect(result.calls).toHaveLength(1)
@@ -232,22 +304,41 @@ describe('immutable byte guard', () => {
       mkdirSync(join(directory, 'dist'))
       mkdirSync(join(directory, 'remote'))
       for (const folder of ['dist', 'remote']) {
-        writeFileSync(join(directory, folder, 'index.html'), folder === 'remote' && mode === 'changed' ? 'other bytes' : 'same page')
-        if (folder === 'dist' || mode !== 'legacy-no-record') writeFileSync(join(directory, folder, 'build-provenance.json'), '{}')
+        writeFileSync(
+          join(directory, folder, 'index.html'),
+          folder === 'remote' && mode === 'changed' ? 'other bytes' : 'same page',
+        )
+        if (folder === 'dist' || mode !== 'legacy-no-record')
+          writeFileSync(join(directory, folder, 'build-provenance.json'), '{}')
       }
       writeFileSync(join(directory, 'env'), '')
-      writeFileSync(join(directory, 'aws'), `#!${process.execPath}
+      writeFileSync(
+        join(directory, 'aws'),
+        `#!${process.execPath}
 const fs = require('node:fs')
 const args = process.argv.slice(2)
 if (args[0] === 's3api' && args[1] === 'list-objects-v2') console.log('1')
 else if (args[0] === 's3' && args[1] === 'sync' && args[2] === 's3://docs-test/en/go/v1/') fs.cpSync(process.env.REMOTE, args[3], { recursive: true })
 else process.exit(90)
-`, { mode: 0o755 })
-      const body = /- name: Protect immutable tag contents[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/.exec(reusable)![1].replace(/^ {10}/gm, '')
-      const result = spawnSync('bash', ['-c', body], { cwd: directory, encoding: 'utf8', env: {
-        ...process.env, PATH: `${directory}:${process.env.PATH}`, RUNNER_TEMP: directory,
-        BUCKET: 'docs-test', PREFIX: 'en/go/v1', GITHUB_ENV: join(directory, 'env'), REMOTE: join(directory, 'remote'),
-      } })
+`,
+        { mode: 0o755 },
+      )
+      const body = /- name: Protect immutable tag contents[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/
+        .exec(reusable)![1]
+        .replace(/^ {10}/gm, '')
+      const result = spawnSync('bash', ['-c', body], {
+        cwd: directory,
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          PATH: `${directory}:${process.env.PATH}`,
+          RUNNER_TEMP: directory,
+          BUCKET: 'docs-test',
+          PREFIX: 'en/go/v1',
+          GITHUB_ENV: join(directory, 'env'),
+          REMOTE: join(directory, 'remote'),
+        },
+      })
       expect(result.status, result.stderr).toBe(mode === 'identical' ? 0 : 1)
       expect(readFileSync(join(directory, 'env'), 'utf8')).toBe(mode === 'identical' ? 'SKIP_SYNC=true\n' : '')
       if (mode !== 'identical') expect(result.stderr).toContain('already exists with different bytes')
@@ -263,25 +354,43 @@ describe('port publisher contract', () => {
     try {
       const environment = join(directory, 'env')
       writeFileSync(environment, '')
-      const body = /- name: Validate path-prefix[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/.exec(reusable)![1].replace(/^ {10}/gm, '')
-      const result = spawnSync('bash', ['-c', body], { encoding: 'utf8', env: {
-        ...process.env, GITHUB_REPOSITORY: repository, GITHUB_ENV: environment,
-        PREFIX_IN: prefix, PORT_IN: port, VERSION_IN: 'pr-42', KIND_IN: 'pr', DEFAULT_IN: 'false', LIBTMUX_DOCS_LOCALE: 'en', ...env,
-      } })
+      const body = /- name: Validate path-prefix[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/
+        .exec(reusable)![1]
+        .replace(/^ {10}/gm, '')
+      const result = spawnSync('bash', ['-c', body], {
+        encoding: 'utf8',
+        env: {
+          ...process.env,
+          GITHUB_REPOSITORY: repository,
+          GITHUB_ENV: environment,
+          PREFIX_IN: prefix,
+          PORT_IN: port,
+          VERSION_IN: 'pr-42',
+          KIND_IN: 'pr',
+          DEFAULT_IN: 'false',
+          LIBTMUX_DOCS_LOCALE: 'en',
+          ...env,
+        },
+      })
       return { ...result, environment: readFileSync(environment, 'utf8') }
     } finally {
       rmSync(directory, { recursive: true, force: true })
     }
   }
 
-  it.each([...new Set(PORTS.map((port) => port.repo)), 'unknown/docs', ''])('rejects an empty port from %s before selecting an artifact or AWS credentials', (repository) => {
-    const result = validatePrefix(repository)
-    expect(result.status, result.stderr).toBe(1)
-    expect(result.stderr).toContain('must supply a port and its publication provenance')
-    expect(result.environment).toBe('')
-    expect(reusable.indexOf('Validate path-prefix')).toBeLessThan(reusable.indexOf('uses: actions/download-artifact'))
-    expect(reusable.indexOf('Validate path-prefix')).toBeLessThan(reusable.indexOf('uses: aws-actions/configure-aws-credentials'))
-  })
+  it.each([...new Set(PORTS.map((port) => port.repo)), 'unknown/docs', ''])(
+    'rejects an empty port from %s before selecting an artifact or AWS credentials',
+    (repository) => {
+      const result = validatePrefix(repository)
+      expect(result.status, result.stderr).toBe(1)
+      expect(result.stderr).toContain('must supply a port and its publication provenance')
+      expect(result.environment).toBe('')
+      expect(reusable.indexOf('Validate path-prefix')).toBeLessThan(reusable.indexOf('uses: actions/download-artifact'))
+      expect(reusable.indexOf('Validate path-prefix')).toBeLessThan(
+        reusable.indexOf('uses: aws-actions/configure-aws-credentials'),
+      )
+    },
+  )
 
   it.each(['libtmux/docs', 'tony/libtmux-docs'])('retains the shared preview contract for %s', (repository) => {
     const result = validatePrefix(repository)
@@ -311,21 +420,33 @@ describe('port publisher contract', () => {
     expect(shared.environment).toBe('')
   })
 
-  it.each(['v1\nPROVENANCE_REVIEW_MARKER=1', 'v1\rMARKER=1', 'v1\n', 'v1/other', 'v1..2', 'v1+build'])('rejects malformed version %j without writing environment bytes', (version) => {
-    const result = validatePrefix('libtmux/libtmux-go', 'go', `go/${version}`, { VERSION_IN: version, KIND_IN: 'tag' })
-    expect(result.status, result.stderr).toBe(1)
-    expect(result.environment).toBe('')
-  })
+  it.each(['v1\nPROVENANCE_REVIEW_MARKER=1', 'v1\rMARKER=1', 'v1\n', 'v1/other', 'v1..2', 'v1+build'])(
+    'rejects malformed version %j without writing environment bytes',
+    (version) => {
+      const result = validatePrefix('libtmux/libtmux-go', 'go', `go/${version}`, {
+        VERSION_IN: version,
+        KIND_IN: 'tag',
+      })
+      expect(result.status, result.stderr).toBe(1)
+      expect(result.environment).toBe('')
+    },
+  )
 
-  it.each(['en\nPROVENANCE_REVIEW_MARKER=1', 'en\n', '../en', 'en/py', 'english'])('rejects malformed locale %j without writing environment bytes', (locale) => {
-    const result = validatePrefix('libtmux/libtmux-go', 'go', 'go/pr-42', { LIBTMUX_DOCS_LOCALE: locale })
-    expect(result.status, result.stderr).toBe(1)
-    expect(result.stderr).toContain('invalid publication locale')
-    expect(result.environment).toBe('')
-  })
+  it.each(['en\nPROVENANCE_REVIEW_MARKER=1', 'en\n', '../en', 'en/py', 'english'])(
+    'rejects malformed locale %j without writing environment bytes',
+    (locale) => {
+      const result = validatePrefix('libtmux/libtmux-go', 'go', 'go/pr-42', { LIBTMUX_DOCS_LOCALE: locale })
+      expect(result.status, result.stderr).toBe(1)
+      expect(result.stderr).toContain('invalid publication locale')
+      expect(result.environment).toBe('')
+    },
+  )
 
   it('reserves every port and requires its exact port/version prefix', () => {
-    const reserved = reusable.match(/reserved=\(([^)]+)\)/)?.[1].trim().split(/\s+/)
+    const reserved = reusable
+      .match(/reserved=\(([^)]+)\)/)?.[1]
+      .trim()
+      .split(/\s+/)
     expect(reserved).toEqual([...PORTS.map((port) => port.slug), 'manifest', '_shell'])
     expect(reusable).toContain('"$p" != "$PORT_IN/$VERSION_IN"')
     expect(reusable).toContain('^pr-[0-9]+$')
@@ -341,7 +462,7 @@ describe('port publisher contract', () => {
     expect(guard).toContain('--max-keys 1')
     expect(guard).toContain("--query 'KeyCount'")
     expect(guard).not.toMatch(/^\s+--max-items/m)
-    expect(reusable).toContain('immutable tag \'$PREFIX\' already exists with different bytes')
+    expect(reusable).toContain("immutable tag '$PREFIX' already exists with different bytes")
     expect(reusable).toContain("if: inputs.port != '' && inputs.version-kind != 'pr'")
   })
 
@@ -379,15 +500,25 @@ describe('port publisher contract', () => {
   it('stages every source-bound native guide before the publication audit checks backlinks', () => {
     sourceCheckoutContract(testWorkflow)
     expect(testWorkflow).toContain('node scripts/stage-port-docs.mjs --from-source')
-    const stage = testWorkflow.slice(testWorkflow.indexOf('- name: Stage integrated source guides'), testWorkflow.indexOf('- name: test-all'))
-    const audit = testWorkflow.slice(testWorkflow.indexOf('- name: test-all'), testWorkflow.indexOf('- name: Upload audited preview'))
+    const stage = testWorkflow.slice(
+      testWorkflow.indexOf('- name: Stage integrated source guides'),
+      testWorkflow.indexOf('- name: test-all'),
+    )
+    const audit = testWorkflow.slice(
+      testWorkflow.indexOf('- name: test-all'),
+      testWorkflow.indexOf('- name: Upload audited preview'),
+    )
     for (const port of sourceGuidePorts) {
-      expect(stage).toContain(`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}: ` + '${{ github.workspace }}/.port-sources/' + port)
+      expect(stage).toContain(
+        `LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}: ` + '${{ github.workspace }}/.port-sources/' + port,
+      )
     }
     expect(stage).toContain('node scripts/stage-port-docs.mjs --cached --check')
     expect(stage.indexOf('--cached --check')).toBeGreaterThan(stage.indexOf('--from-source'))
     for (const port of ['ruby', 'lua']) {
-      expect(audit).toContain(`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}: ` + '${{ github.workspace }}/.port-sources/' + port)
+      expect(audit).toContain(
+        `LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}: ` + '${{ github.workspace }}/.port-sources/' + port,
+      )
     }
     expect(audit).not.toMatch(/LIBTMUX_DOCS_CHECKOUT_(POWERSHELL|JULIA):/)
     expect(testWorkflow).toContain('LIBTMUX_DOCS_SKIP_NATIVE_MODEL_PORTS: ' + sourceGuidePorts.join(','))
@@ -400,14 +531,18 @@ describe('port publisher contract', () => {
     const env = { ...process.env, [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: checkout }
     try {
       const unskipped = spawnSync(process.execPath, ['scripts/gen-api-model.mjs', '--port', port, '--check'], {
-        cwd: new URL('../..', import.meta.url), env, encoding: 'utf8',
+        cwd: new URL('../..', import.meta.url),
+        env,
+        encoding: 'utf8',
       })
       expect(unskipped.status).toBe(1)
       expect(unskipped.stderr).toContain(`${port} has no native artifact`)
 
-      const skipped = spawnSync(process.execPath, [
-        'scripts/gen-api-model.mjs', '--port', port, '--check', '--skip-native-model-ports', port,
-      ], { cwd: new URL('../..', import.meta.url), env, encoding: 'utf8' })
+      const skipped = spawnSync(
+        process.execPath,
+        ['scripts/gen-api-model.mjs', '--port', port, '--check', '--skip-native-model-ports', port],
+        { cwd: new URL('../..', import.meta.url), env, encoding: 'utf8' },
+      )
       expect(skipped.status).toBe(0)
       expect(skipped.stdout).toContain(`${port} native model freshness skipped`)
     } finally {
@@ -425,7 +560,10 @@ describe('port publisher contract', () => {
 
   it('publishes only the same-run artifact that passed both the audit and publisher dry-run', () => {
     const audit = testWorkflow.slice(testWorkflow.indexOf('  test:'), testWorkflow.indexOf('  check-publish-preview:'))
-    const check = testWorkflow.slice(testWorkflow.indexOf('  check-publish-preview:'), testWorkflow.indexOf('  publish-preview:'))
+    const check = testWorkflow.slice(
+      testWorkflow.indexOf('  check-publish-preview:'),
+      testWorkflow.indexOf('  publish-preview:'),
+    )
     const publish = testWorkflow.slice(testWorkflow.indexOf('  publish-preview:'))
     expect(audit.indexOf('name: test-all')).toBeLessThan(audit.indexOf('name: Upload audited preview'))
     expect(audit).toContain('preview-artifact-id: ${{ steps.preview-artifact.outputs.artifact-id }}')
@@ -437,19 +575,29 @@ describe('port publisher contract', () => {
     expect(publish).toContain('github.event.pull_request.head.repo.full_name == github.repository')
     expect(publish).toContain('environment: docs-preview')
     expect(testWorkflow).toContain("format('deploy-shell-pr-{0}', github.event.pull_request.number)")
-    expect((audit + check).replace(/^\s*#.*$/gm, '')).not.toMatch(/id-token:|secrets\.|continue-on-error|always\(\)|run-id:|github-token:/)
+    expect((audit + check).replace(/^\s*#.*$/gm, '')).not.toMatch(
+      /id-token:|secrets\.|continue-on-error|always\(\)|run-id:|github-token:/,
+    )
     expect(testWorkflow + shell).not.toMatch(/pull_request_target:|workflow_run:/)
     expect(publish).not.toMatch(/continue-on-error|always\(\)/)
-    const download = reusable.slice(reusable.indexOf('      # Without github-token'), reusable.indexOf("      - if: inputs.port == '' && inputs.version-kind != 'pr'"))
+    const download = reusable.slice(
+      reusable.indexOf('      # Without github-token'),
+      reusable.indexOf("      - if: inputs.port == '' && inputs.version-kind != 'pr'"),
+    )
     expect(download).toContain('artifact-ids: ${{ inputs.artifact-id }}')
     expect(download).toContain('digest-mismatch: error')
     expect(download).not.toMatch(/^\s*(name|run-id|github-token|repository):/m)
-    expect(reusable.indexOf('Validate preview artifact identity')).toBeLessThan(reusable.indexOf('uses: aws-actions/configure-aws-credentials'))
+    expect(reusable.indexOf('Validate preview artifact identity')).toBeLessThan(
+      reusable.indexOf('uses: aws-actions/configure-aws-credentials'),
+    )
   })
 
   it.each(['', '0', '-1', '12,13', '12other', '12\n', '12\nMARKER=1', '17'])(
-    'validates one immutable preview artifact ID: %j', (id) => {
-      const body = /- name: Validate preview artifact identity[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/.exec(reusable)![1].replace(/^ {10}/gm, '')
+    'validates one immutable preview artifact ID: %j',
+    (id) => {
+      const body = /- name: Validate preview artifact identity[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/
+        .exec(reusable)![1]
+        .replace(/^ {10}/gm, '')
       const result = spawnSync('bash', ['-c', body], { encoding: 'utf8', env: { ...process.env, ARTIFACT_ID: id } })
       expect(result.status).toBe(id === '17' ? 0 : 1)
       if (id !== '17') expect(result.stderr).toContain('requires one audited artifact ID from this run')
@@ -460,7 +608,9 @@ describe('port publisher contract', () => {
     expect(publicationAudit).toContain("step 'production root renders'")
     expect(publicationAudit).toContain('LIBTMUX_DOCS_VERSION_KIND=trunk LIBTMUX_DOCS_IS_DEFAULT=true')
     expect(publicationAudit).toContain('--outDir "$LIBTMUX_DOCS_TEST_PRODUCTION_SITE/$locale"')
-    expect(publicationAudit.indexOf("step 'production root renders'")).toBeLessThan(publicationAudit.indexOf("step 'output tests'"))
+    expect(publicationAudit.indexOf("step 'production root renders'")).toBeLessThan(
+      publicationAudit.indexOf("step 'output tests'"),
+    )
     expect(publicationAudit).toContain("echo 'missing production root render'")
   })
 })
@@ -472,33 +622,42 @@ describe('publication URL audits', () => {
     ['/pr-49', '', false, false],
     ['/pr-49', '/pr-50', false, false],
     ['/pr-49', '/pr-49', true, false],
-  ] as const)('checks Core Library targets within %j with href prefix %j and missing target %j', (prefix, hrefPrefix, missing, valid) => {
-    const directory = mkdtempSync(join(tmpdir(), 'libtmux-sidebar-prefix-'))
-    try {
-      for (const { slug } of API_MODEL_PORTS) {
-        const page = join(directory, slug, 'latest/concepts')
-        const reference = join(directory, slug, 'latest/reference')
-        mkdirSync(page, { recursive: true })
-        mkdirSync(reference, { recursive: true })
-        if (!missing || slug !== 'rs') writeFileSync(join(reference, 'index.html'), 'reference')
-        const host = ({ rs: 'docs.rs', go: 'pkg.go.dev', java: 'javadoc.io' } as Record<string, string>)[slug]
-        const links = `<div class="surface-options"><a href="${hrefPrefix}/en/${slug}/latest/">Home</a><a href="${hrefPrefix}/en/${slug}/latest/reference/">API Reference</a></div>`
-          + '<div class="surface-alternatives">'
-          + (host ? `<a href="https://${host}/" target="_blank" rel="noopener noreferrer">${host}</a>` : '')
-          + (slug === 'py' ? `<a href="${hrefPrefix}/en/py/latest/api/">Upstream reference</a>` : '') + '</div>'
-        writeFileSync(join(page, 'index.html'), `<details data-surface-picker><details data-surface-group><summary><strong>Core Library</strong></summary>${links}</details></details>`
-          + '<nav class="sidebar-nav"><a href="#concept">Concepts</a></nav>'.repeat(2))
+  ] as const)(
+    'checks Core Library targets within %j with href prefix %j and missing target %j',
+    (prefix, hrefPrefix, missing, valid) => {
+      const directory = mkdtempSync(join(tmpdir(), 'libtmux-sidebar-prefix-'))
+      try {
+        for (const { slug } of API_MODEL_PORTS) {
+          const page = join(directory, slug, 'latest/concepts')
+          const reference = join(directory, slug, 'latest/reference')
+          mkdirSync(page, { recursive: true })
+          mkdirSync(reference, { recursive: true })
+          if (!missing || slug !== 'rs') writeFileSync(join(reference, 'index.html'), 'reference')
+          const host = ({ rs: 'docs.rs', go: 'pkg.go.dev', java: 'javadoc.io' } as Record<string, string>)[slug]
+          const links =
+            `<div class="surface-options"><a href="${hrefPrefix}/en/${slug}/latest/">Home</a><a href="${hrefPrefix}/en/${slug}/latest/reference/">API Reference</a></div>` +
+            '<div class="surface-alternatives">' +
+            (host ? `<a href="https://${host}/" target="_blank" rel="noopener noreferrer">${host}</a>` : '') +
+            (slug === 'py' ? `<a href="${hrefPrefix}/en/py/latest/api/">Upstream reference</a>` : '') +
+            '</div>'
+          writeFileSync(
+            join(page, 'index.html'),
+            `<details data-surface-picker><details data-surface-group><summary><strong>Core Library</strong></summary>${links}</details></details>` +
+              '<nav class="sidebar-nav"><a href="#concept">Concepts</a></nav>'.repeat(2),
+          )
+        }
+        const result = spawnSync(process.execPath, ['scripts/check-sidebar-refs.mjs', directory], {
+          cwd: new URL('../..', import.meta.url),
+          encoding: 'utf8',
+          env: { ...process.env, LIBTMUX_DOCS_LOCALES_ROOT: prefix, LIBTMUX_DOCS_LOCALE: 'en' },
+        })
+        expect(result.status, result.stderr).toBe(valid ? 0 : 1)
+        if (!valid) expect(result.stderr).toContain('is linked but not built')
+      } finally {
+        rmSync(directory, { recursive: true, force: true })
       }
-      const result = spawnSync(process.execPath, ['scripts/check-sidebar-refs.mjs', directory], {
-        cwd: new URL('../..', import.meta.url), encoding: 'utf8',
-        env: { ...process.env, LIBTMUX_DOCS_LOCALES_ROOT: prefix, LIBTMUX_DOCS_LOCALE: 'en' },
-      })
-      expect(result.status, result.stderr).toBe(valid ? 0 : 1)
-      if (!valid) expect(result.stderr).toContain('is linked but not built')
-    } finally {
-      rmSync(directory, { recursive: true, force: true })
-    }
-  })
+    },
+  )
 
   it.each([
     ['', '/en/py/latest/reference/server/', true],
@@ -512,7 +671,8 @@ describe('publication URL audits', () => {
       mkdirSync(page, { recursive: true })
       writeFileSync(join(page, 'index.html'), `<link rel="canonical" href="https://libtmux.org${canonical}">`)
       const result = spawnSync(process.execPath, ['scripts/check-canonicals.mjs', directory], {
-        cwd: new URL('../..', import.meta.url), encoding: 'utf8',
+        cwd: new URL('../..', import.meta.url),
+        encoding: 'utf8',
         env: { ...process.env, LIBTMUX_DOCS_LOCALES_ROOT: prefix, LIBTMUX_DOCS_LOCALE: 'en' },
       })
       expect(result.status, result.stderr).toBe(valid ? 0 : 1)
@@ -532,7 +692,9 @@ describe('shell publish', () => {
 
   it('re-uploads every object written before the current header policy', () => {
     const headers = [...new Set([...publishRoot.matchAll(/--cache-control "([^"]+)"/g)].map((match) => match[1]))]
-    expect(headers, 'publish-root.sh changed a header: move policy.since and PUBLISH_POLICY_SINCE to today').toEqual(policy.cacheControl)
+    expect(headers, 'publish-root.sh changed a header: move policy.since and PUBLISH_POLICY_SINCE to today').toEqual(
+      policy.cacheControl,
+    )
     expect(shell).toContain(`PUBLISH_POLICY_SINCE: '${policy.since}'`)
   })
 
@@ -547,7 +709,8 @@ describe('shell publish', () => {
 const testedHead = 'b'.repeat(40)
 const testedMerge = 'a'.repeat(40)
 const currentPullRequest = {
-  number: 42, state: 'open',
+  number: 42,
+  state: 'open',
   head: { repo: { full_name: 'libtmux/libtmux-powershell' }, sha: testedHead },
   merge_commit_sha: testedMerge,
 }
@@ -558,27 +721,55 @@ function requireCurrentPullRequest(response: unknown, env: Record<string, string
     const calls = join(directory, 'calls')
     writeFileSync(calls, '')
     mkdirSync(join(directory, 'publication'))
-    writeFileSync(join(directory, 'publication/publication.json'), JSON.stringify({ sourceSha: env.ARTIFACT_SOURCE_SHA ?? testedMerge }))
+    writeFileSync(
+      join(directory, 'publication/publication.json'),
+      JSON.stringify({ sourceSha: env.ARTIFACT_SOURCE_SHA ?? testedMerge }),
+    )
     writeFileSync(join(directory, 'response'), typeof response === 'string' ? response : JSON.stringify(response))
-    writeFileSync(join(directory, 'gh'), `#!${process.execPath}
+    writeFileSync(
+      join(directory, 'gh'),
+      `#!${process.execPath}
 const fs = require('node:fs')
 const args = process.argv.slice(2)
 fs.appendFileSync(process.env.CALLS, JSON.stringify(args) + '\\n')
 if (JSON.stringify(args) !== JSON.stringify(['api', '--method', 'GET', 'repos/' + process.env.REPOSITORY + '/pulls/' + process.env.PR])) process.exit(99)
 if (Number(process.env.API_STATUS)) process.exit(Number(process.env.API_STATUS))
 process.stdout.write(fs.readFileSync(process.env.RESPONSE))
-`, { mode: 0o755 })
-    const body = /- name: Require current tested pull request[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/.exec(reusable)![1].replace(/^ {10}/gm, '')
+`,
+      { mode: 0o755 },
+    )
+    const body = /- name: Require current tested pull request[\s\S]*?        run: \|\n((?: {10}[^\n]*\n|\n)*)/
+      .exec(reusable)![1]
+      .replace(/^ {10}/gm, '')
     const result = spawnSync('bash', ['-c', body], {
-      encoding: 'utf8', timeout: 10000, cwd: directory, env: {
-        ...process.env, PATH: `${directory}:${process.env.PATH}`, CALLS: calls,
-        RESPONSE: join(directory, 'response'), API_STATUS: String(apiStatus),
-        EVENT: 'pull_request', REPOSITORY: 'libtmux/libtmux-powershell', PR: '42',
-        PORT: 'powershell', VERSION: 'pr-42', EXPECTED_HEAD: testedHead, TESTED_MERGE: testedMerge, ...env,
+      encoding: 'utf8',
+      timeout: 10000,
+      cwd: directory,
+      env: {
+        ...process.env,
+        PATH: `${directory}:${process.env.PATH}`,
+        CALLS: calls,
+        RESPONSE: join(directory, 'response'),
+        API_STATUS: String(apiStatus),
+        EVENT: 'pull_request',
+        REPOSITORY: 'libtmux/libtmux-powershell',
+        PR: '42',
+        PORT: 'powershell',
+        VERSION: 'pr-42',
+        EXPECTED_HEAD: testedHead,
+        TESTED_MERGE: testedMerge,
+        ...env,
       },
     })
     expect(result.error, result.stderr).toBeUndefined()
-    return { ...result, calls: readFileSync(calls, 'utf8').trim().split('\n').filter(Boolean).map((line) => JSON.parse(line)) }
+    return {
+      ...result,
+      calls: readFileSync(calls, 'utf8')
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+        .map((line) => JSON.parse(line)),
+    }
   } finally {
     rmSync(directory, { recursive: true, force: true })
   }
@@ -604,7 +795,10 @@ describe('current PR publication guard', () => {
 
   it.each(['powershell', 'julia'])('allows the current tested same-repository %s preview', (port) => {
     const repo = `libtmux/libtmux-${port}`
-    const result = requireCurrentPullRequest({ ...currentPullRequest, head: { repo: { full_name: repo }, sha: testedHead } }, { PORT: port, REPOSITORY: repo })
+    const result = requireCurrentPullRequest(
+      { ...currentPullRequest, head: { repo: { full_name: repo }, sha: testedHead } },
+      { PORT: port, REPOSITORY: repo },
+    )
     expect(result.status, result.stderr).toBe(0)
     expect(result.calls).toEqual([['api', '--method', 'GET', `repos/${repo}/pulls/42`]])
   })
@@ -634,21 +828,31 @@ describe('current PR publication guard', () => {
   })
 
   it.each<Record<string, string>>([
-    { EVENT: 'workflow_dispatch' }, { EVENT: 'pull_request_target' }, { PORT: '' },
-    { PR: '' }, { PR: '0' }, { PR: '../42' }, { VERSION: 'pr-43' },
-    { EXPECTED_HEAD: '' }, { TESTED_MERGE: '' }, { ARTIFACT_SOURCE_SHA: 'c'.repeat(40) },
+    { EVENT: 'workflow_dispatch' },
+    { EVENT: 'pull_request_target' },
+    { PORT: '' },
+    { PR: '' },
+    { PR: '0' },
+    { PR: '../42' },
+    { VERSION: 'pr-43' },
+    { EXPECTED_HEAD: '' },
+    { TESTED_MERGE: '' },
+    { ARTIFACT_SOURCE_SHA: 'c'.repeat(40) },
   ])('rejects invalid tested identity before API access: %j', (env) => {
     const result = requireCurrentPullRequest(currentPullRequest, env)
     expect(result.status).toBe(1)
     expect(result.calls).toEqual([])
   })
 
-  it.each(['failed-jobs', 'specific-publish-job', 'reusable-publisher-child-job'])('rechecks current state on %s reruns with cached successful upstream outputs', () => {
-    expect(requireCurrentPullRequest(currentPullRequest, { GITHUB_RUN_ATTEMPT: '1' }).status).toBe(0)
-    // Build/provenance may legitimately reuse attempt 1. This same-job gate
-    // still executes after cleanup, even without a new upstream job output.
-    const rerun = requireCurrentPullRequest({ ...currentPullRequest, state: 'closed' }, { GITHUB_RUN_ATTEMPT: '2' })
-    expect(rerun.status).toBe(1)
-    expect(rerun.calls).toHaveLength(1)
-  })
+  it.each(['failed-jobs', 'specific-publish-job', 'reusable-publisher-child-job'])(
+    'rechecks current state on %s reruns with cached successful upstream outputs',
+    () => {
+      expect(requireCurrentPullRequest(currentPullRequest, { GITHUB_RUN_ATTEMPT: '1' }).status).toBe(0)
+      // Build/provenance may legitimately reuse attempt 1. This same-job gate
+      // still executes after cleanup, even without a new upstream job output.
+      const rerun = requireCurrentPullRequest({ ...currentPullRequest, state: 'closed' }, { GITHUB_RUN_ATTEMPT: '2' })
+      expect(rerun.status).toBe(1)
+      expect(rerun.calls).toHaveLength(1)
+    },
+  )
 })
diff --git a/site/test/docs-paths.test.ts b/site/test/docs-paths.test.ts
index 275ff70aa..20e6f5514 100644
--- a/site/test/docs-paths.test.ts
+++ b/site/test/docs-paths.test.ts
@@ -1,53 +1,75 @@
 import { describe, expect, it } from 'vitest'
-import { docsPath, docsRedirects, docsRoutePath, proseHref, sourceGuideRedirects, workspaceRedirectPath } from '../src/lib/docs-paths'
+import {
+  docsPath,
+  docsRedirects,
+  docsRoutePath,
+  proseHref,
+  sourceGuideRedirects,
+  workspaceRedirectPath,
+} from '../src/lib/docs-paths'
 import { PORTS } from '../src/lib/ports'
 
 const pythonGuide = { id: 'ports/py/workspace/guides', data: { port: 'py', product: 'workspace' } }
 
 describe('product document URLs', () => {
-  it.each(['', '/pr-42'])('keeps explicit port and versioned tmux references in their English build under %s', (prefix) => {
-    const root = `${prefix}/ja`
-    const ports = `${prefix}/en`
-    for (const port of PORTS) {
-      for (const path of [`/${port.slug}/`, `/${port.slug}/next/examples/capture-pane-output/?view=full#output`]) {
-        expect(proseHref(path, root, 'go', 'stable', ports)).toBe(`${ports}${path}`)
+  it.each(['', '/pr-42'])(
+    'keeps explicit port and versioned tmux references in their English build under %s',
+    (prefix) => {
+      const root = `${prefix}/ja`
+      const ports = `${prefix}/en`
+      for (const port of PORTS) {
+        for (const path of [`/${port.slug}/`, `/${port.slug}/next/examples/capture-pane-output/?view=full#output`]) {
+          expect(proseHref(path, root, 'go', 'stable', ports)).toBe(`${ports}${path}`)
+        }
       }
-    }
-    for (const path of ['/tmux/latest/manual/full/#FORMATS', '/tmux/3.5a/reference/?q=server#members']) {
-      expect(proseHref(path, root, undefined, 'latest', ports)).toBe(`${ports}${path}`)
-    }
-    for (const path of ['/tmux/', '/tmux/guides/', '/tmux/latest/manual-notes/', '/constructor/', '/third-party-notices/']) {
-      expect(proseHref(path, root, undefined, 'latest', ports)).toBe(`${root}${path}`)
-    }
-    expect(proseHref('/guides/attaching-to-tmux/', root, undefined, 'latest', ports)).toBe(`${root}/tmux/guides/attaching-to-tmux/`)
-    for (const path of ['https://example.com/py/latest/', '//example.com/tmux/latest/manual/', '../guides/', '#example']) {
-      expect(proseHref(path, root, undefined, 'latest', ports)).toBe(path)
-    }
-  })
+      for (const path of ['/tmux/latest/manual/full/#FORMATS', '/tmux/3.5a/reference/?q=server#members']) {
+        expect(proseHref(path, root, undefined, 'latest', ports)).toBe(`${ports}${path}`)
+      }
+      for (const path of [
+        '/tmux/',
+        '/tmux/guides/',
+        '/tmux/latest/manual-notes/',
+        '/constructor/',
+        '/third-party-notices/',
+      ]) {
+        expect(proseHref(path, root, undefined, 'latest', ports)).toBe(`${root}${path}`)
+      }
+      expect(proseHref('/guides/attaching-to-tmux/', root, undefined, 'latest', ports)).toBe(
+        `${root}/tmux/guides/attaching-to-tmux/`,
+      )
+      for (const path of [
+        'https://example.com/py/latest/',
+        '//example.com/tmux/latest/manual/',
+        '../guides/',
+        '#example',
+      ]) {
+        expect(proseHref(path, root, undefined, 'latest', ports)).toBe(path)
+      }
+    },
+  )
 
-  it.each(['guides', 'topics', 'concepts', 'examples'])('mounts shared %s only inside tmux while keeping library routes', (section) => {
-    for (const id of [section, `${section}/nested/page`]) {
-      const entry = { id, data: {} }
-      expect(docsRoutePath(entry)).toBe(`tmux/${id}`)
-      expect(docsRoutePath(entry, 'go')).toBe(id)
-      expect(docsRoutePath({ id, data: { port: 'go' } })).toBe(`go/latest/${id}`)
-      expect(proseHref(`/${id}/?example=one#target`, '/pr-42/en')).toBe(`/pr-42/en/tmux/${id}/?example=one#target`)
-      expect(proseHref(`/tmux/${id}/`, '/en')).toBe(`/en/tmux/${id}/`)
-    }
-    expect(docsRoutePath({ id: 'third-party-notices', data: {} })).toBe('third-party-notices')
-  })
+  it.each(['guides', 'topics', 'concepts', 'examples'])(
+    'mounts shared %s only inside tmux while keeping library routes',
+    (section) => {
+      for (const id of [section, `${section}/nested/page`]) {
+        const entry = { id, data: {} }
+        expect(docsRoutePath(entry)).toBe(`tmux/${id}`)
+        expect(docsRoutePath(entry, 'go')).toBe(id)
+        expect(docsRoutePath({ id, data: { port: 'go' } })).toBe(`go/latest/${id}`)
+        expect(proseHref(`/${id}/?example=one#target`, '/pr-42/en')).toBe(`/pr-42/en/tmux/${id}/?example=one#target`)
+        expect(proseHref(`/tmux/${id}/`, '/en')).toBe(`/en/tmux/${id}/`)
+      }
+      expect(docsRoutePath({ id: 'third-party-notices', data: {} })).toBe('third-party-notices')
+    },
+  )
 
   it('retires duplicate Julia and F# API overviews in root and selected-version builds', () => {
     expect(sourceGuideRedirects(undefined, { fsharp: 'stable' })).toEqual([
       { path: 'julia/latest/guides/api-overview', target: 'julia/latest/reference' },
       { path: 'fsharp/stable/guides/api-overview', target: 'fsharp/stable/reference' },
     ])
-    expect(sourceGuideRedirects('julia')).toEqual([
-      { path: 'guides/api-overview', target: 'reference' },
-    ])
-    expect(sourceGuideRedirects('fsharp')).toEqual([
-      { path: 'guides/api-overview', target: 'reference' },
-    ])
+    expect(sourceGuideRedirects('julia')).toEqual([{ path: 'guides/api-overview', target: 'reference' }])
+    expect(sourceGuideRedirects('fsharp')).toEqual([{ path: 'guides/api-overview', target: 'reference' }])
     expect(sourceGuideRedirects('py')).toEqual([])
   })
   it('uses the same path in root and per-port builds', () => {
@@ -83,10 +105,15 @@ describe('product document URLs', () => {
 
   it('rejects aliases that collide with a canonical route or a reserved route', () => {
     const canonical = { id: 'guides/core', data: { port: 'ruby', route: 'guides/core' } }
-    const staged = { id: '_staged/ruby/core/index', data: { port: 'ruby', route: 'guides/overview', aliases: ['guides/core'] } }
+    const staged = {
+      id: '_staged/ruby/core/index',
+      data: { port: 'ruby', route: 'guides/overview', aliases: ['guides/core'] },
+    }
     expect(() => docsRedirects([canonical, staged], undefined, { ruby: 'latest' })).toThrow('alias collides')
     expect(() => docsRedirects([staged], undefined, { ruby: 'latest' }, ['ruby/latest/mcp'])).not.toThrow()
-    expect(() => docsRedirects([staged], undefined, { ruby: 'latest' }, ['ruby/latest/guides/core'])).toThrow('reserved route')
+    expect(() => docsRedirects([staged], undefined, { ruby: 'latest' }, ['ruby/latest/guides/core'])).toThrow(
+      'reserved route',
+    )
   })
 
   it('filters legacy aliases according to published pages, independently of CLI availability', () => {
diff --git a/site/test/documentation-navigation.test.ts b/site/test/documentation-navigation.test.ts
index 079171ab8..020dfe689 100644
--- a/site/test/documentation-navigation.test.ts
+++ b/site/test/documentation-navigation.test.ts
@@ -1,21 +1,45 @@
 import { describe, expect, it, vi } from 'vitest'
 vi.mock('astro:content', () => ({ getCollection: vi.fn(async () => []) }))
-import { buildDocumentationSurfaces, currentDocumentation, getDocumentationSurfaces } from '../src/lib/documentation-navigation'
+import {
+  buildDocumentationSurfaces,
+  currentDocumentation,
+  getDocumentationSurfaces,
+} from '../src/lib/documentation-navigation'
 import { PORTS, portPageUrl, type DocProduct } from '../src/lib/ports'
 import type { SidebarItem } from '../src/lib/sidebar'
 import { mcpObjects, MCP_REFERENCE } from '../src/lib/mcp-reference'
 
 const link = (label: string, href: string): SidebarItem => ({ type: 'link', label, href })
-const menus = (port: typeof PORTS[number], version: string) => Object.fromEntries(['core', 'mcp', 'workspace'].map((surface) => {
-  const base = (path = '') => portPageUrl(port, version, [surface === 'core' ? '' : surface, path].filter(Boolean).join('/'))
-  return [surface, [link('Overview', base()), link('Guides', base('guides')), link('Examples', base('examples')),
-    link('API', base('reference')), link('Third-party notices', base('third-party-notices')),
-    ...(surface === 'workspace' ? [link('CLI Manual', base('cli')), link('Load', base('cli/load')),
-      link('Installation', base('guides/installation')), link('Internal guides', base('internals/guides')),
-      link('Exit codes', base('reference/exit-codes')), link('Output', base('reference/output'))] : []),
-    ...(surface === 'mcp' ? [link('Tools', base('tools')), link('Prompts', base('prompts')), link('Resources', base('resources'))] : []),
-  ]]
-})) as Record<'core' | DocProduct, SidebarItem[]>
+const menus = (port: (typeof PORTS)[number], version: string) =>
+  Object.fromEntries(
+    ['core', 'mcp', 'workspace'].map((surface) => {
+      const base = (path = '') =>
+        portPageUrl(port, version, [surface === 'core' ? '' : surface, path].filter(Boolean).join('/'))
+      return [
+        surface,
+        [
+          link('Overview', base()),
+          link('Guides', base('guides')),
+          link('Examples', base('examples')),
+          link('API', base('reference')),
+          link('Third-party notices', base('third-party-notices')),
+          ...(surface === 'workspace'
+            ? [
+                link('CLI Manual', base('cli')),
+                link('Load', base('cli/load')),
+                link('Installation', base('guides/installation')),
+                link('Internal guides', base('internals/guides')),
+                link('Exit codes', base('reference/exit-codes')),
+                link('Output', base('reference/output')),
+              ]
+            : []),
+          ...(surface === 'mcp'
+            ? [link('Tools', base('tools')), link('Prompts', base('prompts')), link('Resources', base('resources'))]
+            : []),
+        ],
+      ]
+    }),
+  ) as Record<'core' | DocProduct, SidebarItem[]>
 
 describe('documentation surface navigation', () => {
   it('offers the tmux area without inventing a library port or empty prose sections', async () => {
@@ -27,10 +51,17 @@ describe('documentation surface navigation', () => {
   })
 
   it('selects shared sections inside the tmux hub', () => {
-    const surfaces = [{ id: 'tmux', label: 'tmux', href: '/tmux/', sections: [
-      { id: 'home', label: 'Home', href: '/tmux/', items: [] },
-      { id: 'guides', label: 'Guides', href: '/tmux/guides/', items: [] },
-    ] }]
+    const surfaces = [
+      {
+        id: 'tmux',
+        label: 'tmux',
+        href: '/tmux/',
+        sections: [
+          { id: 'home', label: 'Home', href: '/tmux/', items: [] },
+          { id: 'guides', label: 'Guides', href: '/tmux/guides/', items: [] },
+        ],
+      },
+    ]
     expect(currentDocumentation(surfaces, '/tmux/guides/getting-started/').section.id).toBe('guides')
   })
 
@@ -57,7 +88,9 @@ describe('documentation surface navigation', () => {
       const selected = currentDocumentation(surfaces, `${surface.href}guides/installation/`)
       expect(selected.surface.id).toBe(surface.id)
       expect(selected.section.id).toBe('guides')
-      expect(selected.section.items.every((item) => item.type !== 'link' || !item.href.includes('/internals/'))).toBe(true)
+      expect(selected.section.items.every((item) => item.type !== 'link' || !item.href.includes('/internals/'))).toBe(
+        true,
+      )
       expect(currentDocumentation(surfaces, `${surface.href}reference/example/`).section.id).toBe('reference')
       if (surface.id === 'workspace') {
         const manual = currentDocumentation(surfaces, `${surface.href}cli/load/`).section
@@ -80,7 +113,10 @@ describe('documentation surface navigation', () => {
     const ruby = PORTS.find((port) => port.slug === 'ruby')!
     const version = 'v0.1.0'
     const inventory = menus(ruby, version)
-    for (const [product, title] of [['mcp', 'MCP server guide'], ['workspace', 'Workspace guide']] as const) {
+    for (const [product, title] of [
+      ['mcp', 'MCP server guide'],
+      ['workspace', 'Workspace guide'],
+    ] as const) {
       const href = portPageUrl(ruby, version, `${product}/source-guide`)
       inventory[product].push(link(title, href))
       const surfaces = buildDocumentationSurfaces('ruby', version, inventory)
@@ -96,7 +132,9 @@ describe('documentation surface navigation', () => {
   it('uses Julia’s existing MCP setup guide when no Guides overview exists', () => {
     const setup = '/julia/latest/mcp/source-guide/'
     const surfaces = buildDocumentationSurfaces('julia', 'latest', { mcp: [link('MCP server guide', setup)] })
-    const section = surfaces.find((surface) => surface.id === 'mcp')!.sections.find((section) => section.id === 'guides')!
+    const section = surfaces
+      .find((surface) => surface.id === 'mcp')!
+      .sections.find((section) => section.id === 'guides')!
     expect(section.href).toBe(setup)
     expect(section.items).toEqual([link('MCP server guide', setup)])
     expect(currentDocumentation(surfaces, setup).section).toBe(section)
@@ -104,7 +142,8 @@ describe('documentation surface navigation', () => {
 
   it('omits unavailable Lua apps even when their availability pages exist', () => {
     const port = PORTS.find((entry) => entry.slug === 'lua')!
-    const surfaces = buildDocumentationSurfaces('lua', 'latest', { core: [],
+    const surfaces = buildDocumentationSurfaces('lua', 'latest', {
+      core: [],
       mcp: [link('Availability', portPageUrl(port, 'latest', 'mcp'))],
       workspace: [link('Availability', portPageUrl(port, 'latest', 'workspace'))],
     })
@@ -112,10 +151,12 @@ describe('documentation surface navigation', () => {
   })
 
   it('offers a section when a real child exists, without requiring an overview or adding empty sections', () => {
-    const surfaces = buildDocumentationSurfaces('csharp', 'latest', { core: [
-      link('First session', '/csharp/latest/tutorials/first-session/'),
-      link('Installation', '/csharp/latest/guides/installation/'),
-    ] })
+    const surfaces = buildDocumentationSurfaces('csharp', 'latest', {
+      core: [
+        link('First session', '/csharp/latest/tutorials/first-session/'),
+        link('Installation', '/csharp/latest/guides/installation/'),
+      ],
+    })
     const core = surfaces.find((surface) => surface.id === 'core')!
     expect(core.sections.map((section) => [section.id, section.href])).toEqual([
       ['home', '/csharp/latest/'],
@@ -123,7 +164,12 @@ describe('documentation surface navigation', () => {
       ['tutorials', '/csharp/latest/tutorials/first-session/'],
       ['reference', '/csharp/latest/reference/'],
     ])
-    expect(core.sections[0].items.map((item) => item.label)).toEqual(['Overview', 'Guides', 'Tutorials', 'API Reference'])
+    expect(core.sections[0].items.map((item) => item.label)).toEqual([
+      'Overview',
+      'Guides',
+      'Tutorials',
+      'API Reference',
+    ])
   })
 
   it.each(['cxx', 'julia', 'powershell', 'ruby'])('keeps %s product glossaries inside their API navigation', (slug) => {
@@ -135,7 +181,9 @@ describe('documentation surface navigation', () => {
       const group = reference.items.find((item) => item.label === 'Language API')!
       if (group.type !== 'group') throw new Error('Expected language API tree')
       expect(group.items.length).toBeGreaterThan(1)
-      expect(group.items.filter((item) => item.href === glossary)).toEqual([{ type: 'link', label: 'API glossary', href: glossary }])
+      expect(group.items.filter((item) => item.href === glossary)).toEqual([
+        { type: 'link', label: 'API glossary', href: glossary },
+      ])
       const selected = currentDocumentation(surfaces, glossary)
       expect(selected.surface.id).toBe(surface.id)
       expect(selected.section).toBe(reference)
@@ -162,32 +210,59 @@ describe('documentation surface navigation', () => {
     const mcp = currentDocumentation(surfaces, portPageUrl(port, 'latest', 'mcp/tools/list_sessions'))
     expect(mcp.surface.id).toBe('mcp')
     expect(mcp.section.id).toBe('tools')
-    expect(mcp.section.items.map((item) => item.label)).toEqual(['Tools', ...MCP_REFERENCE.go.registrations.map((tool) => tool.wireName)])
-    expect(currentDocumentation(surfaces, '/go/latest/mcp/reference/').section.items.map((item) => item.label)).toEqual(['Language API'])
+    expect(mcp.section.items.map((item) => item.label)).toEqual([
+      'Tools',
+      ...MCP_REFERENCE.go.registrations.map((tool) => tool.wireName),
+    ])
+    expect(currentDocumentation(surfaces, '/go/latest/mcp/reference/').section.items.map((item) => item.label)).toEqual(
+      ['Language API'],
+    )
   })
 
-  it.each(Object.keys(MCP_REFERENCE))('exposes all three protocol sections for %s with only its advertised objects', (slug) => {
-    const port = PORTS.find((entry) => entry.slug === slug)!
-    const surfaces = buildDocumentationSurfaces(slug, 'next', menus(port, 'next'))
-    const mcp = surfaces.find((surface) => surface.id === 'mcp')!
-    expect(mcp.sections.map((section) => section.id)).toEqual(['home', 'guides', 'examples', 'tools', 'prompts', 'resources', 'reference'])
-    for (const id of ['tools', 'prompts', 'resources']) {
-      const section = mcp.sections.find((section) => section.id === id)!
-      const objects = mcpObjects(slug).filter((object) => object.section === id)
-      expect(section.disabled).toBe(objects.length === 0)
-      const homeLink = mcp.sections.find((section) => section.id === 'home')!.items
-        .find((item) => item.type === 'link' && item.href === section.href)
-      expect(homeLink?.type === 'link' && Boolean(homeLink.disabled)).toBe(objects.length === 0)
-      expect(section.href).toBe(`/${slug}/next/mcp/${id}/`)
-      expect(section.items.slice(1)).toEqual(objects.map((object) => ({ type: 'link', label: object.name, kind: object.kind, href: `/${slug}/next/${object.path}/` })))
-      for (const object of objects) expect(currentDocumentation(surfaces, `/${slug}/next/${object.path}/`).section.id).toBe(id)
-    }
-  })
+  it.each(Object.keys(MCP_REFERENCE))(
+    'exposes all three protocol sections for %s with only its advertised objects',
+    (slug) => {
+      const port = PORTS.find((entry) => entry.slug === slug)!
+      const surfaces = buildDocumentationSurfaces(slug, 'next', menus(port, 'next'))
+      const mcp = surfaces.find((surface) => surface.id === 'mcp')!
+      expect(mcp.sections.map((section) => section.id)).toEqual([
+        'home',
+        'guides',
+        'examples',
+        'tools',
+        'prompts',
+        'resources',
+        'reference',
+      ])
+      for (const id of ['tools', 'prompts', 'resources']) {
+        const section = mcp.sections.find((section) => section.id === id)!
+        const objects = mcpObjects(slug).filter((object) => object.section === id)
+        expect(section.disabled).toBe(objects.length === 0)
+        const homeLink = mcp.sections
+          .find((section) => section.id === 'home')!
+          .items.find((item) => item.type === 'link' && item.href === section.href)
+        expect(homeLink?.type === 'link' && Boolean(homeLink.disabled)).toBe(objects.length === 0)
+        expect(section.href).toBe(`/${slug}/next/mcp/${id}/`)
+        expect(section.items.slice(1)).toEqual(
+          objects.map((object) => ({
+            type: 'link',
+            label: object.name,
+            kind: object.kind,
+            href: `/${slug}/next/${object.path}/`,
+          })),
+        )
+        for (const object of objects)
+          expect(currentDocumentation(surfaces, `/${slug}/next/${object.path}/`).section.id).toBe(id)
+      }
+    },
+  )
 
   it('keeps ecosystem and upstream references reachable from the picker above the core API tree', () => {
-    const core: SidebarItem[] = [link('API reference', '/py/latest/reference/'),
+    const core: SidebarItem[] = [
+      link('API reference', '/py/latest/reference/'),
       link('Upstream reference', '/py/latest/api/'),
-      { type: 'link', label: 'docs.rs', href: 'https://docs.rs/libtmux', external: true }]
+      { type: 'link', label: 'docs.rs', href: 'https://docs.rs/libtmux', external: true },
+    ]
     const surfaces = buildDocumentationSurfaces('py', 'latest', { core })
     const { section } = currentDocumentation(surfaces, '/py/latest/reference/libtmux-server/')
     expect(section.alternatives?.map((item) => item.href)).toEqual(['/py/latest/api/', 'https://docs.rs/libtmux'])
diff --git a/site/test/documentation-picker-interaction.test.ts b/site/test/documentation-picker-interaction.test.ts
index 81efa3899..6c24dcb10 100644
--- a/site/test/documentation-picker-interaction.test.ts
+++ b/site/test/documentation-picker-interaction.test.ts
@@ -13,8 +13,28 @@ import { initDocumentationNavigation } from '../src/components/docs/documentatio
 let win: Window
 beforeEach(() => {
   win = new Window({ url: 'https://libtmux.org/en/cxx/latest/mcp/reference/arguments/' })
-  for (const name of ['window', 'document', 'location', 'HTMLElement', 'HTMLAnchorElement', 'HTMLDetailsElement', 'Element', 'Node', 'AbortController', 'Event']) {
-    vi.stubGlobal(name, name === 'window' ? win : name === 'document' ? win.document : name === 'location' ? win.location : win[name as keyof Window])
+  for (const name of [
+    'window',
+    'document',
+    'location',
+    'HTMLElement',
+    'HTMLAnchorElement',
+    'HTMLDetailsElement',
+    'Element',
+    'Node',
+    'AbortController',
+    'Event',
+  ]) {
+    vi.stubGlobal(
+      name,
+      name === 'window'
+        ? win
+        : name === 'document'
+          ? win.document
+          : name === 'location'
+            ? win.location
+            : win[name as keyof Window],
+    )
   }
   vi.spyOn(win.HTMLElement.prototype, 'getBoundingClientRect').mockReturnValue(new win.DOMRect(20, 10, 160, 30))
   vi.spyOn(win.HTMLElement.prototype, 'getClientRects').mockImplementation(function (this: HTMLElement) {
@@ -49,7 +69,10 @@ it('includes unmatched home exits in keyboard search without inventing an equiva
   expect(win.document.querySelector<HTMLElement>('#matched')!.hidden).toBe(true)
   expect(win.document.querySelector('[data-picker-status]')!.textContent).toBe('1 matching entries')
   let clicked = false
-  win.document.getElementById('home')!.addEventListener('click', (event) => { event.preventDefault(); clicked = true })
+  win.document.getElementById('home')!.addEventListener('click', (event) => {
+    event.preventDefault()
+    clicked = true
+  })
   input.dispatchEvent(new win.KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
   expect(clicked).toBe(true)
   // happy-dom does not give summary its browser-native focusability.
@@ -74,11 +97,22 @@ it('retains separate native-page home exits when fragment equivalents change', (
   const stale = win.document.querySelector('[data-picker-option][data-port="rs"]')!
   stale.setAttribute('title', 'Old destination')
   stale.setAttribute('aria-label', 'Old destination')
-  const context = { port: 'cxx', primary: 'native-one', symbols: {
-    'native-one': [], 'native-two': [{ port: 'rs', href: '/en/rs/latest/reference/server/', label: 'Server' }],
-  } }
-  win.document.body.insertAdjacentHTML('beforeend', `<script type="application/json" data-native-page-ports>${JSON.stringify(context)}</script>`)
-  const source = readFileSync(new URL('../src/components/docs/NativeSphinxScript.astro', import.meta.url), 'utf8').match(/<script>([\s\S]*?)<\/script>/)![1]
+  const context = {
+    port: 'cxx',
+    primary: 'native-one',
+    symbols: {
+      'native-one': [],
+      'native-two': [{ port: 'rs', href: '/en/rs/latest/reference/server/', label: 'Server' }],
+    },
+  }
+  win.document.body.insertAdjacentHTML(
+    'beforeend',
+    `<script type="application/json" data-native-page-ports>${JSON.stringify(context)}</script>`,
+  )
+  const source = readFileSync(
+    new URL('../src/components/docs/NativeSphinxScript.astro', import.meta.url),
+    'utf8',
+  ).match(/<script>([\s\S]*?)<\/script>/)![1]
   win.eval(ts.transpileModule(source, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText)
   const option = () => win.document.querySelector('[data-picker-option][data-port="rs"]')!
   expect(option().tagName).toBe('DIV')
@@ -102,22 +136,32 @@ it('retains separate native-page home exits when fragment equivalents change', (
   expect(option().hasAttribute('aria-label')).toBe(false)
 })
 
-
 const astroRequire = createRequire(realpathSync(new URL('../node_modules/astro/package.json', import.meta.url)))
-let pickerComponent: Promise<Parameters<Awaited<ReturnType<typeof experimental_AstroContainer.create>>['renderToString']>[0]> | undefined
+let pickerComponent:
+  | Promise<Parameters<Awaited<ReturnType<typeof experimental_AstroContainer.create>>['renderToString']>[0]>
+  | undefined
 
 async function renderPicker(entries: PagePortLink[], portSlug = 'julia') {
   pickerComponent ??= (async () => {
     const { transform } = await import(astroRequire.resolve('@astrojs/compiler-rs'))
     async function compile(relative: string, imports: Record<string, string>) {
       const file = new URL(relative, import.meta.url)
-      const source = readFileSync(file, 'utf8').replace(/<style[\s\S]*?<\/style>/g, '')
+      const source = readFileSync(file, 'utf8')
+        .replace(/<style[\s\S]*?<\/style>/g, '')
         .replace(/^import ['"][^'"]+\.css['"]\s*$/gm, '')
-      const result = await transform(source, { filename: file.pathname, internalURL: 'astro/compiler-runtime',
-        resultScopedSlot: true, resolvePath: (specifier: string) => specifier })
+      const result = await transform(source, {
+        filename: file.pathname,
+        internalURL: 'astro/compiler-runtime',
+        resultScopedSlot: true,
+        resolvePath: (specifier: string) => specifier,
+      })
       expect(result.diagnostics.filter((item: { severity: string }) => item.severity === 'error')).toEqual([])
-      let code = result.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
-      for (const [specifier, href] of Object.entries(imports)) code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(href))
+      let code = result.code.replaceAll(
+        '"astro/compiler-runtime"',
+        JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+      )
+      for (const [specifier, href] of Object.entries(imports))
+        code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(href))
       return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`
     }
     const root = new URL('../src/lib/site-root.ts', import.meta.url).href
@@ -125,7 +169,8 @@ async function renderPicker(entries: PagePortLink[], portSlug = 'julia') {
     const component = await compile('../src/components/PagePortSwitcher.astro', {
       '../lib/ports': new URL('../src/lib/ports.ts', import.meta.url).href,
       '../lib/branding': new URL('../src/lib/branding.ts', import.meta.url).href,
-      '../lib/site-root': root, './tmux/Logo.astro': logo,
+      '../lib/site-root': root,
+      './tmux/Logo.astro': logo,
     })
     return (await import(/* @vite-ignore */ component)).default
   })()
@@ -136,8 +181,12 @@ async function renderPicker(entries: PagePortLink[], portSlug = 'julia') {
 it('renders section fallbacks as truthful overview exits without repeated destination titles', async () => {
   const entries: PagePortLink[] = [
     { port: 'julia', name: 'Julia', links: [{ href: '/pr-42/en/julia/v1.2.3/topics/ownership/' }] },
-    { port: 'py', name: 'Python', links: [{ href: '/pr-42/en/py/stable/topics/', label: 'Topics overview', fallback: 'section' }],
-      home: { href: '/pr-42/en/py/stable/', label: 'Go to Python home' } },
+    {
+      port: 'py',
+      name: 'Python',
+      links: [{ href: '/pr-42/en/py/stable/topics/', label: 'Topics overview', fallback: 'section' }],
+      home: { href: '/pr-42/en/py/stable/', label: 'Go to Python home' },
+    },
     { port: 'lua', name: 'Lua', links: [], home: { href: '/pr-42/en/lua/latest/', label: 'Go to Lua home' } },
   ]
   await renderPicker(entries)
@@ -172,19 +221,34 @@ it('renders section fallbacks as truthful overview exits without repeated destin
   input.dispatchEvent(new win.KeyboardEvent('keydown', { key: 'ArrowDown', bubbles: true }))
   expect(win.document.activeElement).toBe(exit)
   let clicked = false
-  exit.addEventListener('click', (event) => { event.preventDefault(); clicked = true })
+  exit.addEventListener('click', (event) => {
+    event.preventDefault()
+    clicked = true
+  })
   input.dispatchEvent(new win.KeyboardEvent('keydown', { key: 'Enter', bubbles: true }))
   expect(clicked).toBe(true)
 })
 
 it('keeps single native distinctions accessible and genuine multiple choices visible', async () => {
   const entries: PagePortLink[] = [
-    { port: 'julia', name: 'Julia', links: [{ href: '/en/julia/latest/reference/libtmux-sessions/', label: 'sessions (function)' }] },
-    { port: 'powershell', name: 'PowerShell', links: [{ href: '/en/powershell/latest/reference/libtmux-get-tmuxsession/', label: 'Get-TmuxSession (cmdlet)' }] },
-    { port: 'ruby', name: 'Ruby', links: [
-      { href: '/en/ruby/latest/mcp/guides/connect-client/', label: 'Connect a client' },
-      { href: '/en/ruby/latest/mcp/source-guide/', label: 'MCP server guide' },
-    ] },
+    {
+      port: 'julia',
+      name: 'Julia',
+      links: [{ href: '/en/julia/latest/reference/libtmux-sessions/', label: 'sessions (function)' }],
+    },
+    {
+      port: 'powershell',
+      name: 'PowerShell',
+      links: [{ href: '/en/powershell/latest/reference/libtmux-get-tmuxsession/', label: 'Get-TmuxSession (cmdlet)' }],
+    },
+    {
+      port: 'ruby',
+      name: 'Ruby',
+      links: [
+        { href: '/en/ruby/latest/mcp/guides/connect-client/', label: 'Connect a client' },
+        { href: '/en/ruby/latest/mcp/source-guide/', label: 'MCP server guide' },
+      ],
+    },
   ]
   await renderPicker(entries)
   for (const entry of entries.slice(0, 2)) {
@@ -195,23 +259,32 @@ it('keeps single native distinctions accessible and genuine multiple choices vis
     expect(link.getAttribute('title')).toBe(`${entry.name}: ${entry.links[0].label}`)
   }
   const choices = [...win.document.querySelectorAll('[data-picker-option][data-port="ruby"]')]
-  expect(choices.map((choice) => choice.querySelector('small')?.textContent)).toEqual(['Connect a client', 'MCP server guide'])
+  expect(choices.map((choice) => choice.querySelector('small')?.textContent)).toEqual([
+    'Connect a client',
+    'MCP server guide',
+  ])
   expect(choices.map((choice) => choice.getAttribute('href'))).toEqual(entries[2].links.map((link) => link.href))
 })
 
-
 it.each([
   ['ts', 'builder.applyWorkspace'],
   ['powershell', 'LibTmux.Workspace\\Invoke-TmuxWorkspace'],
   ['julia', 'LibTmuxWorkspace.apply'],
 ])('renders source-verified workspace construction equivalents from %s', async (port, id) => {
   const symbol = API_MODELS[port].symbols.find((entry) => entry.id === id)!
-  const entries = pagePortLinks({ pagePath: `workspace/reference/${symbol.slug}`, portSlug: port,
-    version: 'latest', defaults: { py: 'stable' }, docs: [] })
+  const entries = pagePortLinks({
+    pagePath: `workspace/reference/${symbol.slug}`,
+    portSlug: port,
+    version: 'latest',
+    defaults: { py: 'stable' },
+    docs: [],
+  })
   await renderPicker(entries, port)
   const links = Array.from(win.document.querySelectorAll('a[data-port]'))
   const published = PORTS.filter((target) => productAvailable(target, 'workspace'))
-  expect(links.map((link) => link.getAttribute('data-port')).sort()).toEqual(published.map((target) => target.slug).sort())
+  expect(links.map((link) => link.getAttribute('data-port')).sort()).toEqual(
+    published.map((target) => target.slug).sort(),
+  )
   for (const [target, slug, kind] of [
     ['powershell', 'libtmux-workspace-invoke-tmuxworkspace', 'Invoke-TmuxWorkspace (cmdlet)'],
     ['julia', 'libtmuxworkspace-apply', 'apply (function)'],
@@ -220,8 +293,9 @@ it.each([
     expect(link.getAttribute('href')).toBe(`/${target}/latest/workspace/reference/${slug}/`)
     if (target !== port) expect(link.getAttribute('aria-label')).toContain(kind)
   }
-  expect(win.document.querySelector('a[data-port="py"]')!.getAttribute('href'))
-    .toBe('/py/stable/workspace/reference/tmuxp-workspace-builder-classicworkspacebuilder-build/')
+  expect(win.document.querySelector('a[data-port="py"]')!.getAttribute('href')).toBe(
+    '/py/stable/workspace/reference/tmuxp-workspace-builder-classicworkspacebuilder-build/',
+  )
   expect(win.document.querySelectorAll('a[data-port][aria-current="page"]')).toHaveLength(1)
   expect(win.document.querySelector('a[data-port][aria-current="page"]')!.getAttribute('data-port')).toBe(port)
   const unmatched = Array.from(win.document.querySelectorAll('.doc-picker-option--unmatched'))
@@ -229,41 +303,60 @@ it.each([
   for (const row of unmatched) {
     expect(row.tagName).toBe('DIV')
     expect(row.querySelector('a[data-port]')).toBeNull()
-    expect(row.querySelector('[data-picker-home]')?.getAttribute('href')).toBe(`/${row.getAttribute('data-port')}/latest/`)
+    expect(row.querySelector('[data-picker-home]')?.getAttribute('href')).toBe(
+      `/${row.getAttribute('data-port')}/latest/`,
+    )
     expect(row.hasAttribute('aria-disabled')).toBe(false)
   }
 })
 
-
-it.each(['workspace/guides', 'workspace/internals/guides'])('keeps %s counterparts separate from detailed native source articles', async (pagePath) => {
-  const guidePorts = ['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
-  const builderPorts = ['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
-  const docs = [
-    ...guidePorts.map((port) => ({ id: `ports/${port}/workspace/guides`, data: { port, product: 'workspace' } })),
-    ...builderPorts.map((port) => ({ id: `ports/${port}/workspace/internals/guides`, data: { port, product: 'workspace' } })),
-    ...['powershell', 'julia'].map((port) => ({ id: `_staged/${port}/workspace/source-guide`,
-      data: { port, product: 'workspace', route: 'workspace/source-guide', aliases: [] } })),
-  ]
-  const portSlug = pagePath === 'workspace/guides' ? 'py' : 'ts'
-  const entries = pagePortLinks({ pagePath, portSlug, version: portSlug === 'py' ? 'stable' : 'latest',
-    defaults: { py: 'stable' }, docs })
-  await renderPicker(entries, portSlug)
-  const matched = pagePath === 'workspace/guides' ? guidePorts : builderPorts
-  expect(Array.from(win.document.querySelectorAll('a[data-port]')).map((link) => link.getAttribute('data-port')).sort())
-    .toEqual([...matched].sort())
-  const unmatched = Array.from(win.document.querySelectorAll('.doc-picker-option--unmatched'))
-  expect(unmatched).toHaveLength(PORTS.length - matched.length)
-  for (const row of unmatched) {
-    const port = PORTS.find((target) => target.slug === row.getAttribute('data-port'))!
-    const workspace = productAvailable(port, 'workspace')
-    const version = port.slug === 'py' ? 'stable' : 'latest'
-    expect(row.tagName).toBe('DIV')
-    expect(row.hasAttribute('aria-disabled')).toBe(false)
-    expect(row.querySelector('a[data-port]')).toBeNull()
-    expect(row.textContent).toContain('No matching page')
-    expect(row.querySelector('[data-picker-home]')?.getAttribute('href'))
-      .toBe(`/${port.slug}/${version}/${workspace ? 'workspace/' : ''}`)
-    expect(row.querySelector('[data-picker-home]')?.getAttribute('aria-label'))
-      .toBe(`Go to ${port.name}${workspace ? ' Workspace Manager' : ''} home`)
-  }
-})
+it.each(['workspace/guides', 'workspace/internals/guides'])(
+  'keeps %s counterparts separate from detailed native source articles',
+  async (pagePath) => {
+    const guidePorts = ['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
+    const builderPorts = ['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
+    const docs = [
+      ...guidePorts.map((port) => ({ id: `ports/${port}/workspace/guides`, data: { port, product: 'workspace' } })),
+      ...builderPorts.map((port) => ({
+        id: `ports/${port}/workspace/internals/guides`,
+        data: { port, product: 'workspace' },
+      })),
+      ...['powershell', 'julia'].map((port) => ({
+        id: `_staged/${port}/workspace/source-guide`,
+        data: { port, product: 'workspace', route: 'workspace/source-guide', aliases: [] },
+      })),
+    ]
+    const portSlug = pagePath === 'workspace/guides' ? 'py' : 'ts'
+    const entries = pagePortLinks({
+      pagePath,
+      portSlug,
+      version: portSlug === 'py' ? 'stable' : 'latest',
+      defaults: { py: 'stable' },
+      docs,
+    })
+    await renderPicker(entries, portSlug)
+    const matched = pagePath === 'workspace/guides' ? guidePorts : builderPorts
+    expect(
+      Array.from(win.document.querySelectorAll('a[data-port]'))
+        .map((link) => link.getAttribute('data-port'))
+        .sort(),
+    ).toEqual([...matched].sort())
+    const unmatched = Array.from(win.document.querySelectorAll('.doc-picker-option--unmatched'))
+    expect(unmatched).toHaveLength(PORTS.length - matched.length)
+    for (const row of unmatched) {
+      const port = PORTS.find((target) => target.slug === row.getAttribute('data-port'))!
+      const workspace = productAvailable(port, 'workspace')
+      const version = port.slug === 'py' ? 'stable' : 'latest'
+      expect(row.tagName).toBe('DIV')
+      expect(row.hasAttribute('aria-disabled')).toBe(false)
+      expect(row.querySelector('a[data-port]')).toBeNull()
+      expect(row.textContent).toContain('No matching page')
+      expect(row.querySelector('[data-picker-home]')?.getAttribute('href')).toBe(
+        `/${port.slug}/${version}/${workspace ? 'workspace/' : ''}`,
+      )
+      expect(row.querySelector('[data-picker-home]')?.getAttribute('aria-label')).toBe(
+        `Go to ${port.name}${workspace ? ' Workspace Manager' : ''} home`,
+      )
+    }
+  },
+)
diff --git a/site/test/documentation-sidebar.test.ts b/site/test/documentation-sidebar.test.ts
index e7ad29caa..3cef2b530 100644
--- a/site/test/documentation-sidebar.test.ts
+++ b/site/test/documentation-sidebar.test.ts
@@ -15,9 +15,17 @@ beforeEach(() => {
   }
   frames = []
   const requestFrame = win.requestAnimationFrame.bind(win)
-  vi.spyOn(win, 'requestAnimationFrame').mockImplementation((callback) => { frames.push(callback); return requestFrame(() => {}) })
+  vi.spyOn(win, 'requestAnimationFrame').mockImplementation((callback) => {
+    frames.push(callback)
+    return requestFrame(() => {})
+  })
   Object.defineProperty(win.document, 'fonts', {
-    value: { ready: new Promise<void>((resolve) => { finishFonts = resolve }) }, configurable: true,
+    value: {
+      ready: new Promise<void>((resolve) => {
+        finishFonts = resolve
+      }),
+    },
+    configurable: true,
   })
 })
 afterEach(async () => {
@@ -47,9 +55,13 @@ function mount({ section = scope, rowOffset = 900, inert = false, hidden = false
   const nav = scroll.querySelector<HappyElement>('[data-section-navigation]')!
   const current = nav.querySelector<HappyElement>('#active')!
   const geometry = { rowOffset }
-  vi.spyOn(scroll, 'getClientRects').mockImplementation(() => (scroll.hidden ? [] : [scroll.getBoundingClientRect()]) as ReturnType<HappyElement['getClientRects']>)
+  vi.spyOn(scroll, 'getClientRects').mockImplementation(
+    () => (scroll.hidden ? [] : [scroll.getBoundingClientRect()]) as ReturnType<HappyElement['getClientRects']>,
+  )
   vi.spyOn(scroll, 'getBoundingClientRect').mockImplementation(() => new win.DOMRect(20, 100, 240, 400))
-  vi.spyOn(current, 'getBoundingClientRect').mockImplementation(() => new win.DOMRect(30, 100 + geometry.rowOffset - scroll.scrollTop, 220, 30))
+  vi.spyOn(current, 'getBoundingClientRect').mockImplementation(
+    () => new win.DOMRect(30, 100 + geometry.rowOffset - scroll.scrollTop, 220, 30),
+  )
   const start = () => initializeDocumentationSidebar(nav as unknown as HTMLElement)
   const language = nav.querySelector('details')!
   const secondary = nav.querySelectorAll('details')[1]
@@ -62,7 +74,9 @@ function flushFrames() {
 function saveState(top: number, branches = {}, section = scope) {
   win.sessionStorage.setItem(key(section), JSON.stringify({ top, branches }))
 }
-function readState(section = scope) { return JSON.parse(win.sessionStorage.getItem(key(section)) ?? 'null') }
+function readState(section = scope) {
+  return JSON.parse(win.sessionStorage.getItem(key(section)) ?? 'null')
+}
 
 it('reveals an off-screen active entry using only its real scroller', () => {
   const { start, scroll, current } = mount()
@@ -80,7 +94,8 @@ it('reveals an off-screen active entry using only its real scroller', () => {
 it('keeps an already visible destination at the saved reading position', () => {
   saveState(700)
   const { start, scroll } = mount()
-  start(); flushFrames()
+  start()
+  flushFrames()
   expect(scroll.scrollTop).toBe(700)
 })
 
@@ -101,37 +116,49 @@ it('saves current position before navigation and restores it in the same scope',
   win.document.dispatchEvent(new win.Event('astro:before-swap'))
   first.scroll.remove()
   const second = mount()
-  second.start(); flushFrames()
+  second.start()
+  flushFrames()
   expect(second.scroll.scrollTop).toBe(670)
   expect(second.secondary.open).toBe(true)
 })
 
-it.each(['/en/julia/latest/mcp/reference/', '/en/cxx/latest/workspace/reference/', '/en/cxx/stable/mcp/reference/', '/fr/cxx/latest/mcp/reference/'])(
-  'does not inherit state in %s', (section) => {
-    saveState(700, { [JSON.stringify([scope, 'Other'])]: true })
-    const { start, scroll, secondary } = mount({ section, rowOffset: 100 })
+it.each([
+  '/en/julia/latest/mcp/reference/',
+  '/en/cxx/latest/workspace/reference/',
+  '/en/cxx/stable/mcp/reference/',
+  '/fr/cxx/latest/mcp/reference/',
+])('does not inherit state in %s', (section) => {
+  saveState(700, { [JSON.stringify([scope, 'Other'])]: true })
+  const { start, scroll, secondary } = mount({ section, rowOffset: 100 })
+  start()
+  expect(scroll.scrollTop).toBe(0)
+  expect(secondary.open).toBe(false)
+})
+
+it.each(['wheel', 'pointerdown', 'keydown'])(
+  'does not override reader %s after font or frame completion',
+  async (event) => {
+    const { start, scroll, geometry } = mount()
     start()
-    expect(scroll.scrollTop).toBe(0)
-    expect(secondary.open).toBe(false)
+    scroll.dispatchEvent(new win.Event(event))
+    scroll.scrollTop = 500
+    geometry.rowOffset = 1200
+    finishFonts()
+    await Promise.resolve()
+    flushFrames()
+    win.dispatchEvent(new win.Event('resize'))
+    flushFrames()
+    expect(scroll.scrollTop).toBe(500)
   },
 )
 
-it.each(['wheel', 'pointerdown', 'keydown'])('does not override reader %s after font or frame completion', async (event) => {
-  const { start, scroll, geometry } = mount()
-  start()
-  scroll.dispatchEvent(new win.Event(event))
-  scroll.scrollTop = 500
-  geometry.rowOffset = 1200
-  finishFonts(); await Promise.resolve(); flushFrames()
-  win.dispatchEvent(new win.Event('resize')); flushFrames()
-  expect(scroll.scrollTop).toBe(500)
-})
-
 it('adjusts for delayed font layout before the reader interacts', async () => {
   const { start, scroll, geometry } = mount()
   start()
   geometry.rowOffset = 1200
-  finishFonts(); await Promise.resolve(); flushFrames()
+  finishFonts()
+  await Promise.resolve()
+  flushFrames()
   expect(scroll.scrollTop).toBe(1015)
 })
 
@@ -139,7 +166,9 @@ it('restores an inert mobile drawer on its first opening without a hidden copy o
   saveState(700)
   const mobile = mount({ inert: true })
   const desktop = mount({ hidden: true })
-  mobile.start(); desktop.start(); flushFrames()
+  mobile.start()
+  desktop.start()
+  flushFrames()
   win.dispatchEvent(new win.Event('pagehide'))
   expect(readState().top).toBe(700)
   expect(mobile.scroll.scrollTop).toBe(0)
@@ -160,14 +189,24 @@ it('captures drawer position before a navigation handler makes it inert', () =>
   const { start, scroll, current } = mount()
   start()
   scroll.scrollTop = 650
-  current.addEventListener('click', (event) => { event.preventDefault(); scroll.setAttribute('inert', '') })
+  current.addEventListener('click', (event) => {
+    event.preventDefault()
+    scroll.setAttribute('inert', '')
+  })
   current.dispatchEvent(new win.MouseEvent('click', { bubbles: true, cancelable: true }))
   expect(readState().top).toBe(650)
 })
 
 it.each(['blocked', 'malformed', 'negative', 'array'])('reveals the active entry with %s storage', (mode) => {
-  if (mode === 'blocked') vi.spyOn(win.sessionStorage, 'getItem').mockImplementation(() => { throw new Error('blocked') })
-  else win.sessionStorage.setItem(key(), mode === 'malformed' ? '{' : mode === 'negative' ? '{"top":-1,"branches":{}}' : '{"top":700,"branches":[]}')
+  if (mode === 'blocked')
+    vi.spyOn(win.sessionStorage, 'getItem').mockImplementation(() => {
+      throw new Error('blocked')
+    })
+  else
+    win.sessionStorage.setItem(
+      key(),
+      mode === 'malformed' ? '{' : mode === 'negative' ? '{"top":-1,"branches":{}}' : '{"top":700,"branches":[]}',
+    )
   const { start, scroll } = mount()
   start()
   expect(scroll.scrollTop).toBe(715)
@@ -205,8 +244,11 @@ it('ignores pending font and resize work after an Astro document swap', async ()
   start()
   win.document.dispatchEvent(new win.Event('astro:before-swap'))
   geometry.rowOffset = 1400
-  finishFonts(); await Promise.resolve(); flushFrames()
-  win.dispatchEvent(new win.Event('resize')); flushFrames()
+  finishFonts()
+  await Promise.resolve()
+  flushFrames()
+  win.dispatchEvent(new win.Event('resize'))
+  flushFrames()
   expect(scroll.scrollTop).toBe(715)
 })
 
@@ -220,12 +262,17 @@ it('keeps the last row reachable when the full header places the sidebar below i
     return win.innerHeight - inset - 16
   }
   vi.spyOn(scroll, 'getBoundingClientRect').mockImplementation(() => new win.DOMRect(20, 167, 240, height()))
-  vi.spyOn(current, 'getBoundingClientRect').mockImplementation(() => new win.DOMRect(30, 1567 - scroll.scrollTop, 220, 30))
+  vi.spyOn(current, 'getBoundingClientRect').mockImplementation(
+    () => new win.DOMRect(30, 1567 - scroll.scrollTop, 220, 30),
+  )
   Object.defineProperty(scroll, 'scrollTop', {
     get: () => Math.min(top, contentHeight - height()),
-    set: (value: number) => { top = Math.max(0, Math.min(value, contentHeight - height())) },
+    set: (value: number) => {
+      top = Math.max(0, Math.min(value, contentHeight - height()))
+    },
   })
-  start(); flushFrames()
+  start()
+  flushFrames()
   expect(scroll.getBoundingClientRect().bottom).toBe(826)
   expect(current.getBoundingClientRect().bottom).toBeLessThanOrEqual(826)
   expect(win.scrollY).toBe(0)
@@ -240,17 +287,20 @@ it('fits a moving desktop sidebar without overriding the reader position', () =>
   scroll.dispatchEvent(new win.Event('wheel'))
   scroll.scrollTop = 200
   top = 80
-  win.dispatchEvent(new win.Event('scroll')); flushFrames()
+  win.dispatchEvent(new win.Event('scroll'))
+  flushFrames()
   expect(scroll.style.maxHeight).toBe('calc(100dvh - 80px - 1rem)')
   expect(scroll.scrollTop).toBe(200)
   win.document.dispatchEvent(new win.Event('astro:before-swap'))
   top = 120
-  win.dispatchEvent(new win.Event('resize')); flushFrames()
+  win.dispatchEvent(new win.Event('resize'))
+  flushFrames()
   expect(scroll.style.maxHeight).toBe('calc(100dvh - 80px - 1rem)')
 })
 
 it('leaves the mobile drawer height with its own layout', () => {
   const { start, scroll } = mount()
-  start(); flushFrames()
+  start()
+  flushFrames()
   expect(scroll.style.maxHeight).toBe('')
 })
diff --git a/site/test/ec-copy-readiness.outer.test.ts b/site/test/ec-copy-readiness.outer.test.ts
index 27d199583..ce2bbd1f4 100644
--- a/site/test/ec-copy-readiness.outer.test.ts
+++ b/site/test/ec-copy-readiness.outer.test.ts
@@ -5,7 +5,7 @@ import { createRenderer } from 'astro-expressive-code'
 import { toHtml } from 'astro-expressive-code/hast'
 import ecConfig from '../ec.config.mjs'
 
-const command = "ruby -e '\n# quoted program\nputs \"ready\"\n'"
+const command = 'ruby -e \'\n# quoted program\nputs "ready"\n\''
 let browser: Browser
 let server: Server
 let origin: string
@@ -20,7 +20,7 @@ async function copiedText(page: Page, expected: string) {
   do {
     actual = await page.evaluate(() => navigator.clipboard.readText())
     if (actual === expected) return actual
-    await new Promise(resolve => setTimeout(resolve, 20))
+    await new Promise((resolve) => setTimeout(resolve, 20))
   } while (performance.now() < deadline)
   return actual
 }
@@ -39,9 +39,11 @@ beforeAll(async () => {
       return
     }
     response.setHeader('Content-Type', 'text/html')
-    response.end(`<!doctype html><html data-theme-mode="light"><head><style>${styles}</style></head><body>${body}<script type="module" src="/copy.js"></script></body></html>`)
+    response.end(
+      `<!doctype html><html data-theme-mode="light"><head><style>${styles}</style></head><body>${body}<script type="module" src="/copy.js"></script></body></html>`,
+    )
   })
-  await new Promise<void>(resolve => server.listen(0, '127.0.0.1', resolve))
+  await new Promise<void>((resolve) => server.listen(0, '127.0.0.1', resolve))
   const address = server.address()
   if (!address || typeof address === 'string') throw new Error('Expected local test server')
   origin = `http://127.0.0.1:${address.port}`
@@ -51,12 +53,14 @@ beforeAll(async () => {
 afterAll(async () => {
   releaseScript?.()
   await browser?.close()
-  await new Promise<void>(resolve => server?.close(() => resolve()))
+  await new Promise<void>((resolve) => server?.close(() => resolve()))
 })
 
 describe('code copy readiness', () => {
   it('enables Copy after its delayed script and copies later inserted blocks', async () => {
-    scriptReleased = new Promise(resolve => { releaseScript = resolve })
+    scriptReleased = new Promise((resolve) => {
+      releaseScript = resolve
+    })
     const context = await browser.newContext({ permissions: ['clipboard-read', 'clipboard-write'] })
     try {
       const page = await context.newPage()
@@ -64,16 +68,16 @@ describe('code copy readiness', () => {
       const button = page.getByRole('button', { name: 'Copy to clipboard', exact: true })
       await button.waitFor({ state: 'visible' })
       expect(await button.isDisabled()).toBe(true)
-      const pendingOpacity = await button.evaluate(element => getComputedStyle(element).opacity)
+      const pendingOpacity = await button.evaluate((element) => getComputedStyle(element).opacity)
       releaseScript()
       await page.waitForFunction(() => !document.querySelector<HTMLButtonElement>('.copy button')?.disabled)
       await page.waitForTimeout(350)
-      expect(await button.evaluate(element => getComputedStyle(element).opacity)).toBe(pendingOpacity)
+      expect(await button.evaluate((element) => getComputedStyle(element).opacity)).toBe(pendingOpacity)
       await page.evaluate(() => navigator.clipboard.writeText('unchanged'))
       await button.click()
       expect(await copiedText(page, command)).toBe(command)
 
-      await page.evaluate(markup => {
+      await page.evaluate((markup) => {
         document.querySelector('.expressive-code')?.remove()
         document.body.insertAdjacentHTML('afterbegin', markup)
         document.dispatchEvent(new Event('astro:page-load'))
diff --git a/site/test/ec-shell-prompt.test.ts b/site/test/ec-shell-prompt.test.ts
index 9d31f1a3f..898374359 100644
--- a/site/test/ec-shell-prompt.test.ts
+++ b/site/test/ec-shell-prompt.test.ts
@@ -3,13 +3,16 @@ import { createRenderer } from 'astro-expressive-code'
 import { select } from 'astro-expressive-code/hast'
 import { sessionLines, shellPrompt } from '../src/plugins/ec-shell-prompt.mjs'
 
-const copied = (lines: string[]) => sessionLines(lines)
-  .filter((line) => line.kind !== 'output').map((line) => line.text).join('\n')
+const copied = (lines: string[]) =>
+  sessionLines(lines)
+    .filter((line) => line.kind !== 'output')
+    .map((line) => line.text)
+    .join('\n')
 
 describe('console command continuations', () => {
   it('copies a multiline quoted program including comment lines, then omits output', async () => {
     const renderer = await createRenderer({ plugins: [shellPrompt()] })
-    const command = "ruby -e '\n# Ruby source\nputs \"ready\"\n'"
+    const command = 'ruby -e \'\n# Ruby source\nputs "ready"\n\''
     const rendered = await renderer.ec.render({ code: `$ ${command}\nready`, language: 'console' })
     const button = select('[data-code]', rendered.renderedGroupAst)
     expect(button?.properties.dataCode).toBe(command.replace(/\n/g, '\x7f'))
@@ -18,16 +21,25 @@ describe('console command continuations', () => {
   it.each(["'", '"', '`'])('keeps %s quote state across command lines', (quote) => {
     const lines = [`$ echo ${quote}first`, '$ literal prompt', `last${quote} &&`, '  next', 'output', '$ done']
     expect(copied(lines)).toBe(`echo ${quote}first\n$ literal prompt\nlast${quote} &&\n  next\ndone`)
-    expect(sessionLines(lines).map((line) => line.kind))
-      .toEqual(['prompt', 'command', 'command', 'command', 'output', 'prompt'])
+    expect(sessionLines(lines).map((line) => line.kind)).toEqual([
+      'prompt',
+      'command',
+      'command',
+      'command',
+      'output',
+      'prompt',
+    ])
   })
 
   it('renders complete chained clipboard bytes and omits session output', async () => {
     const renderer = await createRenderer({ plugins: [shellPrompt()] })
-    const code = '$ first &&\n  # prepare the next step\n\n  (second ||\n    third) |\n  fourth\noutput &&\nstill output'
+    const code =
+      '$ first &&\n  # prepare the next step\n\n  (second ||\n    third) |\n  fourth\noutput &&\nstill output'
     const rendered = await renderer.ec.render({ code, language: 'console' })
     const button = select('[data-code]', rendered.renderedGroupAst)
-    expect(button?.properties.dataCode).toBe('first &&\x7f  # prepare the next step\x7f\x7f  (second ||\x7f    third) |\x7f  fourth')
+    expect(button?.properties.dataCode).toBe(
+      'first &&\x7f  # prepare the next step\x7f\x7f  (second ||\x7f    third) |\x7f  fourth',
+    )
   })
 
   it('copies a complete dependency setup and nested subshell chain', () => {
@@ -40,13 +52,18 @@ describe('console command continuations', () => {
       'installed',
     ]
     expect(copied(lines)).toBe(lines.slice(0, -1).join('\n').slice(2))
-    expect(sessionLines(lines).map((line) => line.kind))
-      .toEqual(['prompt', 'command', 'command', 'command', 'command', 'output'])
+    expect(sessionLines(lines).map((line) => line.kind)).toEqual([
+      'prompt',
+      'command',
+      'command',
+      'command',
+      'command',
+      'output',
+    ])
   })
 
   it.each(['&&', '||', '|'])('copies the continuation after %s, then omits output', (operator) => {
-    expect(copied([`$ first ${operator}  `, '  second', 'output']))
-      .toBe(`first ${operator}  \n  second`)
+    expect(copied([`$ first ${operator}  `, '  second', 'output'])).toBe(`first ${operator}  \n  second`)
   })
 
   it.each([
@@ -61,16 +78,15 @@ describe('console command continuations', () => {
   })
 
   it('recognizes an operator before its trailing shell comment', () => {
-    expect(copied(['$ first && # install first', '  second', 'output']))
-      .toBe('first && # install first\n  second')
+    expect(copied(['$ first && # install first', '  second', 'output'])).toBe('first && # install first\n  second')
   })
 
   it.each(['  # install the next dependency', '', '   '])(
-    'keeps an operator waiting across a comment or blank line: %j', (between) => {
+    'keeps an operator waiting across a comment or blank line: %j',
+    (between) => {
       const lines = ['$ first &&', between, '  second', 'output']
       expect(copied(lines)).toBe(`first &&\n${between}\n  second`)
-      expect(sessionLines(lines).map((line) => line.kind))
-        .toEqual(['prompt', 'command', 'command', 'output'])
+      expect(sessionLines(lines).map((line) => line.kind)).toEqual(['prompt', 'command', 'command', 'output'])
     },
   )
 
@@ -109,8 +125,7 @@ describe('console command continuations', () => {
   it('keeps a word boundary before a backslash-newline', () => {
     const lines = ['$ echo alpha \\', '# comment', 'output']
     expect(copied(lines)).toBe('echo alpha \\\n# comment')
-    expect(sessionLines(lines).map((line) => line.kind))
-      .toEqual(['prompt', 'command', 'output'])
+    expect(sessionLines(lines).map((line) => line.kind)).toEqual(['prompt', 'command', 'output'])
   })
 
   it('does not let a quote in output consume the next prompt', () => {
diff --git a/site/test/edge-redirects.test.ts b/site/test/edge-redirects.test.ts
index 99cb80e2c..d5c2e7d56 100644
--- a/site/test/edge-redirects.test.ts
+++ b/site/test/edge-redirects.test.ts
@@ -4,40 +4,68 @@ import { describe, expect, it } from 'vitest'
 
 const source = readFileSync(new URL('../../infra/cloudfront-function.js', import.meta.url), 'utf8')
 const handler = runInNewContext(`${source.replace("import cf from 'cloudfront'", '')}\nhandler`, {
-  cf: { kvs: () => ({ get: async () => { throw new Error('No port default') } }) },
+  cf: {
+    kvs: () => ({
+      get: async () => {
+        throw new Error('No port default')
+      },
+    }),
+  },
 }) as (event: { request: { uri: string; querystring?: Record<string, unknown> } }) => Promise<{
-  statusCode?: number; uri?: string; headers?: { location: { value: string } }
+  statusCode?: number
+  uri?: string
+  headers?: { location: { value: string } }
 }>
 
 describe('tmux prose redirects at the edge', () => {
-  it.each(['guides', 'topics', 'concepts', 'examples'])('redirects %s indexes and descendants in one hop', async (section) => {
-    for (const root of ['/en', '/ja', '/pr-42/en']) for (const [suffix, target] of [
-      ['', '/'], ['/', '/'], ['/index.html', '/'],
-      ['/nested/page', '/nested/page/'], ['/nested/page/', '/nested/page/'],
-      ['/nested/page/index.html', '/nested/page/'], ['/nested/page.md', '/nested/page.md'],
-      ['/index.md', '/index.md'], ['.md', '.md'],
-      ['/json', '/json/'], ['/constructor', '/constructor/'],
-    ]) {
-      const result = await handler({ request: { uri: `${root}/${section}${suffix}` } })
-      expect(result.statusCode).toBe(301)
-      expect(result.headers?.location.value).toBe(`${root}/tmux/${section}${target}`)
-    }
-  })
+  it.each(['guides', 'topics', 'concepts', 'examples'])(
+    'redirects %s indexes and descendants in one hop',
+    async (section) => {
+      for (const root of ['/en', '/ja', '/pr-42/en'])
+        for (const [suffix, target] of [
+          ['', '/'],
+          ['/', '/'],
+          ['/index.html', '/'],
+          ['/nested/page', '/nested/page/'],
+          ['/nested/page/', '/nested/page/'],
+          ['/nested/page/index.html', '/nested/page/'],
+          ['/nested/page.md', '/nested/page.md'],
+          ['/index.md', '/index.md'],
+          ['.md', '.md'],
+          ['/json', '/json/'],
+          ['/constructor', '/constructor/'],
+        ]) {
+          const result = await handler({ request: { uri: `${root}/${section}${suffix}` } })
+          expect(result.statusCode).toBe(301)
+          expect(result.headers?.location.value).toBe(`${root}/tmux/${section}${target}`)
+        }
+    },
+  )
 
   it('preserves encoded query values, repeated parameters and empty values', async () => {
-    const result = await handler({ request: { uri: '/en/guides/getting-started/', querystring: {
-      prompt: { value: 'session%20switcher' },
-      tag: { multiValue: [{ value: 'a%2Fb' }, { value: 'a%26b' }] },
-      empty: { value: '' },
-    } } })
-    expect(result.headers?.location.value).toBe('/en/tmux/guides/getting-started/?prompt=session%20switcher&tag=a%2Fb&tag=a%26b&empty=')
+    const result = await handler({
+      request: {
+        uri: '/en/guides/getting-started/',
+        querystring: {
+          prompt: { value: 'session%20switcher' },
+          tag: { multiValue: [{ value: 'a%2Fb' }, { value: 'a%26b' }] },
+          empty: { value: '' },
+        },
+      },
+    })
+    expect(result.headers?.location.value).toBe(
+      '/en/tmux/guides/getting-started/?prompt=session%20switcher&tag=a%2Fb&tag=a%26b&empty=',
+    )
   })
 
-  it.each(['/en/tmux/guides/', '/en/go/latest/guides/', '/en/topics-extra/', '/en/prompts/', '/guides/'])('does not redirect unrelated or already canonical path %s', async (uri) => {
-    const result = await handler({ request: { uri } })
-    expect(result.statusCode).toBeUndefined()
-    expect(result.uri).toBe(`${uri}index.html`)
-  })
+  it.each(['/en/tmux/guides/', '/en/go/latest/guides/', '/en/topics-extra/', '/en/prompts/', '/guides/'])(
+    'does not redirect unrelated or already canonical path %s',
+    async (uri) => {
+      const result = await handler({ request: { uri } })
+      expect(result.statusCode).toBeUndefined()
+      expect(result.uri).toBe(`${uri}index.html`)
+    },
+  )
 
   it('keeps the complete function below the CloudFront source limit', () => {
     expect(Buffer.byteLength(source)).toBeLessThanOrEqual(10_240)
@@ -46,30 +74,45 @@ describe('tmux prose redirects at the edge', () => {
 
 describe('C# documentation redirects at the edge', () => {
   it('keeps locale, preview, version, declaration and export paths', async () => {
-    for (const root of ['/en', '/ja', '/zh-Hant', '/pr-42/en']) for (const [path, target] of [
-      ['', '/'], ['/', '/'], ['/index.html', '/'],
-      ['/latest', '/latest/'], ['/v0.0.0-alpha.20/', '/v0.0.0-alpha.20/'],
-      ['/pr-8/reference/libtmux-pane/', '/pr-8/reference/libtmux-pane/'],
-      ['/stable/api/libtmux.client', '/stable/api/libtmux.client/'],
-      ['/latest/reference/libtmux-server/index.html', '/latest/reference/libtmux-server/'],
-      ['/latest/reference/libtmux-server.md', '/latest/reference/libtmux-server.md'],
-      ['/latest/objects.inv', '/latest/objects.inv'], ['/docs.json', '/docs.json'],
-    ]) {
-      const result = await handler({ request: { uri: `${root}/dotnet${path}` } })
-      expect(result.statusCode).toBe(301)
-      expect(result.headers?.location.value).toBe(`${root}/csharp${target}`)
-    }
+    for (const root of ['/en', '/ja', '/zh-Hant', '/pr-42/en'])
+      for (const [path, target] of [
+        ['', '/'],
+        ['/', '/'],
+        ['/index.html', '/'],
+        ['/latest', '/latest/'],
+        ['/v0.0.0-alpha.20/', '/v0.0.0-alpha.20/'],
+        ['/pr-8/reference/libtmux-pane/', '/pr-8/reference/libtmux-pane/'],
+        ['/stable/api/libtmux.client', '/stable/api/libtmux.client/'],
+        ['/latest/reference/libtmux-server/index.html', '/latest/reference/libtmux-server/'],
+        ['/latest/reference/libtmux-server.md', '/latest/reference/libtmux-server.md'],
+        ['/latest/objects.inv', '/latest/objects.inv'],
+        ['/docs.json', '/docs.json'],
+      ]) {
+        const result = await handler({ request: { uri: `${root}/dotnet${path}` } })
+        expect(result.statusCode).toBe(301)
+        expect(result.headers?.location.value).toBe(`${root}/csharp${target}`)
+      }
   })
 
   it('preserves encoded and repeated query parameters', async () => {
-    const result = await handler({ request: { uri: '/en/dotnet/latest/reference/libtmux-server/', querystring: {
-      q: { value: 'a%20b' }, tag: { multiValue: [{ value: 'a%2Fb' }, { value: 'a%26b' }] }, empty: { value: '' },
-    } } })
-    expect(result.headers?.location.value).toBe('/en/csharp/latest/reference/libtmux-server/?q=a%20b&tag=a%2Fb&tag=a%26b&empty=')
+    const result = await handler({
+      request: {
+        uri: '/en/dotnet/latest/reference/libtmux-server/',
+        querystring: {
+          q: { value: 'a%20b' },
+          tag: { multiValue: [{ value: 'a%2Fb' }, { value: 'a%26b' }] },
+          empty: { value: '' },
+        },
+      },
+    })
+    expect(result.headers?.location.value).toBe(
+      '/en/csharp/latest/reference/libtmux-server/?q=a%20b&tag=a%2Fb&tag=a%26b&empty=',
+    )
   })
 
   it.each(['/en/csharp/latest/', '/en/fsharp/latest/', '/en/dotnetwork/', '/dotnet/', '/en/tmux/dotnet/'])(
-    'leaves unrelated and canonical paths alone: %s', async (uri) => {
+    'leaves unrelated and canonical paths alone: %s',
+    async (uri) => {
       const result = await handler({ request: { uri } })
       expect(result.statusCode).toBeUndefined()
       expect(result.uri).toBe(`${uri}index.html`)
diff --git a/site/test/example-sources.test.ts b/site/test/example-sources.test.ts
index 4267c3142..cdc26638b 100644
--- a/site/test/example-sources.test.ts
+++ b/site/test/example-sources.test.ts
@@ -39,10 +39,7 @@ interface Fence {
 }
 
 function fences(): Fence[] {
-  const files = execFileSync('fd', ['-e', 'md', '.', CONTENT], { encoding: 'utf8' })
-    .trim()
-    .split('\n')
-    .filter(Boolean)
+  const files = execFileSync('fd', ['-e', 'md', '.', CONTENT], { encoding: 'utf8' }).trim().split('\n').filter(Boolean)
 
   const out: Fence[] = []
   for (const path of files) {
@@ -90,9 +87,7 @@ describe('documented examples', () => {
 
   it('retains the expected coverage of revision-bound source inclusions', () => {
     const share = `${sourced.length}/${all.length}`
-    expect(sourced.length, `examples sourced from a port checkout (${share})`).toBeGreaterThanOrEqual(
-      SOURCED_FLOOR,
-    )
+    expect(sourced.length, `examples sourced from a port checkout (${share})`).toBeGreaterThanOrEqual(SOURCED_FLOOR)
   })
 
   it('reports source inclusion by port without claiming native execution', () => {
@@ -107,7 +102,10 @@ describe('documented examples', () => {
 
     const lines = [...byPort]
       .sort((a, b) => b[1].inline - a[1].inline)
-      .map(([port, r]) => `  ${port.padEnd(7)} ${String(r.sourced).padStart(3)} sourced, ${String(r.inline).padStart(3)} inline`)
+      .map(
+        ([port, r]) =>
+          `  ${port.padEnd(7)} ${String(r.sourced).padStart(3)} sourced, ${String(r.inline).padStart(3)} inline`,
+      )
 
     console.info(
       `example sources: ${sourced.length} of ${all.length} included from port source (execution coverage not inferred)\n` +
diff --git a/site/test/exports.test.ts b/site/test/exports.test.ts
index b30ddf0c7..2da682c49 100644
--- a/site/test/exports.test.ts
+++ b/site/test/exports.test.ts
@@ -3,7 +3,15 @@ import { join } from 'node:path'
 import { describe, expect, it } from 'vitest'
 import { Window } from 'happy-dom'
 import { API_MODEL_PORTS, PORTS } from '../src/lib/ports'
-import { SITE_BUILT, SITE_PREFIX, PREVIEW_PREFIX, productionPath, publishedHas, publishedPath, sitePath } from './site-root'
+import {
+  SITE_BUILT,
+  SITE_PREFIX,
+  PREVIEW_PREFIX,
+  productionPath,
+  publishedHas,
+  publishedPath,
+  sitePath,
+} from './site-root'
 
 /**
  * The published machine-readable artifacts, checked for shape and counts.
@@ -56,8 +64,7 @@ describeIfAssembled('published exports', () => {
 
     it('excludes preview and demo routes', () => {
       const index = readProduction('en/sitemap-index.xml')
-      const files = [...index.matchAll(/<loc>([^<]+)<\/loc>/g)]
-        .map((m) => new URL(m[1]).pathname.replace(/^\//, ''))
+      const files = [...index.matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => new URL(m[1]).pathname.replace(/^\//, ''))
       const urls = files.flatMap((f) => [...readProduction(f).matchAll(/<loc>([^<]+)<\/loc>/g)].map((m) => m[1]))
       expect(urls.length, 'sitemap has entries').toBeGreaterThan(0)
       expect(urls.filter((u) => /\/pr-|\/demo/.test(u))).toEqual([])
@@ -115,15 +122,17 @@ describeIfAssembled('published exports', () => {
     it('lists every port the site builds', () => {
       const m = manifest()
       expect(Array.isArray(m.ports), 'ports array').toBe(true)
-      expect(
-        (m.ports as Array<{ slug?: string }>).map((p) => p.slug).sort(),
-        'one entry per port in ports.ts',
-      ).toEqual(PORTS.map((p) => p.slug).sort())
+      expect((m.ports as Array<{ slug?: string }>).map((p) => p.slug).sort(), 'one entry per port in ports.ts').toEqual(
+        PORTS.map((p) => p.slug).sort(),
+      )
     })
 
     it.each(API_MODEL_PORTS)('advertises real $name reference sections and declaration links', async (port) => {
-      const reference = manifest().pages.find((page: { url: string; section: string }) =>
-        page.section === 'API reference' && new RegExp(`/${port.slug}/[^/]+/reference/$`).test(new URL(page.url).pathname))
+      const reference = manifest().pages.find(
+        (page: { url: string; section: string }) =>
+          page.section === 'API reference' &&
+          new RegExp(`/${port.slug}/[^/]+/reference/$`).test(new URL(page.url).pathname),
+      )
       expect(reference).toBeDefined()
       expect(reference.title).toBe('API reference')
       const root = new URL(reference.url).pathname.replace(/^\//, '')
@@ -135,8 +144,12 @@ describeIfAssembled('published exports', () => {
         const actual = [...template.content.querySelectorAll('.api-index-summary[id]')].map((node) => node.id)
         expect(reference.headings.map((heading: { id: string }) => heading.id)).toEqual(actual)
         expect(actual[0]).toBe('section-server')
-        if (port.slug === 'powershell') expect(reference.symbols.slice(0, 3).map((symbol: { name: string }) => symbol.name))
-          .toEqual(['New-TmuxServer', 'Get-TmuxServer', 'Connect-TmuxServer'])
+        if (port.slug === 'powershell')
+          expect(reference.symbols.slice(0, 3).map((symbol: { name: string }) => symbol.name)).toEqual([
+            'New-TmuxServer',
+            'Get-TmuxServer',
+            'Connect-TmuxServer',
+          ])
         else expect(reference.symbols[0].name).toBe('Server')
         for (const symbol of reference.symbols) {
           const target = new URL(symbol.url).pathname.replace(/^\//, '')
@@ -149,7 +162,8 @@ describeIfAssembled('published exports', () => {
         for (const members of Object.values(inventory.members) as string[][][]) {
           for (const [, slug, id] of members) {
             const destination = inventory.hrefs?.[id]
-              ? new URL(inventory.hrefs[id], reference.url).pathname.replace(/^\//, '') : join(root, slug)
+              ? new URL(inventory.hrefs[id], reference.url).pathname.replace(/^\//, '')
+              : join(root, slug)
             expect(has(join(destination, 'index.html')), `${reference.symbolIndexUrl}: ${id}`).toBe(true)
           }
         }
@@ -170,7 +184,8 @@ describeIfAssembled('published exports', () => {
   describe('native shell assets', () => {
     for (const version of ['latest', 'stable']) {
       it.skipIf(!has(`${SITE_PREFIX}py/${version}/api/api/libtmux.session/index.html`))(
-        `${version} uses compiled shared chrome and the native palette adapter`, () => {
+        `${version} uses compiled shared chrome and the native palette adapter`,
+        () => {
           const html = read(`py/${version}/api/api/libtmux.session/index.html`)
           expect(html).toContain('data-native-shell=')
           expect(html).toMatch(/href="[^"]*\/_astro\/[^"]+\.css"/)
@@ -187,13 +202,19 @@ describeIfAssembled('published exports', () => {
       const manifest = JSON.parse(read('page-links.json'))
       expect(manifest.schema).toBe(1)
       expect(Object.keys(manifest.indexes).sort()).toEqual(PORTS.map((port) => port.slug).sort())
-      expect(manifest.symbols.py['libtmux.Session.windows']).toEqual(expect.arrayContaining([
-        expect.objectContaining({ port: 'ts', href: expect.stringMatching(/\/ts\/[^/]+\/reference\/session-session-windows\/$/) }),
-      ]))
+      expect(manifest.symbols.py['libtmux.Session.windows']).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            port: 'ts',
+            href: expect.stringMatching(/\/ts\/[^/]+\/reference\/session-session-windows\/$/),
+          }),
+        ]),
+      )
       const targets = new Set([
         ...Object.values(manifest.indexes as Record<string, string>),
-        ...Object.values(manifest.symbols as Record<string, Record<string, { href: string }[]>>)
-          .flatMap((symbols) => Object.values(symbols).flatMap((entries) => entries.map((entry) => entry.href))),
+        ...Object.values(manifest.symbols as Record<string, Record<string, { href: string }[]>>).flatMap((symbols) =>
+          Object.values(symbols).flatMap((entries) => entries.map((entry) => entry.href)),
+        ),
       ])
       const missing = [...targets].filter((href) => {
         const path = new URL(href, 'https://libtmux.org').pathname.replace(/^\//, '')
@@ -207,7 +228,11 @@ describeIfAssembled('published exports', () => {
     it('is a complete cluster wherever it appears, including x-default', () => {
       // A partial cluster is worse than none: a page that advertises `ja` but
       // not `x-default` tells a crawler the site has no fallback.
-      for (const page of [`${SITE_PREFIX}index.html`, `${SITE_PREFIX}concepts/index.html`, `${PREVIEW_PREFIX}/ja/index.html`]) {
+      for (const page of [
+        `${SITE_PREFIX}index.html`,
+        `${SITE_PREFIX}concepts/index.html`,
+        `${PREVIEW_PREFIX}/ja/index.html`,
+      ]) {
         if (!has(page)) continue
         const html = readPublished(page)
         const tags = [...html.matchAll(/<link\b[^>]*hreflang="([^"]+)"/g)].map((m) => m[1])
diff --git a/site/test/external-links.test.ts b/site/test/external-links.test.ts
index 7d98d9845..92ad1e581 100644
--- a/site/test/external-links.test.ts
+++ b/site/test/external-links.test.ts
@@ -12,7 +12,9 @@ function page() {
     <a id="fragment" href="#parameter">Parameter</a><a id="mail" href="mailto:example@example.com">Mail</a>
     <a id="protocol" href="//docs.python.org/3/" title="Python reference" aria-description="More detail">Python</a>`
   const dispose = installExternalLinks(win as unknown as typeof window)
-  disposals.push(dispose, () => { void win.happyDOM.abort() })
+  disposals.push(dispose, () => {
+    void win.happyDOM.abort()
+  })
   return { win, doc: win.document, dispose }
 }
 describe('shared external link hints', () => {
@@ -23,7 +25,8 @@ describe('shared external link hints', () => {
     expect(link.getAttribute('aria-description')).toBe('External site: learn.microsoft.com')
     expect(link.innerHTML).toBe('<code>Example</code>')
     expect(link.hasAttribute('target')).toBe(false)
-    for (const id of ['relative', 'absolute', 'fragment', 'mail']) expect(doc.getElementById(id)!.hasAttribute('data-external-link')).toBe(false)
+    for (const id of ['relative', 'absolute', 'fragment', 'mail'])
+      expect(doc.getElementById(id)!.hasAttribute('data-external-link')).toBe(false)
     expect(doc.getElementById('protocol')!.getAttribute('title')).toBe('View on docs.python.org — Python reference')
   })
   it('handles changed hrefs and dynamically inserted links, and restores original metadata', async () => {
@@ -49,6 +52,8 @@ describe('shared external link hints', () => {
     const cleanup = installExternalLinks(win as unknown as typeof window)
     disposals.push(cleanup)
     expect(doc.getElementById('protocol')!.getAttribute('title')).toBe('View on docs.python.org — Python reference')
-    expect(doc.getElementById('protocol')!.getAttribute('aria-description')).toBe('More detail. External site: docs.python.org')
+    expect(doc.getElementById('protocol')!.getAttribute('aria-description')).toBe(
+      'More detail. External site: docs.python.org',
+    )
   })
 })
diff --git a/site/test/fixtures/attach-examples.json b/site/test/fixtures/attach-examples.json
index 6a10bda82..23f5e38af 100644
--- a/site/test/fixtures/attach-examples.json
+++ b/site/test/fixtures/attach-examples.json
@@ -46,7 +46,7 @@
       "files": [
         {
           "name": "connect.ts",
-          "sha256": "bd4f946b8fc2a24e1aab9d366402fa1260a3a05542023f3454e0686c72ba3d9d"
+          "sha256": "9691bffbd9e6dbc3270ad47bee181b6e7127c159d99e83d2af3dfc3fc348b4db"
         },
         {
           "name": "package.json",
@@ -143,7 +143,7 @@
       "files": [
         {
           "name": "Connect.java",
-          "sha256": "0dd7f4fef844f89ed6b6f424f3bce74daa43beb5280f43b12ab44cc1f4bf56a3"
+          "sha256": "c13bce86400f8b867208ae4ad4fe0343d251a354801692b6d0d78757e32a8947"
         },
         {
           "name": "run.sh",
@@ -171,7 +171,7 @@
       "files": [
         {
           "name": "Program.cs",
-          "sha256": "0936735d8c29c384b1040d37eca077690017d23eb6c21b9b6de489dde595f072"
+          "sha256": "a986a7f8c4ade6b77049efc48ca6446c176b04e302320adfa9904063682a89d1"
         },
         {
           "name": "Connect.csproj",
@@ -205,7 +205,7 @@
       "files": [
         {
           "name": "connect.cpp",
-          "sha256": "e7cf8fedee0d797982c249ed194885c23c5c8f6d29e583592105dd09a191f875"
+          "sha256": "a2c05e7358b0eec6d35ea6ab023414556e4dc5ccc9d89498daa4c3cbd7e1e644"
         },
         {
           "name": "CMakeLists.txt",
@@ -238,7 +238,7 @@
         {
           "name": "Connect.swift",
           "path": "Sources/Connect/Connect.swift",
-          "sha256": "9821b15aa0bb09ab626164f6f6a1e900f7263fafc5ff3d6297520505c8ebdc07"
+          "sha256": "384a3cf86ec4267d7e01e133eab68041e60ccaf4e43d865bb156f4e61e5e7bf0"
         },
         {
           "name": "Package.swift",
@@ -265,7 +265,7 @@
       ],
       "page": "ports/kotlin/guides/attaching-to-tmux",
       "shellRecipe": [
-        "git clone https://github.com/libtmux/libtmux-java libtmux-source &&\n  git -C libtmux-source checkout 85ebf6955e56703c5be74e2afd34a18309044741 &&\n  sh run.sh ./libtmux-source/gradlew --project-dir . run --console=plain --max-workers=2"
+        "git clone https://github.com/libtmux/libtmux-java libtmux-source &&\n  git -C libtmux-source checkout 85ebf6955e56703c5be74e2afd34a18309044741 &&\n  sh run.sh ./libtmux-source/gradlew --project-dir . run \\\n    --console=plain \\\n    --max-workers=2"
       ],
       "expectedOutput": "work",
       "files": [
@@ -306,13 +306,13 @@
       ],
       "page": "ports/scala/guides/attaching-to-tmux",
       "shellRecipe": [
-        "git clone https://github.com/libtmux/libtmux-java libtmux-source &&\n  git -C libtmux-source checkout 85ebf6955e56703c5be74e2afd34a18309044741 &&\n  sh run.sh ./libtmux-source/gradlew --project-dir . run --console=plain --max-workers=2"
+        "git clone https://github.com/libtmux/libtmux-java libtmux-source &&\n  git -C libtmux-source checkout 85ebf6955e56703c5be74e2afd34a18309044741 &&\n  sh run.sh ./libtmux-source/gradlew --project-dir . run \\\n    --console=plain \\\n    --max-workers=2"
       ],
       "expectedOutput": "work",
       "files": [
         {
           "name": "Connect.scala",
-          "sha256": "cbca6ab2fdb96a5b4291cdc9003a17d32a098c2b5f7cff159b03bd4ab63ca1a5"
+          "sha256": "4b471b0afcaba7699b6b2cc5d888e597e62903410a4aa25b1fef3cfd9f0a152f"
         },
         {
           "name": "build.gradle.kts",
@@ -352,11 +352,11 @@
       "files": [
         {
           "name": "Program.fs",
-          "sha256": "22a62e8423aa21ecb88aba93bf1cbf0520aa84c968ce18bb0559122b314517bc"
+          "sha256": "38599c54501b92742fefb97380f327b7a13fd57e6f701a7d16d0c9304e3adc44"
         },
         {
           "name": "Connect.fsproj",
-          "sha256": "314bfb2bef111e8885728a0065943a59594721011da4ac6ef0275aebd8f14bcd"
+          "sha256": "b35f62badfd9ff1220de1cede86aa28da25029f01d36ce81db6a3b46585618fd"
         },
         {
           "name": "run.sh",
@@ -385,7 +385,7 @@
       "files": [
         {
           "name": "connect.rb",
-          "sha256": "b683160fe4caefea0e65c4670519a2bfaa6c4f16f402fc86c730a42df2943f5d"
+          "sha256": "4779f7d61e2dc4c690da75e1c66e1e97fb414fcbd3a419cb673d2d17e4d141a0"
         },
         {
           "name": "Gemfile",
@@ -418,7 +418,7 @@
       "files": [
         {
           "name": "connect.lua",
-          "sha256": "4941e3f804521ec54e8692d83f6f3f22a0badb56affe4c24232ea28973fed2d6"
+          "sha256": "7ba7e904fce0a90788b82b515ca5f3a636ec59aae05c31e0cdea3e39ffc84dfd"
         },
         {
           "name": "run.sh",
diff --git a/site/test/fixtures/capture-examples.json b/site/test/fixtures/capture-examples.json
index f102bd012..8cf74b67b 100644
--- a/site/test/fixtures/capture-examples.json
+++ b/site/test/fixtures/capture-examples.json
@@ -59,7 +59,7 @@
       "files": [
         {
           "name": "main.go",
-          "sha256": "fff130e7c12cd990d4e8af309a6a1e269b0ae2bf9cabfc2fbb422a90ccf2e033"
+          "sha256": "49f698d16660c42a30f3faae755980c700317c2dc157b8a95e7c462eb7cb0485"
         },
         {
           "name": "go.mod",
@@ -86,7 +86,8 @@
       "files": [
         {
           "name": "main.rs",
-          "sha256": "a207a4ace3c97f9226503ccc90b03e81cbd1704333ffa6d44d4d6544deef7b67"
+          "path": "src/main.rs",
+          "sha256": "3303baed2644ed87b94cd3da01645a082e2888571ea428b0b54a306fc60e3271"
         },
         {
           "name": "Cargo.toml",
@@ -112,7 +113,7 @@
       "files": [
         {
           "name": "Capture.java",
-          "sha256": "91433bad174fb4db9330e36307db8face5739963bae754d94862cbbdbbec6c63"
+          "sha256": "5fa5102be8fe5da37e78698e585ee78d5971535aa9dafcec973fae46030ccd87"
         }
       ],
       "toolchain": [
@@ -135,7 +136,7 @@
       "files": [
         {
           "name": "Program.cs",
-          "sha256": "4fd0396a237012636ed7c8d74760a4ddd2614104c78d2dc211a5b1882cb6fc40"
+          "sha256": "409160aa295de88681e4fa1aa41efb65985d0ca32b005f4ff5e8cc54fec2e596"
         },
         {
           "name": "Capture.csproj",
@@ -162,7 +163,7 @@
       "files": [
         {
           "name": "capture.cpp",
-          "sha256": "023554185b1599bf626c7ff5f8eceafae48d68391bd2550d64c2673ad0d55f52"
+          "sha256": "f1fcb9899aeb6a3222c5cc30f584ca2470f4ff1840ee50059441067303d94604"
         },
         {
           "name": "CMakeLists.txt",
@@ -191,7 +192,7 @@
       "files": [
         {
           "name": "Capture.swift",
-          "sha256": "4f4258a1eb646d70712559f5a4d975d1cc36fd1805a77cbb8ddc63bc812db6da",
+          "sha256": "20d96174f5de2f13b88bceccde8566bfaacd074df38671a877647c3160b96a0c",
           "path": "Sources/Capture/Capture.swift"
         },
         {
@@ -302,7 +303,7 @@
       "files": [
         {
           "name": "Capture.scala",
-          "sha256": "1514add5014928157a9110c68bb3032476d921b6b9c5fcc8d74c9eed76f32be5"
+          "sha256": "cf47ddbd8e3628e960c98d17a773051ce16191487081ef6f7f60d634e1d5c553"
         },
         {
           "name": "build.gradle.kts",
@@ -385,11 +386,11 @@
       "files": [
         {
           "name": "Program.fs",
-          "sha256": "10e4320d65f9214988a3c2203576407398646a2e6ca6d829849e15a911df10c0"
+          "sha256": "85848540de83a075d81170e0d2a45db5664d11d099dac97fffed5deb88f1227d"
         },
         {
           "name": "Capture.fsproj",
-          "sha256": "314bfb2bef111e8885728a0065943a59594721011da4ac6ef0275aebd8f14bcd"
+          "sha256": "b35f62badfd9ff1220de1cede86aa28da25029f01d36ce81db6a3b46585618fd"
         }
       ],
       "toolchain": [
@@ -520,7 +521,7 @@
       "files": [
         {
           "name": "capture.lua",
-          "sha256": "a557a96fa3513a318cf6c17ac286d5629b1ffc05c53a466658a22a41891da89f"
+          "sha256": "5ab26d6084e67ba36d9b20cc0c8e72640ad23b0117ac1fa6e0d0b49098715307"
         },
         {
           "name": "run.sh",
diff --git a/site/test/fixtures/concept-examples.json b/site/test/fixtures/concept-examples.json
index 4e60542ea..d12ce806c 100644
--- a/site/test/fixtures/concept-examples.json
+++ b/site/test/fixtures/concept-examples.json
@@ -24,7 +24,7 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Hierarchy.kt",
@@ -32,7 +32,7 @@
         },
         {
           "name": "Refresh.kt",
-          "sha256": "1906afc0b0dee23b964f92560b834a4a308f7dc0545e269d2d66b21d6f942b9a"
+          "sha256": "e4545ba15ae3d825870a18583028de1a5343900fe25b09d8be007631454c78fb"
         }
       ],
       "shellRecipe": [
@@ -77,15 +77,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Local.kt",
-          "sha256": "1b24c8458c02b970db86394e03e45917035548082ecdf5c1576cd6fd54671802"
+          "sha256": "c61816af1d80a96098f816d28671a9b6aa283cd3e8f7ed6a9ff7b652219316aa"
         },
         {
           "name": "Cardinality.kt",
-          "sha256": "4e544e598603d444598d92cb6405b7e11ef8ea38e20b6c11c0d5f4d16e493108"
+          "sha256": "9bf4697fcea47bdc03979a49488ca954c22577d48fa353a7cd7d07dd3f687f15"
         },
         {
           "name": "Relations.kt",
@@ -139,15 +139,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Local.kt",
-          "sha256": "1b24c8458c02b970db86394e03e45917035548082ecdf5c1576cd6fd54671802"
+          "sha256": "c61816af1d80a96098f816d28671a9b6aa283cd3e8f7ed6a9ff7b652219316aa"
         },
         {
           "name": "Control.kt",
-          "sha256": "5617b3a3967ccf5911d9b8adaa4a7790b1ee2dbdc4b2af7de316692945675bea"
+          "sha256": "a79cd6563e506a0b93084ae7efec98bb8ef30766f7384f88f9b2286e83343941"
         }
       ],
       "shellRecipe": [
@@ -191,15 +191,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Layout.kt",
-          "sha256": "2ce63e4cbd402cd9c693238d5aac1dd4e1ef69ce765b319bf4dc25ad06987e29"
+          "sha256": "6360b5ce307633a1ab2542d51c1a6f1860936b2b4802fdce2931d3a0de3e3f8c"
         },
         {
           "name": "ReuseLayout.kt",
-          "sha256": "3c927e91817bb570a90d7f736d3eea9437bd97a70f4d67dee4a64d5ff4c9aa57"
+          "sha256": "c0dad07a81c793688d28f710eb5c68448388abd376845001d45120149e58245e"
         }
       ],
       "shellRecipe": [
@@ -242,15 +242,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Hierarchy.scala",
-          "sha256": "bf83e9625aed62a5585f403de180f83f163de4292ae5f53d333ba9c1dd06a91f"
+          "sha256": "c88effcec5a97aa9d59b8a312296dac3d7bce2734280ac79f60e939be54e232b"
         },
         {
           "name": "Refresh.scala",
-          "sha256": "7ed6ee12473851261ef6117b57841fcc420bf22635e306b8c054795af15a75a8"
+          "sha256": "23e8304ee244fcd33c4c282d5673d8b3311ebafd84128aae85d1954ab356aade"
         }
       ],
       "shellRecipe": [
@@ -295,19 +295,19 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Local.scala",
-          "sha256": "7d714f11710c2a1cf613d6e9a2c2bd43547f2b6a183c758178298a1fe8f90599"
+          "sha256": "e8d398460ace7d1ab5ed293018154afd303507a32251451bac4b19e415efc07e"
         },
         {
           "name": "Cardinality.scala",
-          "sha256": "2abf4f046a9253958c1d6a25ceb0b41f2a0bbcd70b62f42242a736e5b603c60c"
+          "sha256": "2674927901c34dd1ad9ce3185aaad38cd717883afaaf9aca024bdacd530bd8c3"
         },
         {
           "name": "Relations.scala",
-          "sha256": "a197b7e27f24d7c5717cd5cd28f215977471e5791c9f4470aefcfc4d2f1048d2"
+          "sha256": "2c3da9b4d1da11839e683709b67cb010ee1472f499004c76ce9c2b1a8e154d7e"
         }
       ],
       "shellRecipe": [
@@ -357,15 +357,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Local.scala",
-          "sha256": "7d714f11710c2a1cf613d6e9a2c2bd43547f2b6a183c758178298a1fe8f90599"
+          "sha256": "e8d398460ace7d1ab5ed293018154afd303507a32251451bac4b19e415efc07e"
         },
         {
           "name": "Control.scala",
-          "sha256": "a541715d9c976c57716a679524d060579c13cf276890f0b74732ec326b680f62"
+          "sha256": "51a6e43b0cbad13dc28998c139aeaed2ceef34e6559dd9730415930c02b7de2b"
         }
       ],
       "shellRecipe": [
@@ -409,15 +409,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "ea8339a28da6dd07d7c71bc1e264b246b0ea4561865e11d48b3642448a251bee"
+          "sha256": "78c9734d6ca38db8174235ec6b11631c61a307e02d760fe1b154fefdd4671317"
         },
         {
           "name": "Layout.scala",
-          "sha256": "bc3501864a170b3f208064ef720fa104daf8e1e264101ebe8ad7e88708ffd451"
+          "sha256": "2e3827c5afeb06157fbb993ed558177dccc3d43d35ab5e59a9021ffc0da3c1fd"
         },
         {
           "name": "ReuseLayout.scala",
-          "sha256": "7b37add5e44fbb60fee277c95b6728c815826dac4869b749c8a737cce530f204"
+          "sha256": "bae66a13d43574a8f29dc0a1ff9f91b0c1ec3946fbcb6530794fad61b3576fa1"
         }
       ],
       "shellRecipe": [
@@ -448,25 +448,25 @@
       "files": [
         {
           "name": "Query.fsproj",
-          "sha256": "cede2d70f84c645ef1e609e648d1794abdd8d96fb8f0f957a274d11ea2aec212"
+          "sha256": "49978bf3f6e23f7d93cebd7be496f1210a8b6ae507a4a72c72fa5dc185087309"
         },
         {
           "name": "run.sh",
-          "sha256": "dacfb3ef36d757bb66b1c97bacc575348e2466866dee63d53b95895932f8e40b"
+          "sha256": "539612132bce53a3340847989cdb414e4661d5285ff9ea7ba1da2de53c7f4d51"
         },
         {
           "name": "Hierarchy.fs",
-          "sha256": "1b2b94d47c06e1f2ce86e46b3d55eb0576414e2f2e59d8d0328e94e206506046"
+          "sha256": "2ac5c1ec73d5530ebf97f2c2585d73caa74e2ec857667dde339fc2951e9023e3"
         },
         {
           "name": "Refresh.fs",
-          "sha256": "55e801b201571844a295b9b6f002632d0b34c45212773e998d251ac4fc4eaedf"
+          "sha256": "e73567aeb196e14d34a55c0cceef57893a2610aea3966243abfaea98bde85159"
         }
       ],
       "shellRecipe": [
         "git clone https://github.com/libtmux/libtmux-dotnet libtmux-source &&\n  git -C libtmux-source checkout 2d99ead5aba8d968e85dcac8c9a9a518452e6ba6",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Hierarchy \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Hierarchy",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Refresh \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Refresh"
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Hierarchy \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Hierarchy",
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Refresh \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Refresh"
       ],
       "expectedOutputs": [
         [],
@@ -493,30 +493,30 @@
       "files": [
         {
           "name": "Query.fsproj",
-          "sha256": "cede2d70f84c645ef1e609e648d1794abdd8d96fb8f0f957a274d11ea2aec212"
+          "sha256": "49978bf3f6e23f7d93cebd7be496f1210a8b6ae507a4a72c72fa5dc185087309"
         },
         {
           "name": "run.sh",
-          "sha256": "dacfb3ef36d757bb66b1c97bacc575348e2466866dee63d53b95895932f8e40b"
+          "sha256": "539612132bce53a3340847989cdb414e4661d5285ff9ea7ba1da2de53c7f4d51"
         },
         {
           "name": "Local.fs",
-          "sha256": "367291c85b89affaddbd6104932c4ab5e14b49fc01e339f2eb82ff67f0adbd15"
+          "sha256": "841dd1ab2a084d49a9801a0e96d3eafe5b4770568120a710fb9d47a8ece30e15"
         },
         {
           "name": "Cardinality.fs",
-          "sha256": "705ca5f30a953763a11d3bc206ffe647616d8537e4a15373f1da48c1bf1a88d9"
+          "sha256": "004dc67372e01216be2d3506bbb79f720aa6be8f96d6182580d4457b77c0c8bc"
         },
         {
           "name": "Relations.fs",
-          "sha256": "19d95e24c7a274257ba65e15fae9b773e0418e5266ef0436f5ba78c16e7d8040"
+          "sha256": "6b6e6b635f5b356a4d50d2ee9b72496c2bc1fc7bcf08696c5c2cf4fe33a757ef"
         }
       ],
       "shellRecipe": [
         "git clone https://github.com/libtmux/libtmux-dotnet libtmux-source &&\n  git -C libtmux-source checkout 2d99ead5aba8d968e85dcac8c9a9a518452e6ba6",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Local \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Local",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Cardinality \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Cardinality",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Relations \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Relations"
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Local \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Local",
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Cardinality \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Cardinality",
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Relations \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Relations"
       ],
       "expectedOutputs": [
         [],
@@ -547,25 +547,25 @@
       "files": [
         {
           "name": "Query.fsproj",
-          "sha256": "cede2d70f84c645ef1e609e648d1794abdd8d96fb8f0f957a274d11ea2aec212"
+          "sha256": "49978bf3f6e23f7d93cebd7be496f1210a8b6ae507a4a72c72fa5dc185087309"
         },
         {
           "name": "run.sh",
-          "sha256": "dacfb3ef36d757bb66b1c97bacc575348e2466866dee63d53b95895932f8e40b"
+          "sha256": "539612132bce53a3340847989cdb414e4661d5285ff9ea7ba1da2de53c7f4d51"
         },
         {
           "name": "Local.fs",
-          "sha256": "367291c85b89affaddbd6104932c4ab5e14b49fc01e339f2eb82ff67f0adbd15"
+          "sha256": "841dd1ab2a084d49a9801a0e96d3eafe5b4770568120a710fb9d47a8ece30e15"
         },
         {
           "name": "Control.fs",
-          "sha256": "f51c2714f86a4951f1717ec0f6fd565e551def94e70013dec597152f44b52031"
+          "sha256": "4c00937c95d195b862a5906a0e5538845bd58ce5e7438fe594bc16f498b9219d"
         }
       ],
       "shellRecipe": [
         "git clone https://github.com/libtmux/libtmux-dotnet libtmux-source &&\n  git -C libtmux-source checkout 2d99ead5aba8d968e85dcac8c9a9a518452e6ba6",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Local \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Local",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Control \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Control"
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Local \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Local",
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Control \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Control"
       ],
       "expectedOutputs": [
         [],
@@ -591,25 +591,25 @@
       "files": [
         {
           "name": "Query.fsproj",
-          "sha256": "cede2d70f84c645ef1e609e648d1794abdd8d96fb8f0f957a274d11ea2aec212"
+          "sha256": "49978bf3f6e23f7d93cebd7be496f1210a8b6ae507a4a72c72fa5dc185087309"
         },
         {
           "name": "run.sh",
-          "sha256": "dacfb3ef36d757bb66b1c97bacc575348e2466866dee63d53b95895932f8e40b"
+          "sha256": "539612132bce53a3340847989cdb414e4661d5285ff9ea7ba1da2de53c7f4d51"
         },
         {
           "name": "Layout.fs",
-          "sha256": "bb000c5be099288ee305204d32533c6296c498225654968698db282a4859ddc7"
+          "sha256": "8e979ee22c24dd0e26d66a3be41e1b8ad494e4c64df5c3b910347eab822f3c36"
         },
         {
           "name": "ReuseLayout.fs",
-          "sha256": "1b81e1fdf0b1a8346c9c5cf10add566798dc07c5418fed049d0a291c03d7b313"
+          "sha256": "abc68b09c62e636380196ed613f8672213bf84a5975a5e3ea782ca74fd1e51ba"
         }
       ],
       "shellRecipe": [
         "git clone https://github.com/libtmux/libtmux-dotnet libtmux-source &&\n  git -C libtmux-source checkout 2d99ead5aba8d968e85dcac8c9a9a518452e6ba6",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Layout \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Layout",
-        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=ReuseLayout \\\n  -p:DisableImplicitLibraryPacksFolder=true -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=ReuseLayout"
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=Layout \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=Layout",
+        "dotnet build Query.fsproj --maxcpucount:1 -p:Example=ReuseLayout \\\n    -p:DisableImplicitLibraryPacksFolder=true \\\n    -p:RestorePackagesPath=\"$PWD/.packages\" &&\n  sh run.sh dotnet run --project Query.fsproj --no-build -p:Example=ReuseLayout"
       ],
       "expectedOutputs": [
         [],
@@ -638,15 +638,15 @@
         },
         {
           "name": "run.sh",
-          "sha256": "c198606b019bc0d077c83c90032b6e690ed1901c718ddd0cbe8f88e0a077ec40"
+          "sha256": "212bee33d44fad20f36118e2f0e50611736c1bc18dea88281e07ff15a88a3031"
         },
         {
           "name": "Create.go",
-          "sha256": "a5b7ae2cd453887395709de50ff1ae6ccb9318ebbaa88ccf874b789a851ed3d9"
+          "sha256": "c6ad22fd6e46cceb3f4a48833cfbc2b03dc15de19876b6d833dd29123f0f4b5e"
         },
         {
           "name": "Snapshot.go",
-          "sha256": "c085f116c805cde587eebe0ad9d9189798b9191bab8b6f1ae402396a1fd17c03"
+          "sha256": "dbdab894b5f5e1a81e9a4f4375286307648dd960c90052dc6f72e5c46ccd6275"
         }
       ],
       "shellRecipe": [
@@ -684,19 +684,19 @@
         },
         {
           "name": "run.sh",
-          "sha256": "c198606b019bc0d077c83c90032b6e690ed1901c718ddd0cbe8f88e0a077ec40"
+          "sha256": "212bee33d44fad20f36118e2f0e50611736c1bc18dea88281e07ff15a88a3031"
         },
         {
           "name": "Local.go",
-          "sha256": "cdc231b445cf0ed10e74ddc80c486da7beaf46fe115f3b9072edef27a09c5305"
+          "sha256": "f987027fd532bbbf41ea4422a42411cb96019d69033d9552aee2e003ac19ce68"
         },
         {
           "name": "Cardinality.go",
-          "sha256": "6ccab5e42c7b50a29147d0066d0d3b3a113a9531449a17bf8dcb4913b63e4f5f"
+          "sha256": "69b6a6e1cabaa510b6ca438cad16704053c7d7b9995f6510a805fc558ba3ff85"
         },
         {
           "name": "Relations.go",
-          "sha256": "b68f5614cdd02bb8a9835c94fa00c588e2cfe412248a30be9ef1d7f298b3c9a8"
+          "sha256": "22fba1cfedbb44c91e4f79ffdf559ebf6e3245b7c619df70ed4270edabeea8c9"
         }
       ],
       "shellRecipe": [
@@ -744,15 +744,15 @@
         },
         {
           "name": "matching.rs",
-          "sha256": "5602d7f469302ca339aec0239f7b24a4f81ced3bdca6c39ade6d303a9b47e6db"
+          "sha256": "ee7441e432ddf77cb05a2d9d90cd8638fcd55cf609a5a435533cf972ceeef439"
         },
         {
           "name": "cardinality.rs",
-          "sha256": "abd96178295e9ac864a10ccdc4d156643d2efe0f0a20761cdee2840161399e7d"
+          "sha256": "c589e482f260192559b1c85aa40b50038170a3558306e3784385db908ecc8f7d"
         },
         {
           "name": "refresh.rs",
-          "sha256": "2252dc6a8e77d1c692be5c24cb4b76369325dffb923b11230eab25fb41bc7228"
+          "sha256": "3c749c2483ba89dbf6705b2eaf713369eae3e2a3d0bf349e15778da0f0668b56"
         }
       ],
       "shellRecipe": [
@@ -793,7 +793,7 @@
         },
         {
           "name": "subprocess.rs",
-          "sha256": "966b8ca918fbf5d3befb4ccfeefc4a6e274ed63e5c7933892d78ffec767b5b6b"
+          "sha256": "bb5a951d062c0258b5b12a1272876abebca64ba42c98ab68b3c2b5408a0306c6"
         }
       ],
       "shellRecipe": [
@@ -821,11 +821,11 @@
       "files": [
         {
           "name": "Cargo.toml",
-          "sha256": "385a4b4d48cdff06c12fc4d4906e0f665f70f19d09b418cd6943b73124ec0565"
+          "sha256": "846c98bc3ac4e886a41899509233c1fd2772d0ee15bc8a7082d88535635fa275"
         },
         {
           "name": "batching.rs",
-          "sha256": "aae01800c8c46c11e9a89106d41f8018eb5f52dfce131e6fb38d2184df8c6c50"
+          "sha256": "01720dc55cbf017ce588464ee2f616d82c90e227fd079e571da32246b348da25"
         }
       ],
       "shellRecipe": [
@@ -855,11 +855,11 @@
       "files": [
         {
           "name": "Cargo.toml",
-          "sha256": "3e1ab381bffedbfaa6bb11330b2c3c8c8d2ffcf4646f6d1662a66677d1ba1dcd"
+          "sha256": "3b3e6b941856c84a165e6a23df49a46ca2434282333db9014b8c275fea5bc29b"
         },
         {
           "name": "control.rs",
-          "sha256": "413bd653689bbb489be5054a06e2e2be75f8e6544674e8455557a2b6eecdeac1"
+          "sha256": "b51783e8adaa6da223490cbbe2b0edac6424b5651e685388d63e80dbb90292d6"
         }
       ],
       "shellRecipe": [
diff --git a/site/test/fixtures/guide-examples.json b/site/test/fixtures/guide-examples.json
index 9ed28346b..89f831e60 100644
--- a/site/test/fixtures/guide-examples.json
+++ b/site/test/fixtures/guide-examples.json
@@ -56,7 +56,7 @@
       "files": [
         {
           "name": "history.sh",
-          "sha256": "e328f0ec37798b1519c10d2e5d6009ce0c6904a28bec1158be52bc9c056de0bb"
+          "sha256": "7795084fc29d175fcb5a82ac228c3661f68707836b6476223f89817b051fb8fc"
         }
       ],
       "shellRecipe": [
diff --git a/site/test/fixtures/install-widget-script-semantics.html b/site/test/fixtures/install-widget-script-semantics.html
index bbb813dae..dd2fcb04b 100644
--- a/site/test/fixtures/install-widget-script-semantics.html
+++ b/site/test/fixtures/install-widget-script-semantics.html
@@ -1,15 +1,17 @@
 <!doctype html>
 <html lang="en">
-<head><title>Script evaluation fixture</title></head>
-<body>
-  <script id="classic-before">
-    document.documentElement.dataset.classicBefore = document.currentScript?.id ?? 'null'
-  </script>
-  <script id="module" type="module">
-    document.documentElement.dataset.module = document.currentScript?.id ?? 'null'
-  </script>
-  <script id="classic-after">
-    document.documentElement.dataset.classicAfter = document.currentScript?.id ?? 'null'
-  </script>
-</body>
+  <head>
+    <title>Script evaluation fixture</title>
+  </head>
+  <body>
+    <script id="classic-before">
+      document.documentElement.dataset.classicBefore = document.currentScript?.id ?? 'null'
+    </script>
+    <script id="module" type="module">
+      document.documentElement.dataset.module = document.currentScript?.id ?? 'null'
+    </script>
+    <script id="classic-after">
+      document.documentElement.dataset.classicAfter = document.currentScript?.id ?? 'null'
+    </script>
+  </body>
 </html>
diff --git a/site/test/fixtures/product-examples.json b/site/test/fixtures/product-examples.json
index c52749f10..527bb52ed 100644
--- a/site/test/fixtures/product-examples.json
+++ b/site/test/fixtures/product-examples.json
@@ -9,7 +9,7 @@
       "files": [
         {
           "name": "workspace.ts",
-          "sha256": "20905548b12c76a93a0c6c0e6f939ade736bcc1b753dbd767125a71bf26b87ca"
+          "sha256": "48f427838a8a24fffce10f32056c6e66cb5de168753b31430456d1aa4f60012d"
         },
         {
           "name": "package.json",
@@ -26,7 +26,7 @@
       "page": "ports/ts/workspace/internals/examples",
       "shellRecipe": [
         "mkdir workspace-example && cd workspace-example",
-        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \\\n    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin \\\n      https://github.com/libtmux/libtmux-ts.git && \\\n    git -C libtmux-source fetch --depth 1 origin \\\n      3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
         "bun install --production",
         "bun run workspace.ts"
       ]
@@ -39,7 +39,7 @@
       "files": [
         {
           "name": "mcp.ts",
-          "sha256": "982f01a2d52160b6fbc0ed982c98542c4c8341022c1dac9da10809083a1124f7"
+          "sha256": "417db454b49ea128e354223edb9d7e26ffd592051b1513238e7066612b7edcf1"
         },
         {
           "name": "package.json",
@@ -56,7 +56,7 @@
       "page": "ports/ts/mcp/examples",
       "shellRecipe": [
         "mkdir mcp-example && cd mcp-example",
-        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-ts.git && \\\n    git -C libtmux-source fetch --depth 1 origin 3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin \\\n      https://github.com/libtmux/libtmux-ts.git && \\\n    git -C libtmux-source fetch --depth 1 origin \\\n      3fe1ca654b81b8cbf4a13b777a001a3298c87a6f && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
         "bun install --production",
         "bun run mcp.ts"
       ]
@@ -69,7 +69,7 @@
       "files": [
         {
           "name": "Sources/WorkspaceExample/WorkspaceExample.swift",
-          "sha256": "17787f2ccf5e5d1bca44e113c2608810b8787caa6da9ecd65f371b5ba57c72b1"
+          "sha256": "50cf7f39f7c387e24d88678134b538c2c081f6c0efdefd51d779efa9bfb14f44"
         },
         {
           "name": "Package.swift",
@@ -86,7 +86,7 @@
       "page": "ports/swift/workspace/internals/examples",
       "shellRecipe": [
         "mkdir swift-workspace-example && cd swift-workspace-example && \\\n  mkdir -p Sources/WorkspaceExample",
-        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD",
+        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin \\\n    https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin \\\n    254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD",
         "swift run --jobs 2 WorkspaceExample"
       ]
     },
@@ -115,7 +115,7 @@
       "page": "ports/swift/mcp/examples",
       "shellRecipe": [
         "mkdir swift-mcp-example && cd swift-mcp-example && \\\n  mkdir -p Sources/MCPExample",
-        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD",
+        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin \\\n    https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin \\\n    254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD",
         "swift run --jobs 2 MCPExample"
       ]
     },
@@ -140,7 +140,7 @@
       "page": "ports/swift/mcp/guides",
       "shellRecipe": [
         "mkdir swift-mcp-client && cd swift-mcp-client",
-        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin 254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD && \\\n  swift build --package-path libtmux-source --product libtmux-mcp --jobs 2",
+        "git init libtmux-source && \\\n  git -C libtmux-source remote add origin \\\n    https://github.com/libtmux/libtmux-swift.git && \\\n  git -C libtmux-source fetch --depth=1 origin \\\n    254f8b2be7eb60cacc3ffcb3ea8e456784f582df && \\\n  git -C libtmux-source checkout --detach FETCH_HEAD && \\\n  swift build --package-path libtmux-source --product libtmux-mcp --jobs 2",
         "sh run-mcp.sh"
       ]
     },
@@ -152,7 +152,7 @@
       "files": [
         {
           "name": "src/main/java/McpExample.java",
-          "sha256": "784f78db838619a9cdbc4507fa0abbabf262fa43f975819519f785275bddc7c8"
+          "sha256": "8728c8529fcd10fc986639368a652e426916be659cacc369eabdb25c20d19171"
         },
         {
           "name": "settings.gradle.kts",
@@ -173,7 +173,7 @@
       ],
       "page": "ports/java/mcp/examples",
       "shellRecipe": [
-        "mkdir java-mcp-example && cd java-mcp-example && \\\n    git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-java.git && \\\n    git -C libtmux-source fetch --depth=1 origin 842228310449e879ebcaa3f910597757c9dbffd6 && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD && \\\n    mkdir -p src/main/java",
+        "mkdir java-mcp-example && cd java-mcp-example && \\\n    git init libtmux-source && \\\n    git -C libtmux-source remote add origin \\\n      https://github.com/libtmux/libtmux-java.git && \\\n    git -C libtmux-source fetch --depth=1 origin \\\n      842228310449e879ebcaa3f910597757c9dbffd6 && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD && \\\n    mkdir -p src/main/java",
         "./libtmux-source/gradlew --no-daemon --max-workers=2 -p . installDist",
         "./build/install/mcp-example/bin/mcp-example"
       ]
@@ -186,7 +186,7 @@
       "files": [
         {
           "name": "run-mcp.sh",
-          "sha256": "e3b697676591e62e98769a988d0002efcfa693474feb228656589a472b0744f4"
+          "sha256": "3c3246e2d5b15136e4d0b0d76150ded9baad3987e3afbd7af5805b2c3bd503aa"
         }
       ],
       "toolchain": [
@@ -200,7 +200,7 @@
       "page": "ports/java/mcp/guides",
       "shellRecipe": [
         "mkdir java-mcp-client && cd java-mcp-client",
-        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-java.git && \\\n    git -C libtmux-source fetch --depth=1 origin 842228310449e879ebcaa3f910597757c9dbffd6 && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD && \\\n    ./libtmux-source/gradlew --no-daemon --max-workers=2 \\\n    -p libtmux-source :libtmux-mcp:installDist",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin \\\n      https://github.com/libtmux/libtmux-java.git && \\\n    git -C libtmux-source fetch --depth=1 origin \\\n      842228310449e879ebcaa3f910597757c9dbffd6 && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD && \\\n    ./libtmux-source/gradlew --no-daemon --max-workers=2 \\\n    -p libtmux-source :libtmux-mcp:installDist",
         "sh run-mcp.sh"
       ]
     },
@@ -212,7 +212,7 @@
       "files": [
         {
           "name": "main.go",
-          "sha256": "8212bcec780cf5c69da03f90c9621318fc4f54e4f63d1b0147a32618173a60c5"
+          "sha256": "00cb53b40d67d587fe05489117bf84734682c0cd75db4d81782c1d7c9d1d5433"
         },
         {
           "name": "go.mod",
@@ -233,7 +233,7 @@
       "page": "ports/go/workspace/internals/examples",
       "shellRecipe": [
         "mkdir go-workspace-example && cd go-workspace-example",
-        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-go.git && \\\n    git -C libtmux-source fetch --depth=1 origin bb06e26e116e941813ca40bf45e7e3a47d38f52a && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin \\\n      https://github.com/libtmux/libtmux-go.git && \\\n    git -C libtmux-source fetch --depth=1 origin \\\n      bb06e26e116e941813ca40bf45e7e3a47d38f52a && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
         "go mod tidy",
         "go run ."
       ]
@@ -246,11 +246,11 @@
       "files": [
         {
           "name": "src/main.rs",
-          "sha256": "a35348dc9fa3b8db147aa11f253324845e6dee0730c9a65dd08314fd946d171a"
+          "sha256": "e5ef8236b74141a7097eb1eabf1dbfb301698bd8a8de2abe4689474848c896ba"
         },
         {
           "name": "Cargo.toml",
-          "sha256": "1255751db8fb75290d2db99649c1be104325c31be652500df07d95ad5cd16ac4"
+          "sha256": "4e4777c6f634fffe13fc53ca7f5b0fd2cfe3a5ff6285649649e41ded90f078b3"
         },
         {
           "name": "workspace.yaml",
@@ -267,7 +267,7 @@
       "page": "ports/rs/workspace/internals/examples",
       "shellRecipe": [
         "mkdir rust-workspace-example && cd rust-workspace-example && \\\n    mkdir src",
-        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin https://github.com/libtmux/libtmux-rs.git && \\\n    git -C libtmux-source fetch --depth=1 origin d4e08b4eaab62ef4eeedab79b47973ae9a1de310 && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
+        "git init libtmux-source && \\\n    git -C libtmux-source remote add origin \\\n      https://github.com/libtmux/libtmux-rs.git && \\\n    git -C libtmux-source fetch --depth=1 origin \\\n      d4e08b4eaab62ef4eeedab79b47973ae9a1de310 && \\\n    git -C libtmux-source checkout --detach FETCH_HEAD",
         "cargo run --quiet"
       ]
     },
@@ -308,7 +308,7 @@
       "files": [
         {
           "name": "snapshot-sessions.rb",
-          "sha256": "2df8b331308a9541b21b7c8325578fcdecb5f520b639542e7fe9cb6856341fee"
+          "sha256": "e199f960866900ea6d86be97af62575c578226b81e350e3ee0c2b6aa9587e731"
         }
       ],
       "toolchain": [
@@ -336,11 +336,11 @@
       "files": [
         {
           "name": "Cargo.toml",
-          "sha256": "5ec266b05567cb1799d2df65b3dcf6f5db69cab7c8878616d43f21da192d2562"
+          "sha256": "7c7f4c989307b8558a10cd0de051c0bc55e81c3b2575ff53b6212af51460cf7b"
         },
         {
           "name": "src/main.rs",
-          "sha256": "e3c7b08830177404e9c6c87b8680398a4983840b8ac3832bb7a461f5eaf6419e"
+          "sha256": "c4e72d88150e32fd86c4950c2878601aa8b48cba2effe72619776d61db984bf1"
         }
       ],
       "toolchain": [
@@ -371,7 +371,7 @@
         },
         {
           "name": "Program.cs",
-          "sha256": "b4c74bacf7abf45491f911e3ae1c6ccff35f46f57e3ff0aa679b16810d63ff4e"
+          "sha256": "3109d8145bd37f0959a6917ee22094ad41af733536d2425744e07e6dfc39afaa"
         }
       ],
       "toolchain": [
@@ -403,7 +403,7 @@
         },
         {
           "name": "Program.cs",
-          "sha256": "bd64d8460a0a04fd573250346c8a4511b7b001c9cbcdcfc00311f4197c452ebe"
+          "sha256": "5455e13e1c8ea9f1407b8c6aa25070d37c81542f2e7c85e3f87b634d66f14c1f"
         }
       ],
       "toolchain": [
@@ -435,7 +435,7 @@
         },
         {
           "name": "main.go",
-          "sha256": "4bf5af2cacf59ee249faf5b1a03c90989a4630f677bf2269333cdb3d23a8d992"
+          "sha256": "1814b076ea0a627ff6580f40daf31dc78826be4b027d80551d5807523277e34f"
         }
       ],
       "toolchain": [
@@ -469,7 +469,7 @@
         },
         {
           "name": "main.go",
-          "sha256": "463b621f2e258be2bb76bd510ef29477d2100b97d531bcfde816c7b54717d596"
+          "sha256": "887d4e5133063033225d24f1149706f2d87213acfb65c38e8869d901dbece1c3"
         }
       ],
       "toolchain": [
diff --git a/site/test/fixtures/query-examples.json b/site/test/fixtures/query-examples.json
index e98e4be9c..b9d706082 100644
--- a/site/test/fixtures/query-examples.json
+++ b/site/test/fixtures/query-examples.json
@@ -17,27 +17,27 @@
         },
         {
           "name": "matching.ts",
-          "sha256": "546bc696c2eedc1955b0a011b7144fad0ab502173e535a6fbb02bb1fce74f88b"
+          "sha256": "9be69c8742d22fbbce96f40bb5d47429ca8e8f875a1a8718ffa6dfd21b177e6e"
         },
         {
           "name": "single-result.ts",
-          "sha256": "e72643800ae243abfbab8af70b5b76eabc66a2bea2533cbade1024ffb992d584"
+          "sha256": "7d64ac4c00784f716ae7453077c5045a22f81e6cdfcf4e6294380e87a859d5d5"
         },
         {
           "name": "relations.ts",
-          "sha256": "e31da357f7b06b23a7ea943d500fc8595efe9c6469116f3136afa42106739e1b"
+          "sha256": "c8c6428a6445b8491adb5308dcd2d89c497958ef26ebcf51a63dea11b858176a"
         },
         {
           "name": "refresh.ts",
-          "sha256": "8b6b303c2c0a74b8d66771532dcd697fe4243a9dc17139890308ef939614083b"
+          "sha256": "59e45db0a5b3d751e6bc16e95d6d2a346dfdfe3b7f20d7496c8f47c66a451f08"
         },
         {
           "name": "query-document.ts",
-          "sha256": "8a50296a867ad9a33296906a83ada52fae56932b72b9c3a2c32989e687a13fd4"
+          "sha256": "2ad657e2b6640386a319cf4117b895825d7ef9e5d4db70ef0cbbe2c69768a065"
         },
         {
           "name": "tmux-filter.ts",
-          "sha256": "8f95f8507965ee6d6428c816c6735ad4ffd306f89f736875c1f8903f743c4fb3"
+          "sha256": "20ef29653996c1508c008b0bb2ac5da4c7b0d2c479a014fab26950ee89d9b534"
         }
       ],
       "shellRecipe": [
diff --git a/site/test/font-audit.test.ts b/site/test/font-audit.test.ts
index 0adea089a..a5eb54763 100644
--- a/site/test/font-audit.test.ts
+++ b/site/test/font-audit.test.ts
@@ -14,10 +14,11 @@ function audit(html: string) {
   scratch.push(path)
   writeFileSync(join(path, 'index.html'), html)
   const result = spawnSync(process.execPath, [checker, '--site', path, '--url', 'http://127.0.0.1:1', '--json'], {
-    encoding: 'utf8', timeout: 5000,
+    encoding: 'utf8',
+    timeout: 5000,
   })
   expect(result.error, result.stderr).toBeUndefined()
-  return { status: result.status, ...JSON.parse(result.stdout) as { notes: string[]; failures: string[] } }
+  return { status: result.status, ...(JSON.parse(result.stdout) as { notes: string[]; failures: string[] }) }
 }
 
 describe('font audit redirect exemptions', () => {
diff --git a/site/test/fsharp-api-examples.test.ts b/site/test/fsharp-api-examples.test.ts
index 830fd66f6..30c45753c 100644
--- a/site/test/fsharp-api-examples.test.ts
+++ b/site/test/fsharp-api-examples.test.ts
@@ -15,15 +15,23 @@ describe('verified complete F# API programs', () => {
     expect(examples).toHaveLength(52)
     expect(new Set(examples.map((example) => 'sourceProgramId' in example && example.sourceProgramId)).size).toBe(13)
     expect(new Set(examples.map((example) => example.page)).size).toBe(46)
-    const covered = model.symbols.filter((symbol) => symbol.doc?.examples?.some(
-      (block) => block.sourceUrl?.includes('/examples/LibTmux.FSharp.Examples/Programs/'))).map((symbol) => symbol.id)
+    const covered = model.symbols
+      .filter((symbol) =>
+        symbol.doc?.examples?.some((block) => block.sourceUrl?.includes('/examples/LibTmux.FSharp.Examples/Programs/')),
+      )
+      .map((symbol) => symbol.id)
     expect([...new Set(examples.map((example) => example.symbol))].sort()).toEqual(covered.sort())
   })
 
   it.each(examples)('keeps complete $sourceProgramId bytes on $symbol in Markdown and copy payloads', (example) => {
-    if (!('sourceProgramId' in example) || typeof example.sourceProgramId !== 'string' ||
-        !('sourceCompilerId' in example) || typeof example.sourceCompilerId !== 'string' ||
-        !('consoleBlocks' in example) || !example.consoleBlocks) {
+    if (
+      !('sourceProgramId' in example) ||
+      typeof example.sourceProgramId !== 'string' ||
+      !('sourceCompilerId' in example) ||
+      typeof example.sourceCompilerId !== 'string' ||
+      !('consoleBlocks' in example) ||
+      !example.consoleBlocks
+    ) {
       throw new Error(`${example.symbol}: missing source program receipt`)
     }
     const symbols = model.symbols.filter((symbol) => symbol.id === example.symbol)
@@ -34,7 +42,12 @@ describe('verified complete F# API programs', () => {
     const exported = fromMarkdown(markdown).children.filter((node) => node.type === 'code')
     expect(symbol.source.revision).toBe(example.sourceRevision)
     expect(example.page).toBe(`ports/fsharp/reference/${symbol.slug}`)
-    expect(example.sourceCompilerId.slice(2).replace(/\(.*$/, '').replace(/`{1,2}\d+$/, '')).toBe(symbol.id)
+    expect(
+      example.sourceCompilerId
+        .slice(2)
+        .replace(/\(.*$/, '')
+        .replace(/`{1,2}\d+$/, ''),
+    ).toBe(symbol.id)
     expect(example.files).toHaveLength(4)
     for (const file of example.files) {
       const label = `${example.symbol}/${file.name}`
@@ -52,8 +65,9 @@ describe('verified complete F# API programs', () => {
         expect(line.length).toBeLessThanOrEqual(100)
       }
     }
-    expect(example.consoleBlocks.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim()))
-      .toEqual(example.shellRecipe)
+    expect(example.consoleBlocks.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim())).toEqual(
+      example.shellRecipe,
+    )
     const output = blocks[example.consoleBlocks[1] + 1].code.trimEnd().split('\n')
     expect(example.expectedOutputs[1]).toEqual([...output, ...output])
     for (const index of example.consoleBlocks) {
diff --git a/site/test/home-hover-preview.test.ts b/site/test/home-hover-preview.test.ts
index 26ad0ba34..f51fe609a 100644
--- a/site/test/home-hover-preview.test.ts
+++ b/site/test/home-hover-preview.test.ts
@@ -27,9 +27,13 @@ function controls() {
   const show = vi.fn()
   const restore = vi.fn()
   const preview = bindHomeHoverPreview({
-    options: options as unknown as HTMLElement[], show, restore, signal: controller.signal,
+    options: options as unknown as HTMLElement[],
+    show,
+    restore,
+    signal: controller.signal,
   })
-  const enter = (index = 0, pointerType = 'mouse') => options[index].dispatchEvent(new win.PointerEvent('pointerenter', { pointerType }))
+  const enter = (index = 0, pointerType = 'mouse') =>
+    options[index].dispatchEvent(new win.PointerEvent('pointerenter', { pointerType }))
   const leave = (index = 0) => options[index].dispatchEvent(new win.PointerEvent('pointerleave'))
   return { options, show, restore, preview, enter, leave }
 }
diff --git a/site/test/install-widgets.test.ts b/site/test/install-widgets.test.ts
index 896afe55b..dd21aa0a5 100644
--- a/site/test/install-widgets.test.ts
+++ b/site/test/install-widgets.test.ts
@@ -31,8 +31,10 @@ const isJs = (el: Element) => {
   return !type || type === 'module' || type === 'text/javascript'
 }
 const isModuleOnly = (source: string) =>
-  /\bimport\.meta\b/.test(source) || /\bimport\s*\(/.test(source) ||
-  /\bimport\b\s*(?:[\w*{]|['"])/.test(source) || /\bexport\s/.test(source)
+  /\bimport\.meta\b/.test(source) ||
+  /\bimport\s*\(/.test(source) ||
+  /\bimport\b\s*(?:[\w*{]|['"])/.test(source) ||
+  /\bexport\s/.test(source)
 
 interface Loaded {
   window: Window
@@ -133,7 +135,9 @@ const precedes = (first: Element, second: Element) =>
 describe('saved package manager paint', () => {
   it('keys a companion package apart from its library', () => {
     const rules = pickerPaintRules()
-    expect(rules).toContain('html[data-pkg-manager-ts-workspace="6"] .lm-pkg-install__panel[data-manager-scope="ts-workspace"]')
+    expect(rules).toContain(
+      'html[data-pkg-manager-ts-workspace="6"] .lm-pkg-install__panel[data-manager-scope="ts-workspace"]',
+    )
     expect(rules).toContain('html[data-pkg-manager-ts="3"] .lm-pkg-install__panel[data-manager-scope="ts"]')
     // The library lists four managers; a seventh is the CLI's alone.
     expect(rules).not.toContain('html[data-pkg-manager-ts="6"]')
@@ -141,8 +145,9 @@ describe('saved package manager paint', () => {
 })
 
 describe('homepage preference before body parsing', () => {
-  const themeScript = readFileSync(new URL('../src/components/ThemeScript.astro', import.meta.url), 'utf8')
-    .match(/<script is:inline>([\s\S]*?)<\/script>/)![1]
+  const themeScript = readFileSync(new URL('../src/components/ThemeScript.astro', import.meta.url), 'utf8').match(
+    /<script is:inline>([\s\S]*?)<\/script>/,
+  )![1]
 
   it.each([
     ['?port=rs', 'py', 'rs'],
@@ -154,7 +159,10 @@ describe('homepage preference before body parsing', () => {
     const window = new Window({ url: `https://libtmux.org/en/${query}` })
     const { document } = window
     document.documentElement.setAttribute('data-home-ports', PORTS.map((port) => port.slug).join(' '))
-    document.documentElement.setAttribute('data-home-brands', JSON.stringify(Object.fromEntries(PORTS.map((port) => [port.slug, port.logoLanguage]))))
+    document.documentElement.setAttribute(
+      'data-home-brands',
+      JSON.stringify(Object.fromEntries(PORTS.map((port) => [port.slug, port.logoLanguage]))),
+    )
     if (saved) window.localStorage.setItem('libtmux-docs.package-install.port', saved)
     window.eval(themeScript)
     // Happy DOM does not model CSS cascade layers. Actual first-paint
@@ -177,9 +185,7 @@ describeIfBuilt('package install picker', () => {
     const { document } = load(PORT_HOME, url)
     const managers = document.querySelectorAll(`${CORE} .lm-pkg-install__manager`)
     expect(managers.length).toBe(4)
-    expect(visibleCommand(document, CORE)).toBe(
-      '$ npm install libtmux',
-    )
+    expect(visibleCommand(document, CORE)).toBe('$ npm install libtmux')
   })
 
   it('switches the command when a manager is clicked', () => {
@@ -187,9 +193,7 @@ describeIfBuilt('package install picker', () => {
     const pnpm = document.querySelector<HTMLElement>(`${CORE} .lm-pkg-install__manager[data-manager-value="1"]`)!
     pnpm.click()
     expect(pnpm.getAttribute('aria-selected')).toBe('true')
-    expect(visibleCommand(document, CORE)).toBe(
-      '$ pnpm add libtmux',
-    )
+    expect(visibleCommand(document, CORE)).toBe('$ pnpm add libtmux')
   })
 
   it('remembers the manager per port, and ignores one the port does not have', () => {
@@ -199,17 +203,13 @@ describeIfBuilt('package install picker', () => {
 
     // Restored on the next page.
     const next = load(PORT_HOME, url, { 'libtmux-docs.package-install.manager.ts': '3' })
-    expect(visibleCommand(next.document, CORE)).toBe(
-      '$ bun add libtmux',
-    )
+    expect(visibleCommand(next.document, CORE)).toBe('$ bun add libtmux')
 
     // Rust has one command; a saved index of 3 must not blank it. The key is
     // per port precisely so this cannot happen, but the guard is what makes a
     // hand-edited or stale value harmless too.
     const stale = load(PORT_HOME, url, { 'libtmux-docs.package-install.manager.ts': '99' })
-    expect(visibleCommand(stale.document, CORE)).toBe(
-      '$ npm install libtmux',
-    )
+    expect(visibleCommand(stale.document, CORE)).toBe('$ npm install libtmux')
   })
 
   it('moves between managers with the arrow keys', () => {
@@ -231,17 +231,13 @@ describeIfBuilt('package install picker', () => {
 
     const right = load(PORT_HOME, url)
     arrow(right, 'ArrowRight')
-    expect(visibleCommand(right.document, CORE)).toBe(
-      '$ pnpm add libtmux',
-    )
+    expect(visibleCommand(right.document, CORE)).toBe('$ pnpm add libtmux')
 
     // And wraps backwards off the first tab, so the strip is a loop rather
     // than a dead end at either edge.
     const left = load(PORT_HOME, url)
     arrow(left, 'ArrowLeft')
-    expect(visibleCommand(left.document, CORE)).toBe(
-      '$ bun add libtmux',
-    )
+    expect(visibleCommand(left.document, CORE)).toBe('$ bun add libtmux')
   })
 
   it('drops the language strip when the page shows one language', () => {
@@ -256,7 +252,7 @@ describeIfBuilt('package install picker', () => {
     expect(document.querySelector('.lm-mcp-install')?.getAttribute('data-port')).toBe('ts')
   })
 
-  it('keeps the workspace CLI\'s manager apart from the library\'s', () => {
+  it("keeps the workspace CLI's manager apart from the library's", () => {
     // Both panels belong to TypeScript. Keyed by port alone, choosing bunx,
     // the CLI's second tab, chose pnpm, the library's second.
     const { window, document } = load(PORT_HOME, url)
@@ -275,7 +271,8 @@ describeIfBuilt('package install picker', () => {
 
   /** The code of one command's cooldown variant, as the page would show it. */
   const variantCode = (document: Document, panel: string, manager: number, mode: string) =>
-    document.querySelector(`${panel} .lm-pkg-install__cmd[data-manager="${manager}"] [data-cooldown-variant="${mode}"] code`)
+    document
+      .querySelector(`${panel} .lm-pkg-install__cmd[data-manager="${manager}"] [data-cooldown-variant="${mode}"] code`)
       ?.textContent?.trim() ?? ''
 
   /** Drive a cooldown control the way a reader's change does. */
@@ -293,10 +290,12 @@ describeIfBuilt('package install picker', () => {
     expect(window.localStorage.getItem('libtmux-docs.mcp-install.cooldown.enabled')).toBe('1')
     expect(document.querySelector<HTMLInputElement>(`${CLI} [data-pkg-cooldown="toggle"]`)!.checked).toBe(true)
     expect(document.querySelector<HTMLInputElement>('.lm-mcp-install__cooldown-toggle')!.checked).toBe(true)
-    expect(variantCode(document, CORE, 0, 'days')).toBe('$ npm install \\\n    --min-release-age=7 \\\n    --min-release-age-exclude=libtmux \\\n    libtmux')
+    expect(variantCode(document, CORE, 0, 'days')).toBe(
+      '$ npm install \\\n    --min-release-age=7 \\\n    --min-release-age-exclude=libtmux \\\n    libtmux',
+    )
   })
 
-  it('writes the day count in each tool\'s unit', () => {
+  it("writes the day count in each tool's unit", () => {
     const loaded = load(PORT_HOME, url, { 'libtmux-docs.mcp-install.cooldown.enabled': '1' })
     const { window, document } = loaded
     change(loaded, document.querySelector<HTMLInputElement>(`${CLI} [data-pkg-cooldown="days"]`)!, '14')
@@ -316,8 +315,11 @@ describeIfBuilt('package install picker', () => {
     expect(variantCode(document, CLI, 0, 'bypass')).toBe('$ npx -y --min-release-age=0 @libtmux/workspace-cli --help')
     // Bun: the cooldown variant is the plain command, with the reason beside it.
     expect(variantCode(document, CORE, 3, 'days')).toBe('$ bun add libtmux')
-    expect(document.querySelector(`${CORE} .lm-pkg-install__cmd[data-manager="3"] [data-cooldown-variant="days"] .lm-pkg-install__note--cooldown`)?.textContent)
-      .toContain('cannot exempt libtmux')
+    expect(
+      document.querySelector(
+        `${CORE} .lm-pkg-install__cmd[data-manager="3"] [data-cooldown-variant="days"] .lm-pkg-install__note--cooldown`,
+      )?.textContent,
+    ).toContain('cannot exempt libtmux')
   })
 
   it('offers the workspace CLI picker on the workspace overview', () => {
@@ -335,7 +337,9 @@ describeIfGo('workspace install picker, Go', () => {
     expect(visibleCommand(document, panel)).toBe(
       '$ go install github.com/libtmux/libtmux-go/workspace/cmd/tmux-workspace@latest',
     )
-    expect(precedes(document.getElementById('install')!, document.getElementById('load-a-workspace-from-the-terminal')!)).toBe(true)
+    expect(
+      precedes(document.getElementById('install')!, document.getElementById('load-a-workspace-from-the-terminal')!),
+    ).toBe(true)
   })
 })
 
@@ -359,28 +363,32 @@ describeIfMcp('MCP install picker', () => {
     const client = html.getAttribute('data-mcp-install-client')
     const method = html.getAttribute('data-mcp-install-method')
     const scope = html.getAttribute('data-mcp-install-scope')
-    const cooldown = html.getAttribute('data-mcp-install-cooldown-enabled') === '1'
-      ? (html.getAttribute('data-mcp-install-cooldown-type') ?? 'days')
-      : 'off'
-    const panel = (mode: string) => document.querySelector<HTMLElement>(
-      `.lm-mcp-install__panel[data-client="${client}"][data-method="${method}"]` +
-        `[data-scope="${scope}"][data-cooldown="${mode}"]`,
-    )
+    const cooldown =
+      html.getAttribute('data-mcp-install-cooldown-enabled') === '1'
+        ? (html.getAttribute('data-mcp-install-cooldown-type') ?? 'days')
+        : 'off'
+    const panel = (mode: string) =>
+      document.querySelector<HTMLElement>(
+        `.lm-mcp-install__panel[data-client="${client}"][data-method="${method}"]` +
+          `[data-scope="${scope}"][data-cooldown="${mode}"]`,
+      )
     // A port without a cooldown axis renders only its `off` panels.
     return panel(cooldown) ?? panel('off')
   }
 
-  it('installs this port\'s server, not Python\'s', () => {
+  it("installs this port's server, not Python's", () => {
     const { document } = load(TS_MCP, url)
     expect(document.querySelector('.lm-mcp-install')?.getAttribute('data-port')).toBe('ts')
     expect(selectedPanel(document)?.textContent).toContain('npx -y @libtmux/mcp')
   })
 
-  it('offers npm\'s cooldown and bypass', () => {
+  it("offers npm's cooldown and bypass", () => {
     const { document } = load(TS_MCP, url)
     expect(document.querySelectorAll('.lm-mcp-install__cooldown-control').length).toBe(1)
     const cell = (method: string, cooldown: string) =>
-      document.querySelector(`.lm-mcp-install__panel[data-client="claude-code"][data-method="${method}"][data-scope="local"][data-cooldown="${cooldown}"]`)?.textContent ?? ''
+      document.querySelector(
+        `.lm-mcp-install__panel[data-client="claude-code"][data-method="${method}"][data-scope="local"][data-cooldown="${cooldown}"]`,
+      )?.textContent ?? ''
     expect(cell('npx', 'bypass')).toContain('npx -y --min-release-age=0 @libtmux/mcp')
     expect(cell('global', 'days')).toContain('--min-release-age=7 \\')
     expect(cell('global', 'days')).toContain('--min-release-age-exclude=@libtmux/mcp \\')
@@ -445,9 +453,9 @@ describeIfPyMcp('MCP install picker, Python', () => {
   it('still offers uvx and its cooldown control', () => {
     const { document } = load(PY_MCP, `https://libtmux.org/${SITE_PREFIX}mcp/`)
     expect(document.querySelector('.lm-mcp-install')?.getAttribute('data-port')).toBe('py')
-    const methods = [
-      ...document.querySelectorAll('.lm-mcp-install__tab[data-tab-kind="method"]'),
-    ].map((t) => t.getAttribute('data-tab-value'))
+    const methods = [...document.querySelectorAll('.lm-mcp-install__tab[data-tab-kind="method"]')].map((t) =>
+      t.getAttribute('data-tab-value'),
+    )
     expect(methods).toEqual(['uvx', 'pipx', 'pip'])
     expect(document.querySelectorAll('.lm-mcp-install__cooldown-control').length).toBe(1)
   })
diff --git a/site/test/inventory-federation.test.ts b/site/test/inventory-federation.test.ts
index 9baaab1a4..7e3b539e8 100644
--- a/site/test/inventory-federation.test.ts
+++ b/site/test/inventory-federation.test.ts
@@ -35,24 +35,42 @@ describe('indexFor attaches the inventories', () => {
     expect(spans.find((span) => span.text === 'Connect-TmuxServer')).toMatchObject({ declaration: true })
     expect(spans.find((span) => span.text === 'Server')?.link?.href).toContain('.parameter.Server')
     expect(spans.find((span) => span.text === 'LibTmux.Server')?.link?.href).toContain('/csharp/latest/reference/')
-    const prose = index.linkText('Use Get-TmuxSnapshot with LibTmux.Server and -ErrorAction. The example uses $SocketPath.', command)
+    const prose = index.linkText(
+      'Use Get-TmuxSnapshot with LibTmux.Server and -ErrorAction. The example uses $SocketPath.',
+      command,
+    )
     const refs = prose.filter((span) => span.kind === 'ref')
-    expect(refs.map((span) => span.target)).toEqual(['Get-TmuxSnapshot', 'LibTmux.Server', '-ErrorAction', '$SocketPath'])
+    expect(refs.map((span) => span.target)).toEqual([
+      'Get-TmuxSnapshot',
+      'LibTmux.Server',
+      '-ErrorAction',
+      '$SocketPath',
+    ])
     expect(refs.every((span) => span.link)).toBe(true)
     expect(refs.at(-1)?.link?.href).toContain('about_variables')
     for (const [name, path] of [
-      ['System.Management.Automation.SwitchParameter', 'system.management.automation.switchparameter?view=powershellsdk-7.4.0'],
-      ['System.Management.Automation.ActionPreference', 'system.management.automation.actionpreference?view=powershellsdk-7.4.0'],
-      ['System.String', 'system.string'], ['System.Nullable', 'system.nullable-1'],
-    ]) expect(index.resolve(name)?.href).toBe(`https://learn.microsoft.com/dotnet/api/${path}`)
+      [
+        'System.Management.Automation.SwitchParameter',
+        'system.management.automation.switchparameter?view=powershellsdk-7.4.0',
+      ],
+      [
+        'System.Management.Automation.ActionPreference',
+        'system.management.automation.actionpreference?view=powershellsdk-7.4.0',
+      ],
+      ['System.String', 'system.string'],
+      ['System.Nullable', 'system.nullable-1'],
+    ])
+      expect(index.resolve(name)?.href).toBe(`https://learn.microsoft.com/dotnet/api/${path}`)
   })
   it('links Julia standard types and typed parameters within their own language', () => {
     const model = API_MODELS.julia
     const alias = model.symbols.find((symbol) => symbol.id === 'LibTmux.SessionID')!
     const index = indexFor(model, href)
     for (const [name, path] of [
-      ['AbstractString', 'strings/#Core.AbstractString'], ['Any', 'base/#Core.Any'],
-      ['Int64', 'numbers/#Core.Int64'], ['Bool', 'numbers/#Core.Bool'],
+      ['AbstractString', 'strings/#Core.AbstractString'],
+      ['Any', 'base/#Core.Any'],
+      ['Int64', 'numbers/#Core.Int64'],
+      ['Bool', 'numbers/#Core.Bool'],
       ['String', 'strings/#Core.String-Tuple%7BAbstractString%7D'],
     ]) {
       expect(index.resolve(name)?.href).toBe(`https://docs.julialang.org/en/v1/base/${path}`)
@@ -62,8 +80,10 @@ describe('indexFor attaches the inventories', () => {
       const spans = index.linkType(signature.raw!, alias, signature)
       expect(spans.map((span) => span.text).join('')).toBe(signature.raw)
       for (const parameter of signature.params) {
-        if (parameter.type === 'AbstractString') expect(spans.find((span) => span.text === 'AbstractString')?.link?.href)
-          .toBe('https://docs.julialang.org/en/v1/base/strings/#Core.AbstractString')
+        if (parameter.type === 'AbstractString')
+          expect(spans.find((span) => span.text === 'AbstractString')?.link?.href).toBe(
+            'https://docs.julialang.org/en/v1/base/strings/#Core.AbstractString',
+          )
       }
     }
     expect(index.resolve('MissingJuliaType')).toBeUndefined()
@@ -72,10 +92,16 @@ describe('indexFor attaches the inventories', () => {
     const model = API_MODELS.kotlin
     const member = model.symbols.find((symbol) => symbol.id === 'io.github.libtmux.kotlin.Server.liveState')!
     const index = indexFor(model, href)
-    const targets = Object.fromEntries(index.linkType(member.signatures[0].raw!, member)
-      .filter((span) => span.link).map((span) => [span.text, span.link!.href]))
+    const targets = Object.fromEntries(
+      index
+        .linkType(member.signatures[0].raw!, member)
+        .filter((span) => span.link)
+        .map((span) => [span.text, span.link!.href]),
+    )
     expect(targets.config).toContain('Server.config')
-    expect(targets.defaultTimeout).toContain('/java/latest/reference/io-github-libtmux-serverconfig-serverconfig-defaulttimeout/')
+    expect(targets.defaultTimeout).toContain(
+      '/java/latest/reference/io-github-libtmux-serverconfig-serverconfig-defaulttimeout/',
+    )
     expect(targets.toKotlinDuration).toContain('/kotlin.time/to-kotlin-duration.html')
     expect(targets.scope).toContain('.parameter.scope')
     expect(targets.CoroutineScope).toContain('/kotlinx.coroutines/-coroutine-scope/')
@@ -96,9 +122,12 @@ describe('indexFor attaches the inventories', () => {
     const index = indexFor(model, href)
     expect(index.resolve('Deferred', 'any', member)?.href).toContain('/cats/effect/kernel/Deferred.html')
     expect(index.resolve('Signal', 'any', member)?.href).toContain('/fs2-core_3/3.13.0/fs2/concurrent/Signal.html')
-    expect(index.resolve('io.github.libtmux.snapshot.ServerMirror', 'any', member)?.href)
-      .toContain('/java/latest/reference/io-github-libtmux-snapshot-servermirror-servermirror/')
-    expect(index.resolve('Handles.scala', 'any', member)?.href).toMatch(/github\.com\/libtmux\/libtmux-java\/blob\/[a-f0-9]{40}\/libtmux-scala-cats\/src\/main\/scala\/.*\/Handles\.scala$/)
+    expect(index.resolve('io.github.libtmux.snapshot.ServerMirror', 'any', member)?.href).toContain(
+      '/java/latest/reference/io-github-libtmux-snapshot-servermirror-servermirror/',
+    )
+    expect(index.resolve('Handles.scala', 'any', member)?.href).toMatch(
+      /github\.com\/libtmux\/libtmux-java\/blob\/[a-f0-9]{40}\/libtmux-scala-cats\/src\/main\/scala\/.*\/Handles\.scala$/,
+    )
     for (const prefix of ['io.github.libtmux.scaladsl', 'io.github.libtmux.scaladsl.cats']) {
       const server = model.symbols.find((symbol) => symbol.id === `${prefix}.Server`)!
       expect(index.resolve('Window', 'class', server)?.symbol?.id).toBe(`${prefix}.Window`)
@@ -128,9 +157,13 @@ describe('indexFor attaches the inventories', () => {
     const prose = createProseLinker('mcp')
     const utilityBase = 'https://www.typescriptlang.org/docs/handbook/utility-types.html#'
     const cases = [
-      ['Readonly', 'readonlytype'], ['Record', 'recordkeys-type'],
-      ['Partial', 'partialtype'], ['Pick', 'picktype-keys'], ['Omit', 'omittype-keys'],
-      ['ReturnType', 'returntypetype'], ['ThisType', 'thistypetype'],
+      ['Readonly', 'readonlytype'],
+      ['Record', 'recordkeys-type'],
+      ['Partial', 'partialtype'],
+      ['Pick', 'picktype-keys'],
+      ['Omit', 'omittype-keys'],
+      ['ReturnType', 'returntypetype'],
+      ['ThisType', 'thistypetype'],
     ]
     for (const [name, fragment] of cases) {
       const target = utilityBase + fragment
@@ -144,8 +177,12 @@ describe('indexFor attaches the inventories', () => {
     for (const [name, fragment] of cases.slice(0, 2)) {
       expect(spans.find((span) => span.text === name)?.link?.href).toBe(utilityBase + fragment)
     }
-    expect(product.resolve('Promise')?.href).toBe('https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise')
-    expect(product.resolve('AbortController')?.href).toBe('https://developer.mozilla.org/en-US/docs/Web/API/AbortController')
+    expect(product.resolve('Promise')?.href).toBe(
+      'https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise',
+    )
+    expect(product.resolve('AbortController')?.href).toBe(
+      'https://developer.mozilla.org/en-US/docs/Web/API/AbortController',
+    )
     expect(product.resolve('MissingUtilityType')).toBeUndefined()
     expect(indexFor(API_MODELS.java, href).resolve('Readonly')?.href).toBeUndefined()
   })
@@ -167,15 +204,21 @@ describe('indexFor attaches the inventories', () => {
       const index = indexFor(API_MODELS[port], href)
       for (const name of ['List', 'AbortController', 'str', 'Optional']) {
         const hit = index.resolve(name, 'class')
-        expect(hit?.href ?? '', `${port} resolved ${name} in another language`).not.toMatch(/docs\.python\.org|docs\.oracle\.com|developer\.mozilla\.org/)
+        expect(hit?.href ?? '', `${port} resolved ${name} in another language`).not.toMatch(
+          /docs\.python\.org|docs\.oracle\.com|developer\.mozilla\.org/,
+        )
       }
     }
   })
 
   it('links a workspace signature through the same inventories without sharing route caches', () => {
     const model = API_MODELS.java
-    const reader = model.symbols.find((symbol) => symbol.product === 'workspace'
-      && symbol.name === 'read' && symbol.source.file.endsWith('/WorkspaceBuilder.java'))!
+    const reader = model.symbols.find(
+      (symbol) =>
+        symbol.product === 'workspace' &&
+        symbol.name === 'read' &&
+        symbol.source.file.endsWith('/WorkspaceBuilder.java'),
+    )!
     expect(reader, 'WorkspaceBuilder.read declaration').toBeDefined()
     const signature = reader.signatures[0]
     const annotation = signature.params.find((param) => param.name === 'file')!.type!
@@ -191,7 +234,9 @@ describe('indexFor attaches the inventories', () => {
       expect(workspace?.href).toContain(`/java/${version}/workspace/reference/`)
       expect(productApiIndex(model, version)).toBe(product)
     }
-    expect(core.linkType(signature.returns!, reader).find((span) => span.text === 'Workspace')?.link?.href).toMatch(/^#/)
+    expect(core.linkType(signature.returns!, reader).find((span) => span.text === 'Workspace')?.link?.href).toMatch(
+      /^#/,
+    )
   })
 
   it('links dependency types in real product signatures and keeps their language scope', () => {
@@ -205,9 +250,15 @@ describe('indexFor attaches the inventories', () => {
     ] as const
     for (const [port, name, target] of cases) {
       const model = API_MODELS[port]
-      const symbol = model.symbols.find((entry) => entry.product === 'mcp'
-        && entry.signatures.some((signature) => [signature.returns, ...signature.params.map((param) => param.type)]
-          .some((annotation) => annotation?.includes(name))))!
+      const symbol = model.symbols.find(
+        (entry) =>
+          entry.product === 'mcp' &&
+          entry.signatures.some((signature) =>
+            [signature.returns, ...signature.params.map((param) => param.type)].some((annotation) =>
+              annotation?.includes(name),
+            ),
+          ),
+      )!
       expect(symbol, `${port} signature names ${name}`).toBeDefined()
       const link = productApiIndex(model, 'latest').linkType(name, symbol)[0].link
       expect(link?.external, `${port} ${name}`).toBe(true)
@@ -226,9 +277,10 @@ describe('each sidecar agrees with the .inv beside it', () => {
    */
   it.each(['python', 'jdk', 'dom', 'julia'])('%s', (name) => {
     const inv = readInventory(readFileSync(join(invDir, `${name}.inv`)))
-    const sidecar = JSON.parse(
-      readFileSync(join(invDir, `${name}.entries.json`), 'utf8'),
-    ) as { project: string; e: [string, string][] }
+    const sidecar = JSON.parse(readFileSync(join(invDir, `${name}.entries.json`), 'utf8')) as {
+      project: string
+      e: [string, string][]
+    }
 
     expect(sidecar.e.length, `${name}: entry count differs`).toBe(inv.entries.length)
     expect(sidecar.project).toBe(inv.project)
diff --git a/site/test/java-qualified-exports.test.ts b/site/test/java-qualified-exports.test.ts
index f9327f689..e581a6ce0 100644
--- a/site/test/java-qualified-exports.test.ts
+++ b/site/test/java-qualified-exports.test.ts
@@ -14,7 +14,7 @@ describe('Java names in copied Markdown', () => {
       expect(symbol).toBeDefined()
       const canonical = `https://libtmux.org/en/java/latest/reference/${symbol.slug}/`
       const text = symbolMarkdown({ model, symbol, canonical })
-      expect(text).toMatch(new RegExp(`^# ${name.replaceAll('.', '\\.') }\\n`))
+      expect(text).toMatch(new RegExp(`^# ${name.replaceAll('.', '\\.')}\\n`))
       expect(text).toContain('- **Module:** io.github.libtmux\n')
       expect(text).toContain(`- **Page:** ${canonical}\n`)
       if (symbol.signatures.length) expect(text).toContain(`${name}(`)
diff --git a/site/test/julia-signature.test.ts b/site/test/julia-signature.test.ts
index b87786e26..1f5f699b8 100644
--- a/site/test/julia-signature.test.ts
+++ b/site/test/julia-signature.test.ts
@@ -26,7 +26,9 @@ describe('Julia declaration layout', () => {
   it('distinguishes adjacent postfix adjoints from character literals in nested defaults', () => {
     for (const value of adjointDefaults) {
       const raw = `configure(value = ${value}, very_long_argument_name_to_force_multiline = nothing)`
-      expect(format(raw)).toBe(`configure(\n    value = ${value},\n    very_long_argument_name_to_force_multiline = nothing\n)`)
+      expect(format(raw)).toBe(
+        `configure(\n    value = ${value},\n    very_long_argument_name_to_force_multiline = nothing\n)`,
+      )
     }
   })
 
@@ -47,31 +49,43 @@ describe('Julia declaration layout', () => {
   })
 
   it('preserves nested calls, type parameters, literals, adjoints and where clauses', () => {
-    const raw = 'configure(connection::LibTmux.ControlConnection; value::Tuple{T, String} = (map(identity, [1, 2]), "a, b"), transpose = matrix\', marker = \',\', message = "$(join(["a", "b"], ","))", command = `printf "a,b"`, rest...) where {T<:Real}'
-    expect(format(raw)).toBe([
-      'configure(',
-      '    connection::LibTmux.ControlConnection;',
-      '    value::Tuple{T, String} = (map(identity, [1, 2]), "a, b"),',
-      '    transpose = matrix\',',
-      '    marker = \',\',',
-      '    message = "$(join(["a", "b"], ","))",',
-      '    command = `printf "a,b"`,',
-      '    rest...',
-      ') where {T<:Real}',
-    ].join('\n'))
-    const keywordOnly = 'configure(; path = "C:\\tmp\\\\", pattern = raw"a,b", label = "first, \\"second\\"", long_argument_name = nothing)'
-    expect(format(keywordOnly)).toBe([
-      'configure(;',
-      '    path = "C:\\tmp\\\\",',
-      '    pattern = raw"a,b",',
-      '    label = "first, \\"second\\"",',
-      '    long_argument_name = nothing',
-      ')',
-    ].join('\n'))
-    const multilineLiteral = 'configure(connection::LibTmux.ControlConnection; message = """first,\n  second; (third)""", nested = Dict(:a => (1, 2)))'
-    expect(format(multilineLiteral)).toContain('    message = """first,\n  second; (third)""",\n    nested = Dict(:a => (1, 2))\n)')
-    const nonInterpolated = 'configure(connection::LibTmux.ControlConnection; pattern = raw"$(literal, (text", long_argument_name = nothing)'
-    expect(format(nonInterpolated)).toContain('    pattern = raw"$(literal, (text",\n    long_argument_name = nothing\n)')
+    const raw =
+      'configure(connection::LibTmux.ControlConnection; value::Tuple{T, String} = (map(identity, [1, 2]), "a, b"), transpose = matrix\', marker = \',\', message = "$(join(["a", "b"], ","))", command = `printf "a,b"`, rest...) where {T<:Real}'
+    expect(format(raw)).toBe(
+      [
+        'configure(',
+        '    connection::LibTmux.ControlConnection;',
+        '    value::Tuple{T, String} = (map(identity, [1, 2]), "a, b"),',
+        "    transpose = matrix',",
+        "    marker = ',',",
+        '    message = "$(join(["a", "b"], ","))",',
+        '    command = `printf "a,b"`,',
+        '    rest...',
+        ') where {T<:Real}',
+      ].join('\n'),
+    )
+    const keywordOnly =
+      'configure(; path = "C:\\tmp\\\\", pattern = raw"a,b", label = "first, \\"second\\"", long_argument_name = nothing)'
+    expect(format(keywordOnly)).toBe(
+      [
+        'configure(;',
+        '    path = "C:\\tmp\\\\",',
+        '    pattern = raw"a,b",',
+        '    label = "first, \\"second\\"",',
+        '    long_argument_name = nothing',
+        ')',
+      ].join('\n'),
+    )
+    const multilineLiteral =
+      'configure(connection::LibTmux.ControlConnection; message = """first,\n  second; (third)""", nested = Dict(:a => (1, 2)))'
+    expect(format(multilineLiteral)).toContain(
+      '    message = """first,\n  second; (third)""",\n    nested = Dict(:a => (1, 2))\n)',
+    )
+    const nonInterpolated =
+      'configure(connection::LibTmux.ControlConnection; pattern = raw"$(literal, (text", long_argument_name = nothing)'
+    expect(format(nonInterpolated)).toContain(
+      '    pattern = raw"$(literal, (text",\n    long_argument_name = nothing\n)',
+    )
   })
 
   it('formats callable constructors after their receiver and leaves short signatures untouched', () => {
@@ -80,7 +94,9 @@ describe('Julia declaration layout', () => {
     const formatted = nativeSignatureText(owner, signature, 'julia')
     expect(formatted.split('\n')[0]).toBe('(var"#ctor-self#"::Type{LibTmux.ControlSignal{C}} where C)(')
     expect(formatted).toContain('\n    connection,\n    name,\n')
-    expect(format('from_env(; env, socket_path, socket_name, tmux)')).toBe('from_env(; env, socket_path, socket_name, tmux)')
+    expect(format('from_env(; env, socket_path, socket_name, tmux)')).toBe(
+      'from_env(; env, socket_path, socket_name, tmux)',
+    )
   })
 
   it('retains all native signature tokens, links and method identities across the Julia inventory', () => {
@@ -92,8 +108,11 @@ describe('Julia declaration layout', () => {
         const formatted = nativeSignatureText(symbol, signature, 'julia')
         expect(formatted.replace(/\s/g, ''), symbol.id).toBe(signature.raw.replace(/\s/g, ''))
         expect(nativeSignatureText(symbol, { ...signature, raw: formatted }, 'julia'), symbol.id).toBe(formatted)
-        const linked = (text: string) => index.linkType(text, symbol, signature).filter((span) => span.link)
-          .map((span) => ({ text: span.text, href: span.link!.href }))
+        const linked = (text: string) =>
+          index
+            .linkType(text, symbol, signature)
+            .filter((span) => span.link)
+            .map((span) => ({ text: span.text, href: span.link!.href }))
         expect(linked(formatted), symbol.id).toEqual(linked(signature.raw))
         if (formatted !== signature.raw) formattedCount++
       }
@@ -104,7 +123,9 @@ describe('Julia declaration layout', () => {
 
   it('exports the same declaration blocks for the header and every long method', () => {
     const markdown = symbolMarkdown({ model, symbol: application, index })
-    const blocks = fromMarkdown(markdown).children.filter((node) => node.type === 'code').map((node) => node.value)
+    const blocks = fromMarkdown(markdown)
+      .children.filter((node) => node.type === 'code')
+      .map((node) => node.value)
     const formatted = application.signatures.map((signature) => nativeSignatureText(application, signature, 'julia'))
     expect(blocks).toContain(formatted.join('\n\n'))
     for (const declaration of formatted) expect(blocks).toContain(declaration)
diff --git a/site/test/jvm-api-examples.test.ts b/site/test/jvm-api-examples.test.ts
index cee4c23c5..c95234cd5 100644
--- a/site/test/jvm-api-examples.test.ts
+++ b/site/test/jvm-api-examples.test.ts
@@ -18,17 +18,25 @@ describe('verified complete Java-family API programs', () => {
     expect(new Set(examples.map((example) => 'sourceProgramId' in example && example.sourceProgramId)).size).toBe(32)
     expect(new Set(examples.map((example) => example.page)).size).toBe(53)
     for (const port of ['java', 'kotlin', 'scala']) {
-      const covered = models[port].symbols.filter((symbol) => symbol.doc?.examples?.some(
-        (block) => block.sourceUrl?.includes('/examples/src/main/'))).map((symbol) => symbol.id)
-      expect([...new Set(examples.filter((example) => example.port === port).map((example) => example.symbol))].sort())
-        .toEqual(covered.sort())
-      expect(examples.filter((example) => example.port === port)).toHaveLength({ java: 14, kotlin: 15, scala: 28 }[port]!)
+      const covered = models[port].symbols
+        .filter((symbol) => symbol.doc?.examples?.some((block) => block.sourceUrl?.includes('/examples/src/main/')))
+        .map((symbol) => symbol.id)
+      expect(
+        [...new Set(examples.filter((example) => example.port === port).map((example) => example.symbol))].sort(),
+      ).toEqual(covered.sort())
+      expect(examples.filter((example) => example.port === port)).toHaveLength(
+        { java: 14, kotlin: 15, scala: 28 }[port]!,
+      )
     }
   })
 
   it.each(examples)('preserves $sourceProgramId on $symbol', (example) => {
-    if (!('sourceProgramId' in example) || typeof example.sourceProgramId !== 'string' ||
-        !('consoleBlocks' in example) || !example.consoleBlocks) {
+    if (
+      !('sourceProgramId' in example) ||
+      typeof example.sourceProgramId !== 'string' ||
+      !('consoleBlocks' in example) ||
+      !example.consoleBlocks
+    ) {
       throw new Error(`${example.symbol}: missing complete program selection`)
     }
     const model = models[example.port]
@@ -56,8 +64,9 @@ describe('verified complete Java-family API programs', () => {
         expect(line.length).toBeLessThanOrEqual(100)
       }
     }
-    expect(example.consoleBlocks.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim()))
-      .toEqual(example.shellRecipe)
+    expect(example.consoleBlocks.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim())).toEqual(
+      example.shellRecipe,
+    )
     expect(blocks[example.consoleBlocks[1] + 1].code.trimEnd().split('\n')).toEqual(example.expectedOutputs[1])
     for (const index of example.consoleBlocks) {
       expect(blocks[index].lang).toBe('console')
diff --git a/site/test/link-checker.outer.test.ts b/site/test/link-checker.outer.test.ts
index c53625122..61146d098 100644
--- a/site/test/link-checker.outer.test.ts
+++ b/site/test/link-checker.outer.test.ts
@@ -7,7 +7,10 @@ import { expect, it } from 'vitest'
 
 const checker = fileURLToPath(new URL('../../scripts/check-links.mjs', import.meta.url))
 
-it.each([{ mode: 'mentions', flags: [] }, { mode: 'all', flags: ['--all'] }])('resolves encoded fragments without excusing missing targets ($mode)', ({ flags }) => {
+it.each([
+  { mode: 'mentions', flags: [] },
+  { mode: 'all', flags: ['--all'] },
+])('resolves encoded fragments without excusing missing targets ($mode)', ({ flags }) => {
   const root = mkdtempSync(join(tmpdir(), 'libtmux-link-fragment-'))
   const anchors = [
     ['LibTmux%5CGet-TmuxWindow.parameter.Server', 'LibTmux\\Get-TmuxWindow.parameter.Server'],
@@ -27,8 +30,8 @@ it.each([{ mode: 'mentions', flags: [] }, { mode: 'all', flags: ['--all'] }])('r
     ['numeric%26%22%27', 'numeric&#38;&#x22;&#39;'],
   ]
   const check = () => spawnSync(process.execPath, [checker, root, ...flags], { encoding: 'utf8' })
-  const links = (path: string) => anchors.map(([fragment]) =>
-    `<a href="${path}#${fragment}" class="api-mention">Target</a>`).join('')
+  const links = (path: string) =>
+    anchors.map(([fragment]) => `<a href="${path}#${fragment}" class="api-mention">Target</a>`).join('')
   try {
     writeFileSync(join(root, 'target.html'), anchors.map(([, id]) => `<p id="${id}">Target</p>`).join('') + links(''))
     writeFileSync(join(root, 'index.html'), links('/target.html'))
@@ -36,21 +39,27 @@ it.each([{ mode: 'mentions', flags: [] }, { mode: 'all', flags: ['--all'] }])('r
     expect(valid.status, valid.stderr).toBe(0)
     expect(valid.stdout).toContain('2 pages, 30 links checked, 0 broken')
 
-    writeFileSync(join(root, 'index.html'), [
-      '<a href="/target.html#missing%3Aanchor" class="api-mention">Missing anchor</a>',
-      '<a href="/missing.html#C++" class="api-mention">Missing page</a>',
-      '<a href="/target.html#once%25252F" class="api-mention">Must not decode twice</a>',
-      '<a href="/target.html#C+%2B+" class="api-mention">Plus is not a space</a>',
-      '<a href="#missing%3Aanchor" class="api-mention">Missing local anchor</a>',
-      '<a href="/target.html#日%FF%FF" class="api-mention">Must retain Unicode</a>',
-    ].join(''))
+    writeFileSync(
+      join(root, 'index.html'),
+      [
+        '<a href="/target.html#missing%3Aanchor" class="api-mention">Missing anchor</a>',
+        '<a href="/missing.html#C++" class="api-mention">Missing page</a>',
+        '<a href="/target.html#once%25252F" class="api-mention">Must not decode twice</a>',
+        '<a href="/target.html#C+%2B+" class="api-mention">Plus is not a space</a>',
+        '<a href="#missing%3Aanchor" class="api-mention">Missing local anchor</a>',
+        '<a href="/target.html#日%FF%FF" class="api-mention">Must retain Unicode</a>',
+      ].join(''),
+    )
     const invalid = check()
     expect(invalid.status, invalid.stderr).toBe(1)
     expect(invalid.stdout).toContain('2 pages, 21 links checked, 6 broken')
     expect(invalid.stdout).toContain('no anchor')
     expect(invalid.stdout).toContain('no page')
 
-    writeFileSync(join(root, 'target.html'), '<p id="��">Wrong Unicode</p><a href="#日%FF" class="api-mention">Missing</a>')
+    writeFileSync(
+      join(root, 'target.html'),
+      '<p id="��">Wrong Unicode</p><a href="#日%FF" class="api-mention">Missing</a>',
+    )
     writeFileSync(join(root, 'index.html'), '<a href="/target.html#日%FF" class="api-mention">Missing</a>')
     const wrongUnicode = check()
     expect(wrongUnicode.status, wrongUnicode.stderr).toBe(1)
@@ -88,12 +97,17 @@ it('checks a large corpus in a small heap and still rejects missing pages and an
   const anchor = 'long-anchor-for-memory-regression'
   const target = 'long-target-for-memory-regression'
   const padding = 'x'.repeat(2 * 1024 * 1024)
-  const check = () => spawnSync(process.execPath, ['--max-old-space-size=64', checker, root, '--all'], {
-    encoding: 'utf8', timeout: 10_000,
-  })
+  const check = () =>
+    spawnSync(process.execPath, ['--max-old-space-size=64', checker, root, '--all'], {
+      encoding: 'utf8',
+      timeout: 10_000,
+    })
   try {
-    for (let i = 0; i < 48; i++) writeFileSync(join(root, `large-corpus-page-${i}.html`),
-      `<h1 id="${anchor}">${padding}</h1><a href="/large-corpus-page-${(i + 1) % 48}.html#${anchor}">Next</a><a href="/${target}/#${anchor}">There</a>`)
+    for (let i = 0; i < 48; i++)
+      writeFileSync(
+        join(root, `large-corpus-page-${i}.html`),
+        `<h1 id="${anchor}">${padding}</h1><a href="/large-corpus-page-${(i + 1) % 48}.html#${anchor}">Next</a><a href="/${target}/#${anchor}">There</a>`,
+      )
     const missingPage = check()
     expect(missingPage.status, missingPage.stderr).toBe(1)
     expect(missingPage.stdout).toContain('48 pages, 96 links checked, 48 broken')
diff --git a/site/test/link-hint-readiness.test.ts b/site/test/link-hint-readiness.test.ts
index 52a5fa9cd..ff0d5d4d6 100644
--- a/site/test/link-hint-readiness.test.ts
+++ b/site/test/link-hint-readiness.test.ts
@@ -4,26 +4,48 @@ import { initializeLinkHintReadiness } from '../src/lib/link-hint-readiness'
 let win: Window
 const images: TestImage[] = []
 class TestImage {
-  src = ''; crossOrigin = ''; onload = () => {}; onerror = () => {}
+  src = ''
+  crossOrigin = ''
+  onload = () => {}
+  onerror = () => {}
   decode = vi.fn(() => Promise.resolve())
-  constructor() { images.push(this) }
+  constructor() {
+    images.push(this)
+  }
 }
 beforeEach(() => {
-  vi.useFakeTimers(); images.length = 0
+  vi.useFakeTimers()
+  images.length = 0
   win = new Window({ url: 'https://libtmux.org/en/py/stable/reference/server/' })
   win.document.head.innerHTML = '<link data-link-hints-mask href="/en/_shell/external-link.svg">'
-  for (const [name, value] of Object.entries({ document: win.document, location: win.location,
-    HTMLScriptElement: win.HTMLScriptElement, Image: TestImage })) vi.stubGlobal(name, value)
+  for (const [name, value] of Object.entries({
+    document: win.document,
+    location: win.location,
+    HTMLScriptElement: win.HTMLScriptElement,
+    Image: TestImage,
+  }))
+    vi.stubGlobal(name, value)
+})
+afterEach(async () => {
+  await win.happyDOM.abort()
+  vi.useRealTimers()
+  vi.unstubAllGlobals()
+  vi.restoreAllMocks()
 })
-afterEach(async () => { await win.happyDOM.abort(); vi.useRealTimers(); vi.unstubAllGlobals(); vi.restoreAllMocks() })
 const root = () => win.document.documentElement
 const pending = () => root().classList.contains('link-hints-pending')
 const suppressed = () => root().classList.contains('link-hints-suppressed')
 const ready = (generation = root().dataset.linkHintsGeneration, href = win.location.href) => {
   win.document.dispatchEvent(new win.CustomEvent('libtmux:external-links-ready', { detail: { generation, href } }))
 }
-const maskReady = async (index = images.length - 1) => { images[index].onload(); await Promise.resolve() }
-function navigate(href = 'https://libtmux.org/en/julia/latest/reference/server/', mask = '../../_shell/external-link.svg') {
+const maskReady = async (index = images.length - 1) => {
+  images[index].onload()
+  await Promise.resolve()
+}
+function navigate(
+  href = 'https://libtmux.org/en/julia/latest/reference/server/',
+  mask = '../../_shell/external-link.svg',
+) {
   const next = win.document.implementation.createHTMLDocument()
   next.head.innerHTML = `<link data-link-hints-mask href="${mask}">`
   const event = new win.Event('astro:before-swap')
@@ -36,73 +58,125 @@ function navigate(href = 'https://libtmux.org/en/julia/latest/reference/server/'
   return next
 }
 it.each(['mask', 'module'])('waits for both decoration and decoded mask, with %s finishing first', async (first) => {
-  root().classList.add('fonts-pending'); initializeLinkHintReadiness()
+  root().classList.add('fonts-pending')
+  initializeLinkHintReadiness()
   expect(pending()).toBe(true)
   expect(images[0].src).toBe('https://libtmux.org/en/_shell/external-link.svg')
   expect(images[0].crossOrigin).toBe('anonymous')
-  if (first === 'mask') await maskReady(); else ready()
+  if (first === 'mask') await maskReady()
+  else ready()
   expect(pending()).toBe(true)
-  if (first === 'mask') ready(); else await maskReady()
-  expect(pending()).toBe(false); expect(suppressed()).toBe(false)
+  if (first === 'mask') ready()
+  else await maskReady()
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(false)
   expect(root().classList.contains('fonts-pending')).toBe(true)
 })
 it('waits for decode rather than only the image load event', async () => {
-  initializeLinkHintReadiness(); ready()
+  initializeLinkHintReadiness()
+  ready()
   let resolve!: () => void
-  images[0].decode.mockImplementation(() => new Promise<void>((done) => { resolve = done }))
-  images[0].onload(); await Promise.resolve(); expect(pending()).toBe(true)
-  resolve(); await Promise.resolve(); expect(pending()).toBe(false)
+  images[0].decode.mockImplementation(
+    () =>
+      new Promise<void>((done) => {
+        resolve = done
+      }),
+  )
+  images[0].onload()
+  await Promise.resolve()
+  expect(pending()).toBe(true)
+  resolve()
+  await Promise.resolve()
+  expect(pending()).toBe(false)
 })
 it.each(['module', 'mask', 'both'])('bounds a missing %s and ignores late successes for the page', async (missing) => {
   initializeLinkHintReadiness()
   if (missing === 'module') await maskReady()
   if (missing === 'mask') ready()
-  vi.advanceTimersByTime(2999); expect(pending()).toBe(true)
-  vi.advanceTimersByTime(1); expect(pending()).toBe(false); expect(suppressed()).toBe(true)
-  ready(); await maskReady(); expect(pending()).toBe(false); expect(suppressed()).toBe(true)
+  vi.advanceTimersByTime(2999)
+  expect(pending()).toBe(true)
+  vi.advanceTimersByTime(1)
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(true)
+  ready()
+  await maskReady()
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(true)
 })
 it.each(['error', 'decode'])('suppresses failed mask %s without leaving a blank page', async (failure) => {
-  initializeLinkHintReadiness(); ready()
+  initializeLinkHintReadiness()
+  ready()
   if (failure === 'error') images[0].onerror()
-  else { images[0].decode.mockRejectedValue(new Error('decode failed')); await maskReady() }
-  expect(pending()).toBe(false); expect(suppressed()).toBe(true)
+  else {
+    images[0].decode.mockRejectedValue(new Error('decode failed'))
+    await maskReady()
+  }
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(true)
 })
 it('suppresses a failed current module but ignores unrelated or detached script failures', () => {
   initializeLinkHintReadiness()
-  const script = win.document.createElement('script'); win.document.head.append(script)
-  script.dispatchEvent(new win.Event('error')); expect(pending()).toBe(true)
-  script.setAttribute('data-link-hints-module', ''); script.remove()
-  script.dispatchEvent(new win.Event('error')); expect(pending()).toBe(true)
-  win.document.head.append(script); script.dispatchEvent(new win.Event('error'))
-  expect(pending()).toBe(false); expect(suppressed()).toBe(true)
+  const script = win.document.createElement('script')
+  win.document.head.append(script)
+  script.dispatchEvent(new win.Event('error'))
+  expect(pending()).toBe(true)
+  script.setAttribute('data-link-hints-module', '')
+  script.remove()
+  script.dispatchEvent(new win.Event('error'))
+  expect(pending()).toBe(true)
+  win.document.head.append(script)
+  script.dispatchEvent(new win.Event('error'))
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(true)
 })
 it('retries a suppressed page with the destination-specific mask URL and copied HTML attributes', async () => {
-  initializeLinkHintReadiness(); vi.advanceTimersByTime(3000); expect(suppressed()).toBe(true)
+  initializeLinkHintReadiness()
+  vi.advanceTimersByTime(3000)
+  expect(suppressed()).toBe(true)
   const next = navigate()
   expect(images[1].src).toBe('https://libtmux.org/en/julia/latest/_shell/external-link.svg')
-  expect(pending()).toBe(true); expect(suppressed()).toBe(false)
-  ready(); await maskReady()
-  expect(pending()).toBe(false); expect(next.documentElement.classList.contains('link-hints-pending')).toBe(false)
+  expect(pending()).toBe(true)
+  expect(suppressed()).toBe(false)
+  ready()
+  await maskReady()
+  expect(pending()).toBe(false)
+  expect(next.documentElement.classList.contains('link-hints-pending')).toBe(false)
 })
 it('ignores prior-navigation readiness, masks and deadlines, including revisiting the same URL', async () => {
-  initializeLinkHintReadiness(); const old = root().dataset.linkHintsGeneration
-  vi.advanceTimersByTime(2000); navigate(win.location.href, '/other-root/_shell/external-link.svg')
-  ready(old); await maskReady(0); vi.advanceTimersByTime(1000)
-  expect(pending()).toBe(true); expect(suppressed()).toBe(false)
+  initializeLinkHintReadiness()
+  const old = root().dataset.linkHintsGeneration
+  vi.advanceTimersByTime(2000)
+  navigate(win.location.href, '/other-root/_shell/external-link.svg')
+  ready(old)
+  await maskReady(0)
+  vi.advanceTimersByTime(1000)
+  expect(pending()).toBe(true)
+  expect(suppressed()).toBe(false)
   ready(root().dataset.linkHintsGeneration, 'https://libtmux.org/wrong-page/')
-  await maskReady(1); expect(pending()).toBe(true)
-  ready(); expect(pending()).toBe(false)
+  await maskReady(1)
+  expect(pending()).toBe(true)
+  ready()
+  expect(pending()).toBe(false)
 })
 it('ignores fragment differences for the same document', async () => {
-  initializeLinkHintReadiness(); await maskReady()
-  ready(root().dataset.linkHintsGeneration, `${win.location.href}#member`); expect(pending()).toBe(false)
+  initializeLinkHintReadiness()
+  await maskReady()
+  ready(root().dataset.linkHintsGeneration, `${win.location.href}#member`)
+  expect(pending()).toBe(false)
 })
 it('releases with icons suppressed if a destination has no mask contract', () => {
-  win.document.head.innerHTML = ''; initializeLinkHintReadiness()
-  expect(pending()).toBe(false); expect(suppressed()).toBe(true)
+  win.document.head.innerHTML = ''
+  initializeLinkHintReadiness()
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(true)
 })
 it('runs the exact serialized head initializer without module-scope dependencies', () => {
-  Object.assign(win, { Image: TestImage }); win.eval(`(${initializeLinkHintReadiness.toString()})();`)
-  expect(pending()).toBe(true); expect(images).toHaveLength(1)
-  ready(); images[0].onerror(); expect(pending()).toBe(false); expect(suppressed()).toBe(true)
+  Object.assign(win, { Image: TestImage })
+  win.eval(`(${initializeLinkHintReadiness.toString()})();`)
+  expect(pending()).toBe(true)
+  expect(images).toHaveLength(1)
+  ready()
+  images[0].onerror()
+  expect(pending()).toBe(false)
+  expect(suppressed()).toBe(true)
 })
diff --git a/site/test/link-preview-paint.test.ts b/site/test/link-preview-paint.test.ts
index 0ba09ec71..9727f6545 100644
--- a/site/test/link-preview-paint.test.ts
+++ b/site/test/link-preview-paint.test.ts
@@ -6,8 +6,15 @@ let win: Window
 let showPopover: ReturnType<typeof vi.fn>
 beforeEach(() => {
   win = new Window({ url: 'https://libtmux.org/en/julia/latest/reference/libtmux-server/' })
-  for (const [name, value] of Object.entries({ window: win, document: win.document, location: win.location,
-    Element: win.Element, HTMLElement: win.HTMLElement, MutationObserver: win.MutationObserver })) vi.stubGlobal(name, value)
+  for (const [name, value] of Object.entries({
+    window: win,
+    document: win.document,
+    location: win.location,
+    Element: win.Element,
+    HTMLElement: win.HTMLElement,
+    MutationObserver: win.MutationObserver,
+  }))
+    vi.stubGlobal(name, value)
   Object.defineProperty(win.document, 'readyState', { value: 'loading', configurable: true })
   win.document.documentElement.setAttribute('data-reference-previews', '')
   showPopover = vi.fn()
@@ -27,17 +34,32 @@ const parsed = () => win.happyDOM.waitUntilComplete()
 it('shares endpoint rules with deferred behavior, including protocol objects', () => {
   const { target } = policy()
   const origin = win.location.origin
-  for (const path of ['/en/ts/latest/reference/type/', '/en/ts/latest/mcp/tools/create_session/',
-    '/en/ts/latest/mcp/prompts/review/', '/en/ts/latest/mcp/resources/tmux-capabilities/',
-    '/en/ts/latest/mcp/resources/templates/session/']) expect(target(path, origin)?.endpoint).toBe(`${path.slice(0, -1)}.preview.json`)
-  for (const path of ['/en/ts/latest/reference/', '/en/ts/latest/mcp/resources/templates/', '/guide/',
-    '/en/ts/latest/reference/type/?q=1', 'https://elsewhere.test/reference/type/', 'javascript:alert(1)']) expect(target(path, origin)).toBeUndefined()
+  for (const path of [
+    '/en/ts/latest/reference/type/',
+    '/en/ts/latest/mcp/tools/create_session/',
+    '/en/ts/latest/mcp/prompts/review/',
+    '/en/ts/latest/mcp/resources/tmux-capabilities/',
+    '/en/ts/latest/mcp/resources/templates/session/',
+  ])
+    expect(target(path, origin)?.endpoint).toBe(`${path.slice(0, -1)}.preview.json`)
+  for (const path of [
+    '/en/ts/latest/reference/',
+    '/en/ts/latest/mcp/resources/templates/',
+    '/guide/',
+    '/en/ts/latest/reference/type/?q=1',
+    'https://elsewhere.test/reference/type/',
+    'javascript:alert(1)',
+  ])
+    expect(target(path, origin)).toBeUndefined()
 })
 
 it('marks parser-added eligible links without fetching or binding interactions', async () => {
-  const fetch = vi.fn(); vi.stubGlobal('fetch', fetch)
+  const fetch = vi.fn()
+  vi.stubGlobal('fetch', fetch)
   initializeLinkPreviewPaint(policy())
-  append('<p><a id="python" href="/en/py/stable/reference/libtmux-server/">Python</a><a id="from-env" href="../libtmux-from_env/">from_env</a></p>')
+  append(
+    '<p><a id="python" href="/en/py/stable/reference/libtmux-server/">Python</a><a id="from-env" href="../libtmux-from_env/">from_env</a></p>',
+  )
   await parsed()
   expect(marked('python')).toBe(true)
   expect(marked('from-env')).toBe(true)
@@ -49,10 +71,13 @@ it('marks parser-added eligible links without fetching or binding interactions',
 })
 
 it('does not repeatedly scan existing or overlapping parser subtrees', async () => {
-  const rules = policy(); const candidate = vi.spyOn(rules, 'candidate')
+  const rules = policy()
+  const candidate = vi.spyOn(rules, 'candidate')
   initializeLinkPreviewPaint(rules)
-  const section = win.document.createElement('section'); win.document.body.append(section)
-  const paragraph = win.document.createElement('p'); section.append(paragraph)
+  const section = win.document.createElement('section')
+  win.document.body.append(section)
+  const paragraph = win.document.createElement('p')
+  section.append(paragraph)
   paragraph.innerHTML = '<a id="first" href="../libtmux-from_env/">from_env</a>'
   await parsed()
   expect(candidate).toHaveBeenCalledTimes(1)
@@ -75,13 +100,17 @@ it.each([
   '<a id="excluded" href="../libtmux-from_env/?q=1">query</a>',
   '<a id="excluded" href="https://elsewhere.test/reference/from-env/">external</a>',
 ])('preserves the preview exclusion: %s', async (html) => {
-  initializeLinkPreviewPaint(policy()); append(html); await parsed()
+  initializeLinkPreviewPaint(policy())
+  append(html)
+  await parsed()
   expect(marked('excluded')).toBe(false)
 })
 
 it('replaces native glossary tooltips while preserving the link name and destination', async () => {
   initializeLinkPreviewPaint(policy())
-  append('<span title="Enclosing tooltip"><a id="badge" class="api-badge" href="../glossary/#struct" data-link-preview title="struct" aria-label="Read the struct definition"><span class="api-badge__label" title="struct">struct</span></a></span>')
+  append(
+    '<span title="Enclosing tooltip"><a id="badge" class="api-badge" href="../glossary/#struct" data-link-preview title="struct" aria-label="Read the struct definition"><span class="api-badge__label" title="struct">struct</span></a></span>',
+  )
   await parsed()
   expect(marked('badge')).toBe(true)
   expect(anchor('badge').getAttribute('title')).toBe('')
@@ -97,7 +126,9 @@ it('replaces native glossary tooltips while preserving the link name and destina
 
 it('retains native tooltips on links without previews', async () => {
   initializeLinkPreviewPaint(policy())
-  append('<nav><a id="nav" href="../libtmux-from_env/" title="Navigation">from_env</a></nav><div class="api-index-card"><a id="card" href="../libtmux-from_env/" title="Card">from_env</a></div>')
+  append(
+    '<nav><a id="nav" href="../libtmux-from_env/" title="Navigation">from_env</a></nav><div class="api-index-card"><a id="card" href="../libtmux-from_env/" title="Card">from_env</a></div>',
+  )
   await parsed()
   expect(anchor('nav').getAttribute('title')).toBe('Navigation')
   expect(anchor('card').getAttribute('title')).toBe('Card')
@@ -117,12 +148,17 @@ it('initializes an API document before swapping from NativeShell, resolving its
   win.document.documentElement.removeAttribute('data-reference-previews')
   initializeLinkPreviewPaint(policy())
   append('<a id="native" href="../libtmux-from_env/">native</a>')
-  await parsed(); expect(marked('native')).toBe(false)
+  await parsed()
+  expect(marked('native')).toBe(false)
   const next = win.document.implementation.createHTMLDocument()
   next.documentElement.setAttribute('data-reference-previews', '')
-  next.body.innerHTML = '<a id="incoming" href="../libtmux-from_env/" title="from_env">from_env</a><a id="fragment" href="#member">fragment</a>'
+  next.body.innerHTML =
+    '<a id="incoming" href="../libtmux-from_env/" title="from_env">from_env</a><a id="fragment" href="#member">fragment</a>'
   const event = new win.Event('astro:before-swap')
-  Object.assign(event, { newDocument: next, to: new URL('https://libtmux.org/en/julia/latest/reference/libtmux-server/') })
+  Object.assign(event, {
+    newDocument: next,
+    to: new URL('https://libtmux.org/en/julia/latest/reference/libtmux-server/'),
+  })
   win.document.dispatchEvent(event)
   expect(next.getElementById('incoming')!.hasAttribute('data-link-preview')).toBe(true)
   expect(next.getElementById('incoming')!.getAttribute('title')).toBe('')
@@ -134,12 +170,14 @@ it('preserves unsupported-popover fallback', async () => {
   Object.defineProperty(win.HTMLElement.prototype, 'showPopover', { value: undefined, configurable: true })
   initializeLinkPreviewPaint(policy())
   append('<a id="ordinary" href="../libtmux-from_env/" title="Ordinary fallback">ordinary</a>')
-  await parsed(); expect(marked('ordinary')).toBe(false)
+  await parsed()
+  expect(marked('ordinary')).toBe(false)
   expect(anchor('ordinary').getAttribute('title')).toBe('Ordinary fallback')
 })
 
 it('runs the exact self-contained serialized initializer without module globals', async () => {
   win.eval(`(${initializeLinkPreviewPaint.toString()})((${createLinkPreviewPolicy.toString()})());`)
   append('<a id="serialized" href="../libtmux-from_env/">from_env</a>')
-  await parsed(); expect(marked('serialized')).toBe(true)
+  await parsed()
+  expect(marked('serialized')).toBe(true)
 })
diff --git a/site/test/link-preview.test.ts b/site/test/link-preview.test.ts
index ca566b8cf..970674143 100644
--- a/site/test/link-preview.test.ts
+++ b/site/test/link-preview.test.ts
@@ -13,7 +13,10 @@ import { apiGlossaryHref } from '../src/lib/api-glossary'
 import { initLinkPreviews, disposeLinkPreviews, linkPreviewTarget } from '../src/lib/link-preview-browser'
 
 it.each([
-  ['/en/powershell/latest/workspace/reference/libtmux-workspace/', '/en/powershell/latest/workspace/reference/glossary/#cmdlet'],
+  [
+    '/en/powershell/latest/workspace/reference/libtmux-workspace/',
+    '/en/powershell/latest/workspace/reference/glossary/#cmdlet',
+  ],
   ['/pr-42/en/julia/latest/mcp/reference/libtmuxmcp-tools/', '/pr-42/en/julia/latest/mcp/reference/glossary/#cmdlet'],
   ['/en/julia/latest/reference/libtmux-from_env/', '/en/julia/latest/reference/glossary/#cmdlet'],
 ])('keeps glossary terms in their existing reference context: %s', (context, expected) => {
@@ -47,8 +50,15 @@ it('provides exact glossary terms with durable destinations', () => {
 
 it('only fetches same-origin supported reference URLs', () => {
   const origin = 'https://libtmux.org'
-  expect(linkPreviewTarget('/en/ts/latest/reference/server/#parameter', origin)?.endpoint).toBe('/en/ts/latest/reference/server.preview.json')
-  for (const url of ['https://elsewhere.test/reference/server/', '/en/guides/', '/en/ts/latest/reference/server/?q=1', 'javascript:alert(1)']) {
+  expect(linkPreviewTarget('/en/ts/latest/reference/server/#parameter', origin)?.endpoint).toBe(
+    '/en/ts/latest/reference/server.preview.json',
+  )
+  for (const url of [
+    'https://elsewhere.test/reference/server/',
+    '/en/guides/',
+    '/en/ts/latest/reference/server/?q=1',
+    'javascript:alert(1)',
+  ]) {
     expect(linkPreviewTarget(url, origin)).toBeUndefined()
   }
 })
@@ -58,23 +68,42 @@ it('keeps native keyword help and parameter permalinks inside their inline parag
   const { transform } = await import(astroRequire.resolve('@astrojs/compiler-rs'))
   async function compile(relative: string, imports: Record<string, string> = {}) {
     const file = new URL(relative, import.meta.url)
-    const source = readFileSync(file, 'utf8').replace(/<script[\s\S]*?<\/script>/g, '').replace(/<style[\s\S]*?<\/style>/g, '')
-    const result = await transform(source, { filename: file.pathname, internalURL: 'astro/compiler-runtime',
-      resultScopedSlot: true, resolvePath: (specifier: string) => specifier })
+    const source = readFileSync(file, 'utf8')
+      .replace(/<script[\s\S]*?<\/script>/g, '')
+      .replace(/<style[\s\S]*?<\/style>/g, '')
+    const result = await transform(source, {
+      filename: file.pathname,
+      internalURL: 'astro/compiler-runtime',
+      resultScopedSlot: true,
+      resolvePath: (specifier: string) => specifier,
+    })
     expect(result.diagnostics.filter((item: { severity: string }) => item.severity === 'error')).toEqual([])
-    let code = result.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
-    for (const [specifier, url] of Object.entries(imports)) code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(url))
+    let code = result.code.replaceAll(
+      '"astro/compiler-runtime"',
+      JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+    )
+    for (const [specifier, url] of Object.entries(imports))
+      code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(url))
     return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`
   }
   const preview = await compile('../src/components/LinkPreview.astro')
   const keyword = await compile('../src/components/api/ApiKeyword.astro', { '../LinkPreview.astro': preview })
   const model = API_MODELS.kotlin
   const symbol = model.symbols.find((entry) => entry.id === 'io.github.libtmux.kotlin.ControlClient.output')!
-  const parameter = symbol.signatures.flatMap((signature) => signature.params).find((entry) => entry.name === 'onSubscribed')!
-  const helped = productApiIndex(model, 'latest').linkType(parameter.type!, symbol).find((span) => span.help)!
+  const parameter = symbol.signatures
+    .flatMap((signature) => signature.params)
+    .find((entry) => entry.name === 'onSubscribed')!
+  const helped = productApiIndex(model, 'latest')
+    .linkType(parameter.type!, symbol)
+    .find((span) => span.help)!
   const container = await experimental_AstroContainer.create()
-  const html = await container.renderToString((await import(/* @vite-ignore */ keyword)).default, { props: { text: helped.text, help: helped.help } })
-  const tree = fromHtml(`<p><strong>onSubscribed</strong> (${html}<span> () → Unit</span>) <a href="#parameter">#</a></p>`, { fragment: true })
+  const html = await container.renderToString((await import(/* @vite-ignore */ keyword)).default, {
+    props: { text: helped.text, help: helped.help },
+  })
+  const tree = fromHtml(
+    `<p><strong>onSubscribed</strong> (${html}<span> () → Unit</span>) <a href="#parameter">#</a></p>`,
+    { fragment: true },
+  )
   // Use the HTML5 parser: a hidden block element can still close the parameter paragraph.
   expect(tree.children).toHaveLength(1)
   const paragraph = tree.children[0]
@@ -99,18 +128,43 @@ let prefix: string
 beforeEach(() => {
   prefix = `/en/ts/latest/reference/preview-test-${++serial}`
   win = new Window({ url: 'https://libtmux.org/en/ts/latest/guides/' })
-  for (const [name, value] of Object.entries({ window: win, document: win.document, location: win.location,
-    Element: win.Element, Node: win.Node, HTMLElement: win.HTMLElement, innerHeight: 800 })) vi.stubGlobal(name, value)
+  for (const [name, value] of Object.entries({
+    window: win,
+    document: win.document,
+    location: win.location,
+    Element: win.Element,
+    Node: win.Node,
+    HTMLElement: win.HTMLElement,
+    innerHeight: 800,
+  }))
+    vi.stubGlobal(name, value)
   vi.useFakeTimers()
   opened = false
   win.document.body.innerHTML = `<a id="a" href="${prefix}-a/">a</a><a id="b" href="${prefix}-b/">b</a>
     <span id="reference-link-preview"><code data-preview-title></code><button data-preview-expand hidden aria-expanded="false">Show full name</button><span data-preview-description></span>
     <span data-preview-detail></span><code data-preview-signature></code><a data-preview-open></a><button data-preview-close>Close</button></span>`
   const panel = win.document.getElementById('reference-link-preview')!
-  Object.assign(panel, { showPopover: () => { opened = true }, hidePopover: () => { opened = false } })
+  Object.assign(panel, {
+    showPopover: () => {
+      opened = true
+    },
+    hidePopover: () => {
+      opened = false
+    },
+  })
   const matches = panel.matches.bind(panel)
-  panel.matches = (selector) => selector === ':popover-open' ? opened : matches(selector)
-  requests = vi.fn(async (path: string) => new Response(JSON.stringify({ schema: 1, title: path.includes('-a.') ? 'a' : 'b', description: 'Useful description.', href: path.replace('.preview.json', '/') })))
+  panel.matches = (selector) => (selector === ':popover-open' ? opened : matches(selector))
+  requests = vi.fn(
+    async (path: string) =>
+      new Response(
+        JSON.stringify({
+          schema: 1,
+          title: path.includes('-a.') ? 'a' : 'b',
+          description: 'Useful description.',
+          href: path.replace('.preview.json', '/'),
+        }),
+      ),
+  )
   vi.stubGlobal('fetch', requests)
   initLinkPreviews()
 })
@@ -122,7 +176,8 @@ afterEach(async () => {
   vi.restoreAllMocks()
 })
 const link = (id = 'a') => win.document.querySelector<HTMLAnchorElement>(`#${id}`)!
-const hover = (id = 'a', pointerType = 'mouse') => link(id).dispatchEvent(new win.PointerEvent('pointerover', { pointerType, bubbles: true }))
+const hover = (id = 'a', pointerType = 'mouse') =>
+  link(id).dispatchEvent(new win.PointerEvent('pointerover', { pointerType, bubbles: true }))
 const settle = () => vi.advanceTimersByTimeAsync(200)
 const title = () => win.document.querySelector('[data-preview-title]')!.textContent
 const escape = () => win.document.dispatchEvent(new win.KeyboardEvent('keydown', { key: 'Escape', bubbles: true }))
@@ -131,9 +186,11 @@ describe('preview lifecycle', () => {
   it('keeps the destructor name and native signature intact with meaningful title breaks', async () => {
     const name = 'libtmux::CommandOperation::~CommandOperation'
     const signature = '~CommandOperation();'
-    requests.mockResolvedValueOnce(new Response(JSON.stringify({ schema: 1, title: name,
-      description: '', signature, href: `${prefix}-a/` })))
-    hover(); await settle()
+    requests.mockResolvedValueOnce(
+      new Response(JSON.stringify({ schema: 1, title: name, description: '', signature, href: `${prefix}-a/` })),
+    )
+    hover()
+    await settle()
     const panel = win.document.getElementById('reference-link-preview')!
     expect(title()).toBe(name)
     expect(panel.getAttribute('aria-label')).toBe(`${name} preview`)
@@ -146,9 +203,11 @@ describe('preview lifecycle', () => {
   it('expands long qualified names in place without changing full identity, signature or destination', async () => {
     const name = 'io.github.libtmux.workspace.WorkspaceBuilder.applyWorkspace'
     const signature = 'public WorkspaceResult applyWorkspace(WorkspacePlan plan);'
-    requests.mockResolvedValueOnce(new Response(JSON.stringify({ schema: 1, title: name,
-      description: '', signature, href: `${prefix}-a/` })))
-    hover(); await settle()
+    requests.mockResolvedValueOnce(
+      new Response(JSON.stringify({ schema: 1, title: name, description: '', signature, href: `${prefix}-a/` })),
+    )
+    hover()
+    await settle()
     const panel = win.document.getElementById('reference-link-preview')!
     const expand = panel.querySelector<HTMLButtonElement>('[data-preview-expand]')!
     const short = title()
@@ -165,7 +224,9 @@ describe('preview lifecycle', () => {
     expand.click()
     expect(title()).toBe(short)
     expect(expand.getAttribute('aria-expanded')).toBe('false')
-    escape(); hover('b'); await settle()
+    escape()
+    hover('b')
+    await settle()
     expect(title()).toBe('b')
     expect(expand.hidden).toBe(true)
     expect(expand.getAttribute('aria-expanded')).toBe('false')
@@ -173,30 +234,42 @@ describe('preview lifecycle', () => {
 
   it('treats punctuation in a preview name as text when adding break opportunities', async () => {
     const name = 'libtmux::Value<Other> & Value<Script>'
-    requests.mockResolvedValueOnce(new Response(JSON.stringify({ schema: 1, title: name,
-      description: '', href: `${prefix}-a/` })))
-    hover(); await settle()
+    requests.mockResolvedValueOnce(
+      new Response(JSON.stringify({ schema: 1, title: name, description: '', href: `${prefix}-a/` })),
+    )
+    hover()
+    await settle()
     expect(title()).toBe(name)
     expect(win.document.querySelector('[data-preview-title] script')).toBeNull()
-    expect(Array.from(win.document.querySelector('[data-preview-title]')!.children).every((node) => node.tagName === 'WBR')).toBe(true)
+    expect(
+      Array.from(win.document.querySelector('[data-preview-title]')!.children).every((node) => node.tagName === 'WBR'),
+    ).toBe(true)
   })
 
   it('marks eligible previews without eagerly fetching their contents', () => {
     expect(link().hasAttribute('data-link-preview')).toBe(true)
     expect(requests).not.toHaveBeenCalled()
-    win.document.body.insertAdjacentHTML('beforeend', '<a id="external" href="https://example.com/reference/type/">External</a><nav><a id="nav" href="/en/ts/latest/reference/type/">Navigation</a></nav><a id="skip" data-preview-skip href="/en/ts/latest/reference/type/">Skip</a>')
+    win.document.body.insertAdjacentHTML(
+      'beforeend',
+      '<a id="external" href="https://example.com/reference/type/">External</a><nav><a id="nav" href="/en/ts/latest/reference/type/">Navigation</a></nav><a id="skip" data-preview-skip href="/en/ts/latest/reference/type/">Skip</a>',
+    )
     initLinkPreviews()
     for (const id of ['external', 'nav', 'skip']) expect(link(id).hasAttribute('data-link-preview')).toBe(false)
     expect(requests).not.toHaveBeenCalled()
   })
   it('keeps glossary destinations in documentation pickers as ordinary navigation', async () => {
-    win.document.body.insertAdjacentHTML('beforeend', `<header><details data-doc-picker open>
+    win.document.body.insertAdjacentHTML(
+      'beforeend',
+      `<header><details data-doc-picker open>
       <summary>Choose a port</summary><div><a id="picker" href="/en/julia/latest/mcp/reference/glossary/#attribute">Julia</a></div>
-    </details></header>`)
+    </details></header>`,
+    )
     initLinkPreviews()
     expect(link('picker').hasAttribute('data-link-preview')).toBe(false)
-    hover('picker'); await settle()
-    link('picker').focus(); await settle()
+    hover('picker')
+    await settle()
+    link('picker').focus()
+    await settle()
     const click = new win.MouseEvent('click', { bubbles: true, cancelable: true })
     link('picker').dispatchEvent(click)
     await settle()
@@ -212,7 +285,8 @@ describe('preview lifecycle', () => {
     expect(link().textContent).toBe('a')
     expect(link().getAttribute('aria-label')).toBe('Read a')
     expect(link().getAttribute('href')).toBe(`${prefix}-a/`)
-    link().focus(); await settle()
+    link().focus()
+    await settle()
     expect(opened).toBe(true)
     expect(link().getAttribute('aria-details')).toBe('reference-link-preview')
     expect(win.document.activeElement).toBe(link())
@@ -222,7 +296,8 @@ describe('preview lifecycle', () => {
     expect(win.document.activeElement).toBe(link())
     expect(link().title).toBe('')
     link('b').title = 'Dynamically added tooltip'
-    hover('b'); await settle()
+    hover('b')
+    await settle()
     expect(opened).toBe(true)
     expect(link('b').title).toBe('')
   })
@@ -234,35 +309,60 @@ describe('preview lifecycle', () => {
     initLinkPreviews()
     expect(link().title).toBe('')
     expect(link().getAttribute('aria-description')).toBe(origin)
-    requests.mockResolvedValueOnce(new Response(JSON.stringify({ schema: 1, title: 'inherited',
-      description: 'A member declared by a base type.', detail: 'Follow the declaration for its signature.', href: `${prefix}-a/` })))
-    hover(); await settle()
+    requests.mockResolvedValueOnce(
+      new Response(
+        JSON.stringify({
+          schema: 1,
+          title: 'inherited',
+          description: 'A member declared by a base type.',
+          detail: 'Follow the declaration for its signature.',
+          href: `${prefix}-a/`,
+        }),
+      ),
+    )
+    hover()
+    await settle()
     const detail = win.document.querySelector<HTMLElement>('[data-preview-detail]')!
     expect(detail.hidden).toBe(false)
     expect(detail.textContent).toBe(`${origin}. Follow the declaration for its signature.`)
     expect(detail.children).toHaveLength(0)
-    escape(); hover('b'); await settle()
+    escape()
+    hover('b')
+    await settle()
     expect(detail.hidden).toBe(true)
     expect(detail.textContent).toBe('')
   })
   it('loads on intent, caches repeated requests, and ignores touch hover', async () => {
     expect(requests).not.toHaveBeenCalled()
-    hover('a', 'touch'); await settle(); expect(requests).not.toHaveBeenCalled()
-    hover(); await settle(); expect(requests).toHaveBeenCalledTimes(1); expect(opened).toBe(true)
-    escape(); hover(); await settle(); expect(requests).toHaveBeenCalledTimes(1)
+    hover('a', 'touch')
+    await settle()
+    expect(requests).not.toHaveBeenCalled()
+    hover()
+    await settle()
+    expect(requests).toHaveBeenCalledTimes(1)
+    expect(opened).toBe(true)
+    escape()
+    hover()
+    await settle()
+    expect(requests).toHaveBeenCalledTimes(1)
   })
 
   it.each(['card', 'inline', 'kind', 'context'])('keeps %s links inside browse cards free of previews', async (id) => {
-    win.document.body.insertAdjacentHTML('beforeend', `<div class="api-index-card">
+    win.document.body.insertAdjacentHTML(
+      'beforeend',
+      `<div class="api-index-card">
       <a id="card" class="api-index-card__link" href="/en/cxx/latest/mcp/resources/tmux-capabilities/">tmux-capabilities</a>
       <a id="kind" class="api-badge" data-link-preview href="/en/cxx/latest/reference/glossary/#function">function</a>
       <a id="context" class="api-badge" href="/en/cxx/latest/reference/glossary/#package">Package: tmux</a>
       <p>The startup-frozen <a id="inline" href="/en/cxx/latest/reference/server/">server</a> capability manifest.</p>
-    </div>`)
+    </div>`,
+    )
     initLinkPreviews()
     expect(link(id).hasAttribute('data-link-preview')).toBe(false)
-    hover(id); await settle()
-    link(id).focus(); await settle()
+    hover(id)
+    await settle()
+    link(id).focus()
+    await settle()
     const click = new win.MouseEvent('click', { bubbles: true, cancelable: true })
     link(id).dispatchEvent(click)
     await settle()
@@ -272,56 +372,99 @@ describe('preview lifecycle', () => {
   })
 
   it('cancels a brief hover before requesting metadata', async () => {
-    hover(); vi.advanceTimersByTime(100)
+    hover()
+    vi.advanceTimersByTime(100)
     link().dispatchEvent(new win.PointerEvent('pointerout', { pointerType: 'mouse', bubbles: true }))
-    await settle(); expect(requests).not.toHaveBeenCalled()
+    await settle()
+    expect(requests).not.toHaveBeenCalled()
   })
 
   it('ignores a late response as soon as another link owns the intent', async () => {
     let resolveA!: (value: Response) => void
-    requests.mockImplementationOnce(() => new Promise<Response>((resolve) => { resolveA = resolve }))
-    hover(); await settle(); hover('b')
+    requests.mockImplementationOnce(
+      () =>
+        new Promise<Response>((resolve) => {
+          resolveA = resolve
+        }),
+    )
+    hover()
+    await settle()
+    hover('b')
     resolveA(new Response(JSON.stringify({ schema: 1, title: 'stale', description: '', href: `${prefix}-a/` })))
-    await Promise.resolve(); expect(opened).toBe(false)
-    await settle(); expect(opened).toBe(true); expect(title()).toBe('b')
+    await Promise.resolve()
+    expect(opened).toBe(false)
+    await settle()
+    expect(opened).toBe(true)
+    expect(title()).toBe('b')
   })
 
   it('aborts pending navigation work and never reopens after disposal', async () => {
     let resolveA!: (value: Response) => void
-    requests.mockImplementationOnce(() => new Promise<Response>((resolve) => { resolveA = resolve }))
-    hover(); await settle(); const signal = requests.mock.calls[0][1].signal as AbortSignal
-    disposeLinkPreviews(); expect(signal.aborted).toBe(true)
+    requests.mockImplementationOnce(
+      () =>
+        new Promise<Response>((resolve) => {
+          resolveA = resolve
+        }),
+    )
+    hover()
+    await settle()
+    const signal = requests.mock.calls[0][1].signal as AbortSignal
+    disposeLinkPreviews()
+    expect(signal.aborted).toBe(true)
     resolveA(new Response(JSON.stringify({ schema: 1, title: 'stale', description: '', href: `${prefix}-a/` })))
-    await settle(); expect(opened).toBe(false)
+    await settle()
+    expect(opened).toBe(false)
   })
 
   it('cancels a pending preview when keyboard focus moves to another control', async () => {
     let resolveA!: (value: Response) => void
-    requests.mockImplementationOnce(() => new Promise<Response>((resolve) => { resolveA = resolve }))
-    link().focus(); await settle()
-    const button = win.document.createElement('button'); win.document.body.append(button); button.focus()
+    requests.mockImplementationOnce(
+      () =>
+        new Promise<Response>((resolve) => {
+          resolveA = resolve
+        }),
+    )
+    link().focus()
+    await settle()
+    const button = win.document.createElement('button')
+    win.document.body.append(button)
+    button.focus()
     resolveA(new Response(JSON.stringify({ schema: 1, title: 'stale', description: '', href: `${prefix}-a/` })))
-    await settle(); expect(opened).toBe(false)
+    await settle()
+    expect(opened).toBe(false)
   })
 
   it('never replaces native keyword help with a pending API response', async () => {
     let resolveA!: (value: Response) => void
-    requests.mockImplementationOnce(() => new Promise<Response>((resolve) => { resolveA = resolve }))
-    hover(); await settle()
-    const help = win.document.createElement('span'); help.className = 'reference-link-preview api-keyword-help'
+    requests.mockImplementationOnce(
+      () =>
+        new Promise<Response>((resolve) => {
+          resolveA = resolve
+        }),
+    )
+    hover()
+    await settle()
+    const help = win.document.createElement('span')
+    help.className = 'reference-link-preview api-keyword-help'
     win.document.body.append(help)
-    const toggle = new win.Event('beforetoggle'); Object.assign(toggle, { newState: 'open' }); help.dispatchEvent(toggle)
+    const toggle = new win.Event('beforetoggle')
+    Object.assign(toggle, { newState: 'open' })
+    help.dispatchEvent(toggle)
     resolveA(new Response(JSON.stringify({ schema: 1, title: 'stale', description: '', href: `${prefix}-a/` })))
-    await settle(); expect(opened).toBe(false)
+    await settle()
+    expect(opened).toBe(false)
   })
 
   it('keeps API clicks and modified glossary clicks as ordinary navigation', async () => {
     const click = new win.MouseEvent('click', { bubbles: true, cancelable: true })
-    link().dispatchEvent(click); expect(click.defaultPrevented).toBe(false)
+    link().dispatchEvent(click)
+    expect(click.defaultPrevented).toBe(false)
     link().setAttribute('href', '/en/powershell/latest/workspace/reference/glossary/#cmdlet')
     const modified = new win.MouseEvent('click', { bubbles: true, cancelable: true, ctrlKey: true })
-    link().dispatchEvent(modified); expect(modified.defaultPrevented).toBe(false)
-    await settle(); expect(requests).not.toHaveBeenCalled()
+    link().dispatchEvent(modified)
+    expect(modified.defaultPrevented).toBe(false)
+    await settle()
+    expect(requests).not.toHaveBeenCalled()
   })
 
   it('opens a glossary definition on click and restores focus once on Escape', async () => {
@@ -329,21 +472,39 @@ describe('preview lifecycle', () => {
     requests.mockResolvedValueOnce(new Response(JSON.stringify(glossaryPreview(href))))
     link().setAttribute('href', `${href}#cmdlet`)
     let routerPrevented = false
-    win.document.addEventListener('click', (event) => { routerPrevented = event.defaultPrevented }, { once: true })
+    win.document.addEventListener(
+      'click',
+      (event) => {
+        routerPrevented = event.defaultPrevented
+      },
+      { once: true },
+    )
     const click = new win.MouseEvent('click', { bubbles: true, cancelable: true })
-    link().dispatchEvent(click); expect(click.defaultPrevented).toBe(true)
+    link().dispatchEvent(click)
+    expect(click.defaultPrevented).toBe(true)
     expect(routerPrevented).toBe(true)
-    await settle(); expect(opened).toBe(true); expect(title()).toBe('cmdlet')
+    await settle()
+    expect(opened).toBe(true)
+    expect(title()).toBe('cmdlet')
     expect(win.document.activeElement).toBe(win.document.querySelector('[data-preview-open]'))
-    escape(); await settle(); expect(opened).toBe(false); expect(win.document.activeElement).toBe(link())
+    escape()
+    await settle()
+    expect(opened).toBe(false)
+    expect(win.document.activeElement).toBe(link())
     expect(requests).toHaveBeenCalledTimes(1)
   })
 
   it('rejects missing and foreign metadata without trapping ordinary links', async () => {
     requests.mockResolvedValueOnce(new Response('', { status: 404 }))
-    hover(); await settle(); expect(opened).toBe(false)
-    requests.mockResolvedValueOnce(new Response(JSON.stringify({ schema: 1, title: 'unsafe', description: '', href: 'https://elsewhere.test/' })))
-    hover(); await settle(); expect(opened).toBe(false)
+    hover()
+    await settle()
+    expect(opened).toBe(false)
+    requests.mockResolvedValueOnce(
+      new Response(JSON.stringify({ schema: 1, title: 'unsafe', description: '', href: 'https://elsewhere.test/' })),
+    )
+    hover()
+    await settle()
+    expect(opened).toBe(false)
     expect(link().getAttribute('href')).toBe(`${prefix}-a/`)
   })
 })
diff --git a/site/test/lua-api-examples.test.ts b/site/test/lua-api-examples.test.ts
index 8839b5eb4..02e806915 100644
--- a/site/test/lua-api-examples.test.ts
+++ b/site/test/lua-api-examples.test.ts
@@ -15,8 +15,12 @@ describe('verified complete Lua API programs', () => {
     expect(examples).toHaveLength(11)
     expect(new Set(examples.map((example) => example.sourceFile)).size).toBe(7)
     expect(new Set(examples.map((example) => example.symbol)).size).toBe(examples.length)
-    expect(model.symbols.filter((symbol) => symbol.doc?.examples?.length)
-      .map((symbol) => symbol.id).sort()).toEqual(examples.map((example) => example.symbol).sort())
+    expect(
+      model.symbols
+        .filter((symbol) => symbol.doc?.examples?.length)
+        .map((symbol) => symbol.id)
+        .sort(),
+    ).toEqual(examples.map((example) => example.symbol).sort())
   })
 
   it.each(examples)('preserves the executed $symbol files and setup', (example) => {
@@ -40,8 +44,10 @@ describe('verified complete Lua API programs', () => {
       expect(block.code).not.toContain('\r')
       expect(hash(block.code), `${example.symbol}/${file.name}`).toBe(file.sha256)
       expect(hash(block.code.slice(0, -1))).toBe(file.clipboardSha256)
-      expect(exported.some((entry) => hash(entry.value + '\n') === file.sha256),
-        `${example.symbol}/${file.name} Markdown`).toBe(true)
+      expect(
+        exported.some((entry) => hash(entry.value + '\n') === file.sha256),
+        `${example.symbol}/${file.name} Markdown`,
+      ).toBe(true)
       expect(block.sourceUrl).toBe(`https://github.com/${model.repo}/blob/${example.sourceRevision}/${file.sourceFile}`)
       expect(markdown).toContain(`[Source example](${block.sourceUrl}).`)
       expect(block.intro).toContain(file.name)
@@ -49,8 +55,9 @@ describe('verified complete Lua API programs', () => {
         expect(line.length).toBeLessThanOrEqual(100)
       }
     }
-    expect(blocks.filter((block) => block.lang === 'console')
-      .map((block) => block.code.replace(/^\$ /gm, '').trim())).toEqual(example.shellRecipe)
+    expect(
+      blocks.filter((block) => block.lang === 'console').map((block) => block.code.replace(/^\$ /gm, '').trim()),
+    ).toEqual(example.shellRecipe)
     for (const index of example.consoleBlocks ?? []) {
       expect(exported.some((entry) => entry.value + '\n' === blocks[index].code)).toBe(true)
     }
diff --git a/site/test/machine-readable.test.ts b/site/test/machine-readable.test.ts
index 98fb12936..df89ff69c 100644
--- a/site/test/machine-readable.test.ts
+++ b/site/test/machine-readable.test.ts
@@ -29,10 +29,16 @@ const json = (file: string) => JSON.parse(readFileSync(join(DATA, file), 'utf8')
 const REPOS = new Set<string>(['libtmux/docs', TMUX_REPOSITORY, ...PORTS.map((port) => port.repo)])
 for (const file of readdirSync(join(DATA, 'api')).filter((name) => name.endsWith('.json'))) {
   const model = json(`api/${file}`)
-  for (const repo of [model.repo, ...(model.sources ?? []).map((source: { repo?: string }) => source.repo),
-    ...(model.symbols ?? []).map((symbol: { source?: { repo?: string } }) => symbol.source?.repo)]) if (repo) REPOS.add(repo)
+  for (const repo of [
+    model.repo,
+    ...(model.sources ?? []).map((source: { repo?: string }) => source.repo),
+    ...(model.symbols ?? []).map((symbol: { source?: { repo?: string } }) => symbol.source?.repo),
+  ])
+    if (repo) REPOS.add(repo)
 }
-for (const port of Object.values(json('mcp-tools.json').ports) as { registrations?: { source?: { repo?: string } }[] }[]) {
+for (const port of Object.values(json('mcp-tools.json').ports) as {
+  registrations?: { source?: { repo?: string } }[]
+}[]) {
   for (const tool of port.registrations ?? []) if (tool.source?.repo) REPOS.add(tool.source.repo)
 }
 const attr = (name: string) => new RegExp(`\\b${name}=(?:"([^"]*)"|'([^']*)'|([^\\s>]+))`)
@@ -71,7 +77,12 @@ describe('GitHub footer targets', () => {
   it.each(['kotlin', 'scala'])('accepts the declared %s directory at a branch, tag or revision', (slug) => {
     for (const ref of ['master', 'v0.0.1-alpha.17', 'a'.repeat(40), 'feature%2Fsource-links']) {
       for (const prefix of ['', 'pr-50/']) {
-        expect(githubSourceMatches(`https://github.com/libtmux/libtmux-java/tree/${ref}/libtmux-${slug}`, `${prefix}en/${slug}/latest/index.html`)).toBe(true)
+        expect(
+          githubSourceMatches(
+            `https://github.com/libtmux/libtmux-java/tree/${ref}/libtmux-${slug}`,
+            `${prefix}en/${slug}/latest/index.html`,
+          ),
+        ).toBe(true)
       }
     }
   })
@@ -102,7 +113,8 @@ function htmlFiles(): string[] {
   return LOCALES.filter((locale) => existsSync(join(ASSEMBLY_ROOT, locale))).flatMap((locale) =>
     (readdirSync(join(ASSEMBLY_ROOT, locale), { recursive: true }) as string[])
       .filter((file) => file.endsWith('.html'))
-      .map((file) => `${PREVIEW_PREFIX.slice(1)}${PREVIEW_PREFIX ? '/' : ''}${locale}/${file.replaceAll('\\', '/')}`))
+      .map((file) => `${PREVIEW_PREFIX.slice(1)}${PREVIEW_PREFIX ? '/' : ''}${locale}/${file.replaceAll('\\', '/')}`),
+  )
 }
 
 function resolves(href: string, page: string): boolean {
@@ -131,10 +143,13 @@ interface Footer {
 }
 
 function footerOf(html: string): Footer | undefined {
-  const block = /<div\b[^>]*\bclass=(?:"[^"]*\bpage-source\b[^"]*"|page-source\b)[^>]*>([\s\S]*?)<\/div>/.exec(html)?.[1]
+  const block = /<div\b[^>]*\bclass=(?:"[^"]*\bpage-source\b[^"]*"|page-source\b)[^>]*>([\s\S]*?)<\/div>/.exec(
+    html,
+  )?.[1]
   if (block === undefined) return undefined
   const hrefs = [...block.matchAll(/<a\b[^>]*>/g)].map((tag) => value(tag[0], 'href') ?? '')
-  const icon = [...html.slice(html.indexOf(block)).matchAll(/<a\b[^>]*>/g)].map((tag) => tag[0])
+  const icon = [...html.slice(html.indexOf(block)).matchAll(/<a\b[^>]*>/g)]
+    .map((tag) => tag[0])
     .find((tag) => value(tag, 'aria-label') === 'GitHub')
   const links = [...html.matchAll(/<link\b[^>]*>/g)].map((tag) => tag[0])
   const alternate = links.find((tag) => value(tag, 'rel') === 'alternate' && value(tag, 'type') === 'text/markdown')
@@ -172,11 +187,17 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
         problems.push(`${page}: no page-source footer`)
         continue
       }
-      for (const [name, href] of Object.entries({ markdown: footer.markdown, manifest: footer.manifest, llms: footer.llms, llmsFull: footer.llmsFull })) {
+      for (const [name, href] of Object.entries({
+        markdown: footer.markdown,
+        manifest: footer.manifest,
+        llms: footer.llms,
+        llmsFull: footer.llmsFull,
+      })) {
         if (!href) problems.push(`${page}: no ${name} link`)
         else if (!resolves(href, page)) problems.push(`${page}: ${name} ${href} does not exist`)
       }
-      if (footer.alternate !== footer.markdown) problems.push(`${page}: <head> Markdown ${footer.alternate} differs from footer ${footer.markdown}`)
+      if (footer.alternate !== footer.markdown)
+        problems.push(`${page}: <head> Markdown ${footer.alternate} differs from footer ${footer.markdown}`)
       if (footer.markdown && resolves(footer.markdown, page)) {
         const twin = new URL(footer.markdown, `https://libtmux.org/${page}`).pathname
         const text = readFileSync(join(BUCKET_ROOT, twin.replace(/^\//, '')), 'utf8')
@@ -187,8 +208,10 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
         if (named) {
           const path = new URL(named).pathname
           const own = (twin.endsWith('/index.md') ? `${path}index.md` : `${path.replace(/\/$/, '')}.md`) === twin
-          const canonical = footer.canonical && new URL(footer.canonical, `https://libtmux.org/${page}`).pathname === path
-          if (!own && !canonical) problems.push(`${page}: Markdown ${footer.markdown} names ${named}, neither its page nor its canonical URL`)
+          const canonical =
+            footer.canonical && new URL(footer.canonical, `https://libtmux.org/${page}`).pathname === path
+          if (!own && !canonical)
+            problems.push(`${page}: Markdown ${footer.markdown} names ${named}, neither its page nor its canonical URL`)
         }
       }
       const raw = footer.raw && /^https:\/\/github\.com\/([^/]+\/[^/]+)\/raw\/[^/]+\/(.+)$/.exec(footer.raw)
@@ -198,7 +221,8 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
         if (footer.source !== raw[2]) problems.push(`${page}: source ${footer.source} differs from raw path ${raw[2]}`)
         if (raw[1] === 'libtmux/docs' && !tracked.has(raw[2])) problems.push(`${page}: source ${raw[2]} is not tracked`)
       }
-      if (!githubSourceMatches(footer.github, page)) problems.push(`${page}: GitHub icon ${footer.github} is not a declared source target`)
+      if (!githubSourceMatches(footer.github, page))
+        problems.push(`${page}: GitHub icon ${footer.github} is not a declared source target`)
     }
     expect(checked, 'shell pages found').toBeGreaterThan(0)
     expect(problems.slice(0, 40), `${problems.length} footer problems across ${checked} pages`).toEqual([])
@@ -210,7 +234,9 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
     const problems: string[] = []
     let checked = 0
     for (const locale of LOCALES.filter((locale) => existsSync(join(ASSEMBLY_ROOT, locale, 'llms-full.txt')))) {
-      for (const section of readFileSync(join(ASSEMBLY_ROOT, locale, 'llms-full.txt'), 'utf8').split('\n---\n\n').slice(1)) {
+      for (const section of readFileSync(join(ASSEMBLY_ROOT, locale, 'llms-full.txt'), 'utf8')
+        .split('\n---\n\n')
+        .slice(1)) {
         const url = /^Source: (\S+)$/m.exec(section)?.[1]
         if (!url) {
           problems.push(`${locale}/llms-full.txt: a section names no page`)
@@ -233,7 +259,8 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
         const here = new URL(url).pathname
         if (path !== (path.endsWith('/index.md') ? `${here}index.md` : `${here.replace(/\/$/, '')}.md`)) continue
         checked++
-        if (readFileSync(twin, 'utf8').trim() !== section.trim()) problems.push(`${locale}/llms-full.txt: ${url} differs from ${alternate}`)
+        if (readFileSync(twin, 'utf8').trim() !== section.trim())
+          problems.push(`${locale}/llms-full.txt: ${url} differs from ${alternate}`)
       }
     }
     expect(checked, 'llms-full.txt sections found').toBeGreaterThan(0)
@@ -246,7 +273,9 @@ describe.skipIf(!SITE_BUILT)('machine-readable footer', () => {
     const problems: string[] = []
     let checked = 0
     for (const locale of LOCALES.filter((locale) => existsSync(join(ASSEMBLY_ROOT, locale, 'docs.json')))) {
-      const manifest = JSON.parse(readFileSync(join(ASSEMBLY_ROOT, locale, 'docs.json'), 'utf8')) as { pages: { url: string; markdownUrl: string; title: string }[] }
+      const manifest = JSON.parse(readFileSync(join(ASSEMBLY_ROOT, locale, 'docs.json'), 'utf8')) as {
+        pages: { url: string; markdownUrl: string; title: string }[]
+      }
       for (const entry of manifest.pages) {
         const file = join(BUCKET_ROOT, decodeURIComponent(new URL(entry.url).pathname).replace(/^\//, ''), 'index.html')
         if (!existsSync(file)) {
diff --git a/site/test/mcp-exports.test.ts b/site/test/mcp-exports.test.ts
index da5c94c69..ded0533e0 100644
--- a/site/test/mcp-exports.test.ts
+++ b/site/test/mcp-exports.test.ts
@@ -14,23 +14,42 @@ vi.mock('hast-util-from-html', async (importOriginal) => {
 
 afterEach(() => vi.unstubAllEnvs())
 
-const schema = { type: 'object', properties: { nested: {
-  type: 'array', items: { type: 'object', properties: { choice: { enum: ['pane', 'window'] } }, required: ['choice'] },
-} }, required: ['nested'], additionalProperties: false }
+const schema = {
+  type: 'object',
+  properties: {
+    nested: {
+      type: 'array',
+      items: { type: 'object', properties: { choice: { enum: ['pane', 'window'] } }, required: ['choice'] },
+    },
+  },
+  required: ['nested'],
+  additionalProperties: false,
+}
 const escape = (text: string) => text.replaceAll('&', '&amp;').replaceAll('<', '&lt;').replaceAll('"', '&quot;')
 const base = '/preview/en/go/v9-proof/'
 
 function fixture(run: (out: string, routes: ReturnType<typeof mcpReferenceRoutes>) => void) {
   const out = mkdtempSync(join(tmpdir(), 'libtmux-mcp-exports-'))
-  const write = (path: string, text: string) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, text) }
+  const write = (path: string, text: string) => {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, text)
+  }
   const routes = mcpReferenceRoutes('go', {}, 'v9-proof')
   try {
-    write(join(out, 'docs.json'), JSON.stringify({ pages: [{ title: 'Guide', url: `https://libtmux.org${base}guide/` }] }))
+    write(
+      join(out, 'docs.json'),
+      JSON.stringify({ pages: [{ title: 'Guide', url: `https://libtmux.org${base}guide/` }] }),
+    )
     write(join(out, 'llms.txt'), '# Guides\n\n## Documentation\n\n- [Guide](guide/)\n')
-    write(join(out, 'llms-full.txt'), `# Guides\n\n---\n\n${markdownDocument({ title: 'Guide', url: `https://libtmux.org${base}guide/`, body: 'Existing prose.' })}`)
+    write(
+      join(out, 'llms-full.txt'),
+      `# Guides\n\n---\n\n${markdownDocument({ title: 'Guide', url: `https://libtmux.org${base}guide/`, body: 'Existing prose.' })}`,
+    )
     for (const route of routes) {
       const source = MCP_REFERENCE.go.registrations.find((tool) => tool.wireName === route.toolName)?.source
-      write(join(out, route.path, 'index.html'), `<html><head>
+      write(
+        join(out, route.path, 'index.html'),
+        `<html><head>
 <link rel="canonical" href="https://libtmux.org/en/go/stable/${route.path}/">
 <link rel="alternate" type="text/markdown" data-twin="rendered" href="${base}${route.path}.md">
 <meta name="description" content="Resolved Go contract for ${route.toolName ?? 'catalog'}">
@@ -41,10 +60,13 @@ ${source ? `<a href="https://github.com/${source.repo}/blob/${source.revision}/$
 <h2 id="arguments">Arguments</h2><p>The nested selection is required.</p>
 <h2 id="schemas">Schemas</h2><details data-pagefind-ignore="all"><summary>Input schema</summary>
 <pre data-language="json"><code>${escape(JSON.stringify(schema, null, 2))}</code></pre></details>
-<button>Copy</button><nav>Other languages</nav></main></body></html>`)
+<button>Copy</button><nav>Other languages</nav></main></body></html>`,
+      )
     }
     run(out, routes)
-  } finally { rmSync(out, { recursive: true, force: true }) }
+  } finally {
+    rmSync(out, { recursive: true, force: true })
+  }
 }
 
 it.each(['en', 'ja'])('adds every selected-port MCP contract when the requested locale is %s', (locale) => {
@@ -67,8 +89,12 @@ it.each(['en', 'ja'])('adds every selected-port MCP contract when the requested
       expect(entry.markdownUrl).toBe(`https://libtmux.org${base}${path}.md`)
       expect(entry.source.repo).toBe('libtmux/libtmux-go')
       expect(entry.source.revision).toBe(MCP_REFERENCE.go.revision)
-      if (toolName) expect(entry.source).toEqual(MCP_REFERENCE.go.registrations.find((tool) => tool.wireName === toolName)!.source)
-      expect(entry.headings).toEqual([{ id: 'arguments', level: 2, text: 'Arguments' }, { id: 'schemas', level: 2, text: 'Schemas' }])
+      if (toolName)
+        expect(entry.source).toEqual(MCP_REFERENCE.go.registrations.find((tool) => tool.wireName === toolName)!.source)
+      expect(entry.headings).toEqual([
+        { id: 'arguments', level: 2, text: 'Arguments' },
+        { id: 'schemas', level: 2, text: 'Schemas' },
+      ])
       const twin = readFileSync(join(out, `${path}.md`), 'utf8')
       expect(full).toContain(twin)
       expect(index).toContain(`](${url})`)
@@ -97,31 +123,43 @@ it('keeps repeated export generation byte-identical', () => {
 
 it('parses each MCP twin once while preserving every final export byte', () => {
   let expected: string[] = []
-  for (const legacyOrder of [true, false]) fixture((out, routes) => {
-    // A translated root runs only the generic pass, reproducing the old first pass.
-    vi.stubEnv('LIBTMUX_DOCS_PORT', legacyOrder ? '' : 'go')
-    vi.stubEnv('LIBTMUX_DOCS_LOCALE', legacyOrder ? 'ja' : 'en')
-    vi.stubEnv('LIBTMUX_DOCS_VERSION', 'v9-proof')
-    writeFileSync(join(out, 'ordinary.html'), `<html><head>
+  for (const legacyOrder of [true, false])
+    fixture((out, routes) => {
+      // A translated root runs only the generic pass, reproducing the old first pass.
+      vi.stubEnv('LIBTMUX_DOCS_PORT', legacyOrder ? '' : 'go')
+      vi.stubEnv('LIBTMUX_DOCS_LOCALE', legacyOrder ? 'ja' : 'en')
+      vi.stubEnv('LIBTMUX_DOCS_VERSION', 'v9-proof')
+      writeFileSync(
+        join(out, 'ordinary.html'),
+        `<html><head>
 <link rel="canonical" href="https://libtmux.org${base}ordinary/">
 <link rel="alternate" type="text/markdown" data-twin="rendered" href="${base}ordinary.md">
-</head><body><main><h1>Ordinary page</h1><p>Keep this content.</p></main></body></html>`)
-    const hooks = markdownTwins().hooks
-    ;(hooks['astro:config:done'] as (value: unknown) => void)({ config: { base } })
-    vi.mocked(fromHtml).mockClear()
-    ;(hooks['astro:build:done'] as (value: unknown) => void)({ dir: new URL(`file://${out}/`), logger: { info() {} } })
-    if (legacyOrder) writeMcpExports(out, base, routes)
-    const files = ['docs.json', 'llms.txt', 'llms-full.txt', 'ordinary.md',
-      ...routes.map((route) => `${route.path}.md`)]
-    const actual = files.map((file) => readFileSync(join(out, file), 'utf8'))
-    if (legacyOrder) {
-      expected = actual
-      expect(fromHtml).toHaveBeenCalledTimes(routes.length * 2 + 1)
-    } else {
-      expect(actual).toEqual(expected)
-      expect(fromHtml).toHaveBeenCalledTimes(routes.length + 1)
-    }
-  })
+</head><body><main><h1>Ordinary page</h1><p>Keep this content.</p></main></body></html>`,
+      )
+      const hooks = markdownTwins().hooks
+      ;(hooks['astro:config:done'] as (value: unknown) => void)({ config: { base } })
+      vi.mocked(fromHtml).mockClear()
+      ;(hooks['astro:build:done'] as (value: unknown) => void)({
+        dir: new URL(`file://${out}/`),
+        logger: { info() {} },
+      })
+      if (legacyOrder) writeMcpExports(out, base, routes)
+      const files = [
+        'docs.json',
+        'llms.txt',
+        'llms-full.txt',
+        'ordinary.md',
+        ...routes.map((route) => `${route.path}.md`),
+      ]
+      const actual = files.map((file) => readFileSync(join(out, file), 'utf8'))
+      if (legacyOrder) {
+        expected = actual
+        expect(fromHtml).toHaveBeenCalledTimes(routes.length * 2 + 1)
+      } else {
+        expect(actual).toEqual(expected)
+        expect(fromHtml).toHaveBeenCalledTimes(routes.length + 1)
+      }
+    })
 })
 
 it('still rejects a missing ordinary source twin after MCP exports are written', () => {
@@ -129,14 +167,20 @@ it('still rejects a missing ordinary source twin after MCP exports are written',
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
     vi.stubEnv('LIBTMUX_DOCS_LOCALE', 'en')
     vi.stubEnv('LIBTMUX_DOCS_VERSION', 'v9-proof')
-    writeFileSync(join(out, 'missing.html'), `<html><head>
+    writeFileSync(
+      join(out, 'missing.html'),
+      `<html><head>
 <link rel="alternate" type="text/markdown" data-twin="source" href="${base}missing.md">
-</head><body><main>Missing source twin</main></body></html>`)
+</head><body><main>Missing source twin</main></body></html>`,
+    )
     const hooks = markdownTwins().hooks
     ;(hooks['astro:config:done'] as (value: unknown) => void)({ config: { base } })
-    expect(() => (hooks['astro:build:done'] as (value: unknown) => void)({
-      dir: new URL(`file://${out}/`), logger: { info() {} },
-    })).toThrow(/missing\.html.*missing\.md/)
+    expect(() =>
+      (hooks['astro:build:done'] as (value: unknown) => void)({
+        dir: new URL(`file://${out}/`),
+        logger: { info() {} },
+      }),
+    ).toThrow(/missing\.html.*missing\.md/)
   })
 })
 
diff --git a/site/test/mcp-preview.test.ts b/site/test/mcp-preview.test.ts
index 2528a4611..2a7d354f7 100644
--- a/site/test/mcp-preview.test.ts
+++ b/site/test/mcp-preview.test.ts
@@ -13,7 +13,9 @@ it('previews every captured protocol object at its actual versioned route', () =
       expect(preview.title).toBe(object.name)
       expect(preview.kind).toBe(object.kind)
       expect(preview.href).toBe(portPageUrl(PORT_BY_SLUG[port], 'v1', object.path))
-      expect(linkPreviewTarget(preview.href, 'https://libtmux.org')?.endpoint).toBe(preview.href.replace(/\/$/, '.preview.json'))
+      expect(linkPreviewTarget(preview.href, 'https://libtmux.org')?.endpoint).toBe(
+        preview.href.replace(/\/$/, '.preview.json'),
+      )
       expect(preview.signature).toBe(object.item?.uriTemplate ?? object.item?.uri)
     }
   }
@@ -30,8 +32,13 @@ it('preserves opt-in tool availability without inventing a callable signature',
 })
 
 it('does not turn protocol indexes or unknown categories into object previews', () => {
-  for (const path of ['/en/ts/latest/mcp/tools/', '/en/ts/latest/mcp/prompts/', '/en/ts/latest/mcp/resources/',
-    '/en/ts/latest/mcp/resources/templates/', '/en/ts/latest/mcp/unknown/foo/']) {
+  for (const path of [
+    '/en/ts/latest/mcp/tools/',
+    '/en/ts/latest/mcp/prompts/',
+    '/en/ts/latest/mcp/resources/',
+    '/en/ts/latest/mcp/resources/templates/',
+    '/en/ts/latest/mcp/unknown/foo/',
+  ]) {
     expect(linkPreviewTarget(path, 'https://libtmux.org')).toBeUndefined()
   }
 })
diff --git a/site/test/mcp-prose-links.test.ts b/site/test/mcp-prose-links.test.ts
index 58c7531fb..4246dd52d 100644
--- a/site/test/mcp-prose-links.test.ts
+++ b/site/test/mcp-prose-links.test.ts
@@ -12,7 +12,9 @@ afterEach(() => vi.unstubAllEnvs())
 const renderer = () => createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
 function markdownLinks(text: string): string[] {
   const hrefs: string[] = []
-  visit(fromMarkdown(text), 'link', (node) => { hrefs.push(node.url) })
+  visit(fromMarkdown(text), 'link', (node) => {
+    hrefs.push(node.url)
+  })
   return hrefs
 }
 
@@ -21,11 +23,17 @@ describe('MCP protocol links in site prose', () => {
     ['py', 'mcp:tool:capture_pane', 'tools/capture_pane', 'tool'],
     ['py', 'mcp:prompt:run_and_wait', 'prompts/run_and_wait', 'prompt'],
     ['ts', 'mcp:resource:tmux://capabilities', 'resources/capabilities', 'resource'],
-    ['py', 'mcp:resource-template:tmux://panes/{pane_id}{?socket_name}', 'resources/templates/get_pane', 'resource-template'],
+    [
+      'py',
+      'mcp:resource-template:tmux://panes/{pane_id}{?socket_name}',
+      'resources/templates/get_pane',
+      'resource-template',
+    ],
   ])('resolves the %s %s contract in HTML and Markdown outside MCP pages', async (port, reference, path, kind) => {
     const content = `Read \`${reference}\`.`
     const href = `/${port}/latest/mcp/${path}/`
-    const html = (await (await renderer()).render(content, { frontmatter: { port, route: 'guides/getting-started' } })).code
+    const html = (await (await renderer()).render(content, { frontmatter: { port, route: 'guides/getting-started' } }))
+      .code
     expect(html).toContain(`href="${href}"`)
     expect(html).toContain(`data-api-kind="${kind}" aria-hidden="true"`)
     const markdown = linkProseMarkdown(content, port)
@@ -37,28 +45,39 @@ describe('MCP protocol links in site prose', () => {
     const content = 'Use `capture_pane`, `run_and_wait`, and `tmux://panes/{pane_id}{?socket_name}`.'
     const processor = await renderer()
     const html = (await processor.render(content, { frontmatter: { port: 'py', product: 'mcp' } })).code
-    const expected = ['/py/latest/mcp/tools/capture_pane/', '/py/latest/mcp/prompts/run_and_wait/', '/py/latest/mcp/resources/templates/get_pane/']
+    const expected = [
+      '/py/latest/mcp/tools/capture_pane/',
+      '/py/latest/mcp/prompts/run_and_wait/',
+      '/py/latest/mcp/resources/templates/get_pane/',
+    ]
     for (const href of expected) expect(html).toContain(`href="${href}"`)
     expect(markdownLinks(linkProseMarkdown(content, 'py', 'mcp'))).toEqual(expected)
     const libraryHtml = (await processor.render(content, { frontmatter: { port: 'py' } })).code
     expect(libraryHtml).toContain('/py/latest/reference/libtmux-pane-capture_pane/')
     expect(libraryHtml).not.toMatch(/\/mcp\/(?:tools|prompts|resources)\//)
-    expect(markdownLinks(linkProseMarkdown(content, 'py')).some((href) => /\/mcp\/(?:tools|prompts|resources)\//.test(href))).toBe(false)
+    expect(
+      markdownLinks(linkProseMarkdown(content, 'py')).some((href) => /\/mcp\/(?:tools|prompts|resources)\//.test(href)),
+    ).toBe(false)
   })
 
   it('resolves explicit Markdown destinations without changing labels, titles or authored ordinary links', async () => {
-    const content = 'Read [the wait workflow](mcp:prompt:run_and_wait "Workflow") and [the pane](mcp:resource-template:tmux://panes/{pane_id}{?socket_name}). Keep [this link](https://example.com/).'
+    const content =
+      'Read [the wait workflow](mcp:prompt:run_and_wait "Workflow") and [the pane](mcp:resource-template:tmux://panes/{pane_id}{?socket_name}). Keep [this link](https://example.com/).'
     const html = (await (await renderer()).render(content, { frontmatter: { port: 'py' } })).code
     const markdown = linkProseMarkdown(content, 'py', undefined, {
-      resolved: (href) => `https://libtmux.org${href}`, authored: (href) => href,
+      resolved: (href) => `https://libtmux.org${href}`,
+      authored: (href) => href,
     })
     expect(html).toContain('href="/py/latest/mcp/prompts/run_and_wait/" title="Workflow"')
     expect(html).toContain('data-api-kind="prompt"')
     expect(html).toContain('href="/py/latest/mcp/resources/templates/get_pane/"')
-    expect(markdown).toContain('[the wait workflow](https://libtmux.org/py/latest/mcp/prompts/run_and_wait/ "Workflow")')
+    expect(markdown).toContain(
+      '[the wait workflow](https://libtmux.org/py/latest/mcp/prompts/run_and_wait/ "Workflow")',
+    )
     expect(markdownLinks(markdown)).toEqual([
       'https://libtmux.org/py/latest/mcp/prompts/run_and_wait/',
-      'https://libtmux.org/py/latest/mcp/resources/templates/get_pane/', 'https://example.com/',
+      'https://libtmux.org/py/latest/mcp/resources/templates/get_pane/',
+      'https://example.com/',
     ])
     expect(markdown).not.toContain('data-api-kind')
   })
@@ -66,13 +85,19 @@ describe('MCP protocol links in site prose', () => {
   it('does not borrow a capability from another port or infer an unknown explicit object', () => {
     const link = createProseLinker('mcp')
     for (const [port, text] of [
-      ['ts', 'mcp:prompt:run_and_wait'], ['julia', 'mcp:tool:list_sessions'],
-      ['py', 'mcp:resource:tmux://capabilities'], ['py', 'mcp:tool:not_a_tool'],
+      ['ts', 'mcp:prompt:run_and_wait'],
+      ['julia', 'mcp:tool:list_sessions'],
+      ['py', 'mcp:resource:tmux://capabilities'],
+      ['py', 'mcp:tool:not_a_tool'],
       ['py', 'mcp:tool:run_and_wait'],
-    ]) expect(link(text, { pagePort: port }).kind, `${port}/${text}`).toBe('unresolved')
+    ])
+      expect(link(text, { pagePort: port }).kind, `${port}/${text}`).toBe('unresolved')
     expect(link('mcp:tool:list_sessions', {}).kind).toBe('unresolved')
     expect(link('mcp:prompt:run_and_wait', {})).toMatchObject({ kind: 'link', port: 'py' })
-    expect(link('mcp:prompt:run_and_wait', { pagePort: 'ts', before: 'Python offers ' })).toMatchObject({ kind: 'link', port: 'py' })
+    expect(link('mcp:prompt:run_and_wait', { pagePort: 'ts', before: 'Python offers ' })).toMatchObject({
+      kind: 'link',
+      port: 'py',
+    })
   })
 
   it('resolves encoded URI templates in both renderers while retaining authored text and code', async () => {
@@ -92,7 +117,8 @@ describe('MCP protocol links in site prose', () => {
   })
 
   it('preserves malformed, unknown and unsupported encoded MCP destinations', async () => {
-    const content = '[malformed](mcp:resource-template:tmux://panes/%ZZ) and [unknown](mcp:resource-template:tmux://missing/%7Bid%7D).'
+    const content =
+      '[malformed](mcp:resource-template:tmux://panes/%ZZ) and [unknown](mcp:resource-template:tmux://missing/%7Bid%7D).'
     expect(linkProseMarkdown(content, 'py')).toBe(content)
     await expect((await renderer()).render(content, { frontmatter: { port: 'py' } })).resolves.toBeDefined()
     const unsupported = '[pane](mcp:resource-template:tmux://panes/%7Bpane_id%7D%7B?socket_name%7D)'
@@ -104,8 +130,12 @@ describe('MCP protocol links in site prose', () => {
     vi.stubEnv('LIBTMUX_DOCS_VERSION', 'next')
     vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{"ts":"stable"}')
     const link = createProseLinker()
-    expect(link('mcp:prompt:run_and_wait', { pagePort: 'py' })).toMatchObject({ href: '/py/next/mcp/prompts/run_and_wait/' })
-    expect(link('mcp:resource:tmux://capabilities', { pagePort: 'ts' })).toMatchObject({ href: '/ts/stable/mcp/resources/capabilities/' })
+    expect(link('mcp:prompt:run_and_wait', { pagePort: 'py' })).toMatchObject({
+      href: '/py/next/mcp/prompts/run_and_wait/',
+    })
+    expect(link('mcp:resource:tmux://capabilities', { pagePort: 'ts' })).toMatchObject({
+      href: '/ts/stable/mcp/resources/capabilities/',
+    })
   })
 
   it('marks the actual relative or absolute destination, excluding ordinary pages, fields and foreign hosts', async () => {
@@ -114,7 +144,8 @@ describe('MCP protocol links in site prose', () => {
       '[prompt](../../prompts/run_and_wait/)',
       '[template](../../resources/templates/get_pane/)',
       '[resource](/en/go/latest/mcp/resources/tmux-capabilities/)',
-      '[overview](../../tools/)', '[unknown](../../tools/missing_tool/)',
+      '[overview](../../tools/)',
+      '[unknown](../../tools/missing_tool/)',
       '[argument](../../tools/capture_pane/#mcp.tool.capture_pane.arguments.pane_id)',
       '[fragment](#mcp.tool.capture_pane)',
       '[foreign](https://example.com/en/py/latest/mcp/tools/capture_pane/)',
@@ -129,8 +160,13 @@ describe('MCP protocol links in site prose', () => {
       if (node.properties.dataApiKind) badges.push(String(node.properties.dataApiKind))
     })
     expect(badges).toEqual(['tool', 'prompt', 'resource-template', 'resource'])
-    expect(html).toContain('<pre><code class="language-json">{"name":"capture_pane", "note":"mcp:prompt:run_and_wait"}\n</code></pre>')
-    const twice = await createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks, rehypeApiLinks], syntaxHighlight: false })
+    expect(html).toContain(
+      '<pre><code class="language-json">{"name":"capture_pane", "note":"mcp:prompt:run_and_wait"}\n</code></pre>',
+    )
+    const twice = await createMarkdownProcessor({
+      rehypePlugins: [rehypeApiLinks, rehypeApiLinks],
+      syntaxHighlight: false,
+    })
     expect((await twice.render(content, { frontmatter })).code).toBe(html)
     expect(linkProseMarkdown(content, 'py', 'mcp')).toBe(content)
   })
diff --git a/site/test/mcp-protocol.outer.test.ts b/site/test/mcp-protocol.outer.test.ts
index 145f2e979..adb4336ae 100644
--- a/site/test/mcp-protocol.outer.test.ts
+++ b/site/test/mcp-protocol.outer.test.ts
@@ -7,24 +7,32 @@ import { expect, it } from 'vitest'
 import { captureProtocol } from '../../scripts/lib/mcp-protocol.mjs'
 
 it.each(['kotlin', 'scala', 'fsharp'])('does not discover MCP tools for the %s library', (port) => {
-  expect(execFileSync(process.execPath, [
-    new URL('../../scripts/gen-mcp-protocol.mjs', import.meta.url).pathname, '--port', port,
-  ], { encoding: 'utf8' })).toBe('')
+  expect(
+    execFileSync(
+      process.execPath,
+      [new URL('../../scripts/gen-mcp-protocol.mjs', import.meta.url).pathname, '--port', port],
+      { encoding: 'utf8' },
+    ),
+  ).toBe('')
 })
 
 it('retains startup diagnostics when the server closes stdin immediately', async () => {
-  await expect(captureProtocol({
-    command: process.execPath,
-    args: ['-e', 'require("node:fs").writeSync(2, "fixture startup refused\\n"); process.exit(2)'],
-    timeoutMs: 3000,
-  })).rejects.toThrow('fixture startup refused')
+  await expect(
+    captureProtocol({
+      command: process.execPath,
+      args: ['-e', 'require("node:fs").writeSync(2, "fixture startup refused\\n"); process.exit(2)'],
+      timeoutMs: 3000,
+    }),
+  ).rejects.toThrow('fixture startup refused')
 })
 
 it('joins a discovery process that ignores graceful shutdown', async () => {
   const directory = mkdtempSync(join(tmpdir(), 'libtmux-docs-protocol-test-'))
   const script = join(directory, 'server.mjs')
   const pidFile = join(directory, 'pid')
-  writeFileSync(script, `
+  writeFileSync(
+    script,
+    `
 import { writeFileSync } from 'node:fs'
 import { createInterface } from 'node:readline'
 writeFileSync(process.argv[2], String(process.pid))
@@ -36,14 +44,19 @@ createInterface({ input: process.stdin }).on('line', (line) => {
     protocolVersion: '2025-11-25', serverInfo: { name: 'fixture', version: '1' }, capabilities: {},
   } }))
 })
-`)
+`,
+  )
   try {
     const result = await captureProtocol({ command: process.execPath, args: [script, pidFile], timeoutMs: 3000 })
     expect(result.serverInfo.name).toBe('fixture')
     const pid = Number(readFileSync(pidFile, 'utf8'))
     expect(() => process.kill(pid, 0), 'discovery must join its owned process before returning').toThrow()
   } finally {
-    try { process.kill(Number(readFileSync(pidFile, 'utf8')), 'SIGKILL') } catch { /* Already joined. */ }
+    try {
+      process.kill(Number(readFileSync(pidFile, 'utf8')), 'SIGKILL')
+    } catch {
+      /* Already joined. */
+    }
     rmSync(directory, { recursive: true, force: true })
   }
 }, 5000)
diff --git a/site/test/mcp-reference.test.ts b/site/test/mcp-reference.test.ts
index 2e6780c16..2ca0ff89f 100644
--- a/site/test/mcp-reference.test.ts
+++ b/site/test/mcp-reference.test.ts
@@ -1,29 +1,49 @@
 import { readFileSync } from 'node:fs'
 import { expect, it } from 'vitest'
 import catalogs from '../src/data/mcp-tools.json'
-import { equivalentMcpTool, equivalentMcpObject, MCP_REFERENCE, mcpObjects, mcpObjectAt, mcpReferenceRoutes, mcpNavigation, resolveMcpObject, renderToolDescription, toolSummary } from '../src/lib/mcp-reference'
+import {
+  equivalentMcpTool,
+  equivalentMcpObject,
+  MCP_REFERENCE,
+  mcpObjects,
+  mcpObjectAt,
+  mcpReferenceRoutes,
+  mcpNavigation,
+  resolveMcpObject,
+  renderToolDescription,
+  toolSummary,
+} from '../src/lib/mcp-reference'
 import { apiTreeHref, searchApi } from '../src/lib/api-search'
 import { PORTS } from '../src/lib/ports'
 
-it.each(Object.entries(catalogs.ports))('keeps the %s catalog bound to its committed native snapshot', (port, catalog) => {
-  const snapshot = JSON.parse(readFileSync(new URL(`../src/data/mcp-protocol/${port}.json`, import.meta.url), 'utf8'))
-  const { tools, ...protocol } = snapshot.protocol as {
-    tools: (Record<string, unknown> & { name: string })[]
-  }
-  expect(catalog.repo).toBe(snapshot.repo)
-  expect(catalog.extractedRevision).toBe(snapshot.revision)
-  expect(catalog.selection).toEqual(snapshot.selection)
-  expect(catalog.protocol).toEqual(protocol)
-  expect(catalog.registrations.map((tool) => tool.wireName).sort()).toEqual(tools.map((tool) => tool.name).sort())
-  const contract = ({ description, inputSchema, outputSchema, annotations, meta, _meta }: Record<string, unknown>) =>
-    ({ description, inputSchema, outputSchema, annotations, meta: meta ?? _meta })
-  for (const tool of tools) {
-    const registration = catalog.registrations.find((entry) => entry.wireName === tool.name)!
-    expect(registration.source.repo, tool.name).toBe(snapshot.repo)
-    expect(registration.source.extractedRevision, tool.name).toBe(snapshot.revision)
-    expect(contract(registration), tool.name).toEqual(contract(tool))
-  }
-})
+it.each(Object.entries(catalogs.ports))(
+  'keeps the %s catalog bound to its committed native snapshot',
+  (port, catalog) => {
+    const snapshot = JSON.parse(readFileSync(new URL(`../src/data/mcp-protocol/${port}.json`, import.meta.url), 'utf8'))
+    const { tools, ...protocol } = snapshot.protocol as {
+      tools: (Record<string, unknown> & { name: string })[]
+    }
+    expect(catalog.repo).toBe(snapshot.repo)
+    expect(catalog.extractedRevision).toBe(snapshot.revision)
+    expect(catalog.selection).toEqual(snapshot.selection)
+    expect(catalog.protocol).toEqual(protocol)
+    expect(catalog.registrations.map((tool) => tool.wireName).sort()).toEqual(tools.map((tool) => tool.name).sort())
+    const contract = ({
+      description,
+      inputSchema,
+      outputSchema,
+      annotations,
+      meta,
+      _meta,
+    }: Record<string, unknown>) => ({ description, inputSchema, outputSchema, annotations, meta: meta ?? _meta })
+    for (const tool of tools) {
+      const registration = catalog.registrations.find((entry) => entry.wireName === tool.name)!
+      expect(registration.source.repo, tool.name).toBe(snapshot.repo)
+      expect(registration.source.extractedRevision, tool.name).toBe(snapshot.revision)
+      expect(contract(registration), tool.name).toEqual(contract(tool))
+    }
+  },
+)
 
 it('preserves protocol description structure while keeping index summaries short', async () => {
   const description = 'Read a pane.\n\n## Example\n\n```json\n{"pane_id":"%1"}\n```'
@@ -51,8 +71,9 @@ it('links equivalent operations whose registered names differ', () => {
   const ports = ['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift']
   const groups = [
     [['py', 'run_command'], ...ports.map((port) => [port, 'run_shell_command'])],
-    ...['create_session', 'create_window', 'split_window', 'snapshot_pane']
-      .map((name) => ['py', ...ports].map((port) => [port, name])),
+    ...['create_session', 'create_window', 'split_window', 'snapshot_pane'].map((name) =>
+      ['py', ...ports].map((port) => [port, name]),
+    ),
     ports.map((port) => [port, 'clear_pane_scrollback']),
   ]
   for (const group of groups) {
@@ -75,14 +96,18 @@ it('keeps different effects and unavailable tools out of the equivalents', () =>
 })
 
 it('links only registered tool mentions in description prose', async () => {
-  const description = 'Use capture_since after `capture_pane`. Keep `missing_tool` plain.\n\n[send_keys](https://example.com/) already has a link.\n\n```json\n{"name":"capture_pane"}\n```'
+  const description =
+    'Use capture_since after `capture_pane`. Keep `missing_tool` plain.\n\n[send_keys](https://example.com/) already has a link.\n\n```json\n{"name":"capture_pane"}\n```'
   const html = await renderToolDescription(description, { port: 'py', version: 'stable', toolName: 'capture_since' })
   expect(html).toContain('/py/stable/mcp/tools/capture_pane/"')
   expect(html).not.toContain('/py/stable/mcp/tools/capture_since/"')
   expect(html).not.toContain('/mcp/tools/missing_tool/')
   expect(html).not.toContain('/mcp/tools/send_keys/')
   expect(html.match(/\/py\/stable\/mcp\/tools\/capture_pane\/"/g)).toHaveLength(1)
-  const dotnet = await renderToolDescription('Use capture_pane or `run_shell_command`.', { port: 'csharp', version: 'latest' })
+  const dotnet = await renderToolDescription('Use capture_pane or `run_shell_command`.', {
+    port: 'csharp',
+    version: 'latest',
+  })
   expect(dotnet).toContain('/csharp/latest/mcp/tools/capture_pane/')
   expect(dotnet).toContain('/csharp/latest/mcp/tools/run_shell_command/')
 })
@@ -100,7 +125,11 @@ it.each(Object.keys(MCP_REFERENCE))('routes and indexes every advertised %s prot
   expect(objects.map(({ kind, name }) => [kind, name])).toEqual(expected)
   expect(new Set(objects.map((object) => object.id)).size).toBe(expected.length)
   const routes = mcpReferenceRoutes(port, {}, 'next')
-  expect(routes.filter((route) => !route.itemSlug).map((route) => route.path)).toEqual(['mcp/tools', 'mcp/prompts', 'mcp/resources'])
+  expect(routes.filter((route) => !route.itemSlug).map((route) => route.path)).toEqual([
+    'mcp/tools',
+    'mcp/prompts',
+    'mcp/resources',
+  ])
   expect(routes).toHaveLength(expected.length + 3)
   const navigation = mcpNavigation(port)
   const all = searchApi(navigation.json, '')
@@ -112,15 +141,25 @@ it.each(Object.keys(MCP_REFERENCE))('routes and indexes every advertised %s prot
     const result = searchApi(navigation.json, object.name, object.section).find((row) => row.id === object.id)!
     expect(result, object.id).toMatchObject({ name: object.name, kind: object.kind, category: object.section })
     expect(apiTreeHref(`/${port}/next/mcp/`, result)).toBe(`/${port}/next/${object.path}/`)
-    expect(searchApi(navigation.json, object.name, object.section === 'tools' ? 'prompts' : 'tools').some((row) => row.id === object.id)).toBe(false)
+    expect(
+      searchApi(navigation.json, object.name, object.section === 'tools' ? 'prompts' : 'tools').some(
+        (row) => row.id === object.id,
+      ),
+    ).toBe(false)
   }
 })
 
 it('keeps resource URI identity distinct from display names and template identities', () => {
   const object = resolveMcpObject('ts', 'mcp:resource:tmux://capabilities')!
   expect(object).toMatchObject({ id: 'mcp.resource.tmux://capabilities', name: 'capabilities' })
-  expect(equivalentMcpObject('ts', object, 'go')).toMatchObject({ name: 'tmux capabilities', path: 'mcp/resources/tmux-capabilities' })
-  expect(equivalentMcpObject('ts', object, 'csharp')).toMatchObject({ name: 'tmux_capabilities', path: 'mcp/resources/tmux_capabilities' })
+  expect(equivalentMcpObject('ts', object, 'go')).toMatchObject({
+    name: 'tmux capabilities',
+    path: 'mcp/resources/tmux-capabilities',
+  })
+  expect(equivalentMcpObject('ts', object, 'csharp')).toMatchObject({
+    name: 'tmux_capabilities',
+    path: 'mcp/resources/tmux_capabilities',
+  })
   expect(equivalentMcpObject('ts', object, 'py')).toBeUndefined()
   const template = resolveMcpObject('py', 'mcp:resource-template:tmux://panes/{pane_id}{?socket_name}')!
   expect(template).toMatchObject({ name: 'get_pane', path: 'mcp/resources/templates/get_pane' })
@@ -134,7 +173,11 @@ it('does not invent protocol objects for ports without a captured contract', ()
     expect(resolveMcpObject(port, 'mcp:tool:list_sessions')).toBeUndefined()
   }
   const routes = mcpReferenceRoutes(undefined, { py: 'stable', ts: 'next' }, 'ignored')
-  expect(routes.find((route) => route.port === 'py' && route.section === 'prompts' && !route.itemSlug)?.path).toBe('py/stable/mcp/prompts')
-  expect(routes.find((route) => route.port === 'ts' && route.section === 'resources' && !route.itemSlug)?.path).toBe('ts/next/mcp/resources')
+  expect(routes.find((route) => route.port === 'py' && route.section === 'prompts' && !route.itemSlug)?.path).toBe(
+    'py/stable/mcp/prompts',
+  )
+  expect(routes.find((route) => route.port === 'ts' && route.section === 'resources' && !route.itemSlug)?.path).toBe(
+    'ts/next/mcp/resources',
+  )
   expect(new Set(routes.map((route) => route.path)).size).toBe(routes.length)
 })
diff --git a/site/test/mcp-schema.test.ts b/site/test/mcp-schema.test.ts
index 73dcd6ed5..df422e308 100644
--- a/site/test/mcp-schema.test.ts
+++ b/site/test/mcp-schema.test.ts
@@ -4,11 +4,23 @@ import { createRequire } from 'node:module'
 import { pathToFileURL } from 'node:url'
 import { experimental_AstroContainer } from 'astro/container'
 import { Window } from 'happy-dom'
-import { inlineSchemaItem, schemaAnchor, schemaChildren, schemaConstraints, schemaDefinitions, schemaReference, schemaType, schemaTypeParts, type McpSchema } from '../src/lib/mcp-schema'
+import {
+  inlineSchemaItem,
+  schemaAnchor,
+  schemaChildren,
+  schemaConstraints,
+  schemaDefinitions,
+  schemaReference,
+  schemaType,
+  schemaTypeParts,
+  type McpSchema,
+} from '../src/lib/mcp-schema'
 
 describe('MCP structured schemas', () => {
   const schema: McpSchema = {
-    type: 'object', required: ['pane/id'], additionalProperties: false,
+    type: 'object',
+    required: ['pane/id'],
+    additionalProperties: false,
     properties: {
       'pane/id': { type: 'string', description: 'The target pane.' },
       settings: { type: 'object', properties: { timeout: { type: ['integer', 'null'], default: 0, minimum: 0 } } },
@@ -20,14 +32,22 @@ describe('MCP structured schemas', () => {
 
   it('gives escaped nested fields independent identities and preserves required metadata', () => {
     const fields = schemaChildren(schema)
-    expect(fields.find((field) => field.name === 'pane/id')).toMatchObject({ path: '/properties/pane~1id', required: true })
+    expect(fields.find((field) => field.name === 'pane/id')).toMatchObject({
+      path: '/properties/pane~1id',
+      required: true,
+    })
     expect(fields.find((field) => field.name === 'settings')).toMatchObject({ required: false })
     const settings = fields.find((field) => field.name === 'settings')!
     const timeout = schemaChildren(settings.schema)[0]
     const pointer = settings.path + timeout.path
-    expect(schemaAnchor('mcp.tool.test.input', pointer)).toBe('mcp.tool.test.input/properties/settings/properties/timeout')
+    expect(schemaAnchor('mcp.tool.test.input', pointer)).toBe(
+      'mcp.tool.test.input/properties/settings/properties/timeout',
+    )
     expect(schemaAnchor('mcp.tool.test.output', pointer)).not.toBe(schemaAnchor('mcp.tool.test.input', pointer))
-    expect(schemaConstraints(timeout.schema)).toEqual([['default', '0'], ['minimum', '0']])
+    expect(schemaConstraints(timeout.schema)).toEqual([
+      ['default', '0'],
+      ['minimum', '0'],
+    ])
     expect(schemaConstraints(schema)).toEqual([['additionalProperties', 'false']])
   })
 
@@ -35,7 +55,12 @@ describe('MCP structured schemas', () => {
     const reference = schemaReference(schema, '#/$defs/pane~1ref', 'mcp.tool.test.input')!
     const definition = schemaChildren(schema).find((child) => child.path === '/$defs/pane~1ref')!
     expect(decodeURIComponent(reference.slice(1))).toBe(schemaAnchor('mcp.tool.test.input', definition.path))
-    for (const invalid of ['https://example.com/schema.json#/$defs/pane', '#/$defs/missing', '#/%zz', '#/properties/settings/type']) {
+    for (const invalid of [
+      'https://example.com/schema.json#/$defs/pane',
+      '#/$defs/missing',
+      '#/%zz',
+      '#/properties/settings/type',
+    ]) {
       expect(schemaReference(schema, invalid, 'mcp.tool.test.input')).toBeUndefined()
     }
   })
@@ -67,20 +92,37 @@ describe('MCP structured schemas', () => {
     expect(schemaTypeParts({ type: ['integer', 'null'] }, schema, 'output').filter((part) => part.href)).toHaveLength(2)
     const nullable: McpSchema = { type: ['array', 'null'], items: { type: 'string' } }
     expect(schemaType(nullable)).toBe('Array<string> | null')
-    expect(schemaTypeParts(nullable, schema, 'output').map((part) => part.text).join('')).toBe('Array<string> | null')
-    expect(schemaTypeParts(nullable, schema, 'output').filter((part) => part.href).map((part) => part.text)).toEqual(['Array', 'string', 'null'])
+    expect(
+      schemaTypeParts(nullable, schema, 'output')
+        .map((part) => part.text)
+        .join(''),
+    ).toBe('Array<string> | null')
+    expect(
+      schemaTypeParts(nullable, schema, 'output')
+        .filter((part) => part.href)
+        .map((part) => part.text),
+    ).toEqual(['Array', 'string', 'null'])
     const singleton: McpSchema = { type: ['array'], items: { type: 'integer' } }
     expect(schemaType(singleton)).toBe('Array<integer>')
-    expect(schemaTypeParts(singleton, schema, 'output').map((part) => part.text).join('')).toBe('Array<integer>')
+    expect(
+      schemaTypeParts(singleton, schema, 'output')
+        .map((part) => part.text)
+        .join(''),
+    ).toBe('Array<integer>')
   })
 
   it('separates named types while preserving nested definition paths', () => {
-    const nested: McpSchema = { properties: { value: { $defs: { Local: { type: 'string' } } } },
-      definitions: { Result: { type: 'object', $defs: { Child: { type: 'boolean' } } } } }
+    const nested: McpSchema = {
+      properties: { value: { $defs: { Local: { type: 'string' } } } },
+      definitions: { Result: { type: 'object', $defs: { Child: { type: 'boolean' } } } },
+    }
     expect(schemaDefinitions(nested).map((entry) => entry.path)).toEqual([
-      '/properties/value/$defs/Local', '/definitions/Result', '/definitions/Result/$defs/Child',
+      '/properties/value/$defs/Local',
+      '/definitions/Result',
+      '/definitions/Result/$defs/Child',
     ])
-    for (const entry of schemaDefinitions(nested)) expect(schemaReference(nested, `#${entry.path}`, 'output')).toBe(`#${encodeURIComponent('output' + entry.path)}`)
+    for (const entry of schemaDefinitions(nested))
+      expect(schemaReference(nested, `#${entry.path}`, 'output')).toBe(`#${encodeURIComponent('output' + entry.path)}`)
     expect(inlineSchemaItem({ $ref: '#/definitions/Result' })).toBe(true)
     expect(inlineSchemaItem({ type: 'string', description: 'Keep this explanation.' })).toBe(false)
     expect(inlineSchemaItem({ type: 'string', minLength: 1 })).toBe(false)
@@ -92,17 +134,25 @@ describe('MCP structured schemas', () => {
     const compile = async (name: string, imports: Record<string, string>) => {
       const file = new URL(`../src/components/mcp/${name}.astro`, import.meta.url)
       const result = await transform(readFileSync(file, 'utf8').replace(/<style[\s\S]*?<\/style>/g, ''), {
-        filename: file.pathname, internalURL: 'astro/compiler-runtime', resultScopedSlot: true,
+        filename: file.pathname,
+        internalURL: 'astro/compiler-runtime',
+        resultScopedSlot: true,
         resolvePath: (specifier: string) => specifier,
       })
       expect(result.diagnostics.filter((entry: { severity: string }) => entry.severity === 'error')).toEqual([])
-      let code = result.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
-      for (const [specifier, target] of Object.entries(imports)) code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(target))
+      let code = result.code.replaceAll(
+        '"astro/compiler-runtime"',
+        JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+      )
+      for (const [specifier, target] of Object.entries(imports))
+        code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(target))
       return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`
     }
     const imports = { '../../lib/mcp-schema': new URL('../src/lib/mcp-schema.ts', import.meta.url).href }
     const type = await compile('McpSchemaType', imports)
-    const fields = await compile('McpSchema', { ...imports, './McpSchemaType.astro': type,
+    const fields = await compile('McpSchema', {
+      ...imports,
+      './McpSchemaType.astro': type,
       // These fixtures have no description prose; keep the rendering check independent of the full catalog.
       '../../lib/mcp-reference': 'data:text/javascript,export const renderToolDescription = async () => ""',
     })
@@ -110,12 +160,28 @@ describe('MCP structured schemas', () => {
     const container = await experimental_AstroContainer.create()
     const win = new Window()
     try {
-      for (const fixture of [{ type: 'integer', format: 'int32' },
-        { type: 'object', additionalProperties: false, properties: { height: { type: 'integer', minimum: 1 } } }]) {
-        win.document.body.innerHTML = await container.renderToString(component, { props: { schema: fixture, scope: 'output/$defs/Type', port: 'rs', version: 'latest' } })
-        const facts = [...win.document.querySelectorAll('dl.api-parameter-facts dt')].map((entry) => [entry.textContent, entry.nextElementSibling?.textContent])
-        expect(facts).toEqual(fixture.format ? [['format', '"int32"']] : [['additionalProperties', 'false'], ['minimum', '1']])
+      for (const fixture of [
+        { type: 'integer', format: 'int32' },
+        { type: 'object', additionalProperties: false, properties: { height: { type: 'integer', minimum: 1 } } },
+      ]) {
+        win.document.body.innerHTML = await container.renderToString(component, {
+          props: { schema: fixture, scope: 'output/$defs/Type', port: 'rs', version: 'latest' },
+        })
+        const facts = [...win.document.querySelectorAll('dl.api-parameter-facts dt')].map((entry) => [
+          entry.textContent,
+          entry.nextElementSibling?.textContent,
+        ])
+        expect(facts).toEqual(
+          fixture.format
+            ? [['format', '"int32"']]
+            : [
+                ['additionalProperties', 'false'],
+                ['minimum', '1'],
+              ],
+        )
       }
-    } finally { await win.happyDOM.abort() }
+    } finally {
+      await win.happyDOM.abort()
+    }
   })
 })
diff --git a/site/test/mcp-source-bound.outer.test.ts b/site/test/mcp-source-bound.outer.test.ts
index 4c6f607be..6a85d1614 100644
--- a/site/test/mcp-source-bound.outer.test.ts
+++ b/site/test/mcp-source-bound.outer.test.ts
@@ -1,5 +1,14 @@
 import { execFileSync, spawnSync, type SpawnSyncReturns } from 'node:child_process'
-import { chmodSync, copyFileSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'node:fs'
+import {
+  chmodSync,
+  copyFileSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { pathToFileURL } from 'node:url'
@@ -7,25 +16,52 @@ import { expect, it } from 'vitest'
 
 const root = new URL('../../', import.meta.url).pathname
 const files = [
-  'scripts/gen-mcp-protocol.mjs', 'scripts/gen-mcp-tools.mjs', 'scripts/lib/mcp-protocol.mjs',
-  'packages/api-model/src/source-lines.ts', 'site/src/lib/ports.ts',
-  'site/src/lib/site-root.ts', 'site/src/lib/cooldown.ts',
+  'scripts/gen-mcp-protocol.mjs',
+  'scripts/gen-mcp-tools.mjs',
+  'scripts/lib/mcp-protocol.mjs',
+  'packages/api-model/src/source-lines.ts',
+  'site/src/lib/ports.ts',
+  'site/src/lib/site-root.ts',
+  'site/src/lib/cooldown.ts',
 ]
-const tool = { name: 'list_sessions', description: 'Selected source contract', inputSchema: {
-  type: 'object', properties: { label: { type: 'string', description: 'Selected source argument' } },
-} }
+const tool = {
+  name: 'list_sessions',
+  description: 'Selected source contract',
+  inputSchema: {
+    type: 'object',
+    properties: { label: { type: 'string', description: 'Selected source argument' } },
+  },
+}
 
-function fixture(slug: 'go' | 'py' | 'ruby' | 'java' | 'swift' | 'julia', run: (fixture: {
-  directory: string; checkout: string; sha: string; model: string; snapshot: string; catalog: string;
-  discovery: string; env: NodeJS.ProcessEnv;
-  invoke: (script: 'protocol' | 'tools', args?: string[], env?: NodeJS.ProcessEnv) => SpawnSyncReturns<string>;
-}) => void, { javaLayout = 'catalog', toolPages = ['list-sessions.md'] }: {
-  javaLayout?: 'catalog' | 'toolsets'; toolPages?: readonly string[];
-} = {}) {
+function fixture(
+  slug: 'go' | 'py' | 'ruby' | 'java' | 'swift' | 'julia',
+  run: (fixture: {
+    directory: string
+    checkout: string
+    sha: string
+    model: string
+    snapshot: string
+    catalog: string
+    discovery: string
+    env: NodeJS.ProcessEnv
+    invoke: (script: 'protocol' | 'tools', args?: string[], env?: NodeJS.ProcessEnv) => SpawnSyncReturns<string>
+  }) => void,
+  {
+    javaLayout = 'catalog',
+    toolPages = ['list-sessions.md'],
+  }: {
+    javaLayout?: 'catalog' | 'toolsets'
+    toolPages?: readonly string[]
+  } = {},
+) {
   const directory = mkdtempSync(join(tmpdir(), 'libtmux-mcp-source-'))
   const checkout = join(directory, 'source')
-  const git = (...args: string[]) => execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
-  const write = (path: string, text: string) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, text) }
+  const git = (...args: string[]) =>
+    execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+  const write = (path: string, text: string) => {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, text)
+  }
   try {
     for (const file of files) {
       const target = join(directory, file)
@@ -35,18 +71,26 @@ function fixture(slug: 'go' | 'py' | 'ruby' | 'java' | 'swift' | 'julia', run: (
     write(join(directory, 'package.json'), '{"type":"module"}')
     if (slug === 'java') {
       const directory = join(checkout, 'libtmux-mcp/src/main/java/io/github/libtmux/mcp')
-      write(join(directory, javaLayout === 'catalog' ? 'Catalog.java' : 'InspectTools.java'),
-        `Catalog.tool("helper_only");\ntools.add(${javaLayout === 'catalog' ? 'inspect(' : 'Catalog.literalized(Catalog.tool('}"list_sessions")${javaLayout === 'catalog' ? ')' : '))'};\n`)
+      write(
+        join(directory, javaLayout === 'catalog' ? 'Catalog.java' : 'InspectTools.java'),
+        `Catalog.tool("helper_only");\ntools.add(${javaLayout === 'catalog' ? 'inspect(' : 'Catalog.literalized(Catalog.tool('}"list_sessions")${javaLayout === 'catalog' ? ')' : '))'};\n`,
+      )
       write(join(directory, 'CatalogTest.java'), 'tools.add(tool("test_only"));\n')
     } else if (slug === 'swift') {
-      write(join(checkout, 'Sources/LibTmuxMCP/ToolOperation.swift'),
-        'enum ToolOperation: String {\n\n    case listSessions = "list_sessions"\n}\n')
+      write(
+        join(checkout, 'Sources/LibTmuxMCP/ToolOperation.swift'),
+        'enum ToolOperation: String {\n\n    case listSessions = "list_sessions"\n}\n',
+      )
     } else if (slug === 'julia') {
-      write(join(checkout, 'packages/LibTmuxMCP/src/tools.jl'),
-        'const _TOOL_NAMES = (\n    "list_sessions",\n)\nconst _ROUTINE_TOOLS = ("list_sessions",)\nconst unrelated = "not_a_tool"\n')
+      write(
+        join(checkout, 'packages/LibTmuxMCP/src/tools.jl'),
+        'const _TOOL_NAMES = (\n    "list_sessions",\n)\nconst _ROUTINE_TOOLS = ("list_sessions",)\nconst unrelated = "not_a_tool"\n',
+      )
     } else {
-      write(join(checkout, slug === 'go' ? 'mcp/manifest_catalog.go' : 'src/libtmux_mcp/tools/sessions.py'),
-        slug === 'go' ? 'var catalog = []tool{{name: "list_sessions"}}\n' : 'mcp.tool()(list_sessions)\n')
+      write(
+        join(checkout, slug === 'go' ? 'mcp/manifest_catalog.go' : 'src/libtmux_mcp/tools/sessions.py'),
+        slug === 'go' ? 'var catalog = []tool{{name: "list_sessions"}}\n' : 'mcp.tool()(list_sessions)\n',
+      )
     }
     if (slug === 'py') {
       for (const page of toolPages) write(join(checkout, 'docs/tools', page), '# Tool documentation\n')
@@ -60,15 +104,36 @@ function fixture(slug: 'go' | 'py' | 'ruby' | 'java' | 'swift' | 'julia', run: (
     const snapshot = join(directory, `site/src/data/mcp-protocol/${slug}.json`)
     const catalog = join(directory, 'site/src/data/mcp-tools.json')
     const repo = slug === 'py' ? 'tmux-python/libtmux-mcp' : `libtmux/libtmux-${slug}`
-    write(model, JSON.stringify({ port: slug, revision: coreSha, sources: [{ product: 'mcp', repo, revision: sha, extractedRevision: sha }] }))
-    write(catalog, JSON.stringify({ generated: 'fixture', referenceDocumented: 54,
-      ports: Object.fromEntries(['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'julia'].map((port) => [port, {
-        tools: ['old_tool'], registrations: [{ wireName: 'old_tool' }], revision: 'a'.repeat(40),
-      }])),
-    }))
+    write(
+      model,
+      JSON.stringify({
+        port: slug,
+        revision: coreSha,
+        sources: [{ product: 'mcp', repo, revision: sha, extractedRevision: sha }],
+      }),
+    )
+    write(
+      catalog,
+      JSON.stringify({
+        generated: 'fixture',
+        referenceDocumented: 54,
+        ports: Object.fromEntries(
+          ['py', 'ruby', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'julia'].map((port) => [
+            port,
+            {
+              tools: ['old_tool'],
+              registrations: [{ wireName: 'old_tool' }],
+              revision: 'a'.repeat(40),
+            },
+          ]),
+        ),
+      }),
+    )
     const discovery = join(directory, 'discovery.json')
     const server = join(directory, 'server.mjs')
-    write(server, `
+    write(
+      server,
+      `
 import { writeFileSync } from 'node:fs'
 import { execFileSync } from 'node:child_process'
 import { createInterface } from 'node:readline'
@@ -85,18 +150,30 @@ createInterface({ input: process.stdin }).on('line', (line) => {
     : { tools: process.env.EMPTY_TOOLS === '1' ? [] : [${JSON.stringify(tool)}] }
   console.log(JSON.stringify({ jsonrpc: '2.0', id: message.id, result }))
 })
-`)
-    const env: NodeJS.ProcessEnv = { ...process.env, HOME: join(directory, 'empty-home'),
-      LIBTMUX_DOCS_PORT: slug, LIBTMUX_DOCS_SOURCE_SHA: coreSha,
-      [`LIBTMUX_DOCS_CHECKOUT_${slug.toUpperCase()}`]: checkout, LIBTMUX_DOCS_MCP_PY: checkout,
+`,
+    )
+    const env: NodeJS.ProcessEnv = {
+      ...process.env,
+      HOME: join(directory, 'empty-home'),
+      LIBTMUX_DOCS_PORT: slug,
+      LIBTMUX_DOCS_SOURCE_SHA: coreSha,
+      [`LIBTMUX_DOCS_CHECKOUT_${slug.toUpperCase()}`]: checkout,
+      LIBTMUX_DOCS_MCP_PY: checkout,
       [`LIBTMUX_DOCS_MCP_COMMAND_${slug.toUpperCase()}`]: JSON.stringify([process.execPath, server]),
-      TMUX: 'inherited-session', TMUX_PANE: '%123', LIBTMUX_TOOLSETS: 'teardown', LIBTMUX_SOCKET_PATH: '/must-not-use',
+      TMUX: 'inherited-session',
+      TMUX_PANE: '%123',
+      LIBTMUX_TOOLSETS: 'teardown',
+      LIBTMUX_SOCKET_PATH: '/must-not-use',
       LIBTMUX_MCP_LIVE: '0',
-      DISCOVERY: discovery, SOURCE: checkout,
+      DISCOVERY: discovery,
+      SOURCE: checkout,
     }
-    const invoke = (script: 'protocol' | 'tools', args: string[] = [], overrides: NodeJS.ProcessEnv = {}) => spawnSync(process.execPath,
-      [join(directory, `scripts/gen-mcp-${script}.mjs`), '--port', slug, '--source-bound', ...args],
-      { encoding: 'utf8', timeout: 10000, env: { ...env, ...overrides } })
+    const invoke = (script: 'protocol' | 'tools', args: string[] = [], overrides: NodeJS.ProcessEnv = {}) =>
+      spawnSync(
+        process.execPath,
+        [join(directory, `scripts/gen-mcp-${script}.mjs`), '--port', slug, '--source-bound', ...args],
+        { encoding: 'utf8', timeout: 10000, env: { ...env, ...overrides } },
+      )
     run({ directory, checkout, sha, model, snapshot, catalog, discovery, env, invoke })
   } finally {
     rmSync(directory, { recursive: true, force: true })
@@ -111,8 +188,13 @@ it('extracts only the Julia declared catalog and retains its native default sele
     expect(result.status, result.stderr).toBe(0)
     const registrations = JSON.parse(readFileSync(catalog, 'utf8')).ports.julia.registrations
     expect(registrations).toHaveLength(1)
-    expect(registrations[0]).toMatchObject({ wireName: 'list_sessions', enabledByDefault: true,
-      enableOption: '--tool', schemaStatus: 'runtime', source: { line: 2 } })
+    expect(registrations[0]).toMatchObject({
+      wireName: 'list_sessions',
+      enabledByDefault: true,
+      enableOption: '--tool',
+      schemaStatus: 'runtime',
+      source: { line: 2 },
+    })
   })
 })
 
@@ -124,126 +206,172 @@ it('cites the Swift enum case after a blank line', () => {
     expect(result.status, result.stderr).toBe(0)
     const registrations = JSON.parse(readFileSync(catalog, 'utf8')).ports.swift.registrations
     expect(registrations).toHaveLength(1)
-    expect(registrations[0]).toMatchObject({ wireName: 'list_sessions', source: {
-      file: 'Sources/LibTmuxMCP/ToolOperation.swift', line: 3,
-    } })
+    expect(registrations[0]).toMatchObject({
+      wireName: 'list_sessions',
+      source: {
+        file: 'Sources/LibTmuxMCP/ToolOperation.swift',
+        line: 3,
+      },
+    })
   })
 })
 
-it.each(['go', 'py'] as const)('binds the %s catalog to its actual MCP source and preserves unrelated catalogs', (slug) => {
-  fixture(slug, ({ sha, catalog, snapshot, discovery, invoke }) => {
-    const previous = JSON.parse(readFileSync(catalog, 'utf8'))
-    const captured = invoke('protocol')
-    expect(captured.status, captured.stderr).toBe(0)
-    const generated = invoke('tools')
-    expect(generated.status, generated.stderr).toBe(0)
-    const result = JSON.parse(readFileSync(catalog, 'utf8'))
-    expect(result.ports[slug].revision).toBe(sha)
-    expect(result.ports[slug].extractedRevision).toBe(sha)
-    expect(result.ports[slug].registrations[0]).toMatchObject({ ...tool, schemaStatus: 'runtime', source: { revision: sha, extractedRevision: sha } })
-    expect(JSON.parse(readFileSync(snapshot, 'utf8')).revision).toBe(sha)
-    for (const port of Object.keys(previous.ports).filter((port) => port !== slug)) expect(result.ports[port]).toEqual(previous.ports[port])
-    if (slug === 'go') expect(result.referenceDocumented).toBe(54)
-    else expect(result.referenceDocumented).toBe(1)
-    const environment = JSON.parse(readFileSync(discovery, 'utf8'))
-    expect(environment).toMatchObject({ toolsets: 'inspect,manage,execute,teardown', socket: 'libtmux-docs-protocol' })
-    expect(environment.tmux).toBeUndefined()
-    expect(environment.pane).toBeUndefined()
-    expect(environment.live).toBeUndefined()
-    expect(environment.tmp).toContain('libtmux-docs-mcp-')
-    expect(existsSync(environment.tmp)).toBe(false)
-  })
-})
+it.each(['go', 'py'] as const)(
+  'binds the %s catalog to its actual MCP source and preserves unrelated catalogs',
+  (slug) => {
+    fixture(slug, ({ sha, catalog, snapshot, discovery, invoke }) => {
+      const previous = JSON.parse(readFileSync(catalog, 'utf8'))
+      const captured = invoke('protocol')
+      expect(captured.status, captured.stderr).toBe(0)
+      const generated = invoke('tools')
+      expect(generated.status, generated.stderr).toBe(0)
+      const result = JSON.parse(readFileSync(catalog, 'utf8'))
+      expect(result.ports[slug].revision).toBe(sha)
+      expect(result.ports[slug].extractedRevision).toBe(sha)
+      expect(result.ports[slug].registrations[0]).toMatchObject({
+        ...tool,
+        schemaStatus: 'runtime',
+        source: { revision: sha, extractedRevision: sha },
+      })
+      expect(JSON.parse(readFileSync(snapshot, 'utf8')).revision).toBe(sha)
+      for (const port of Object.keys(previous.ports).filter((port) => port !== slug))
+        expect(result.ports[port]).toEqual(previous.ports[port])
+      if (slug === 'go') expect(result.referenceDocumented).toBe(54)
+      else expect(result.referenceDocumented).toBe(1)
+      const environment = JSON.parse(readFileSync(discovery, 'utf8'))
+      expect(environment).toMatchObject({
+        toolsets: 'inspect,manage,execute,teardown',
+        socket: 'libtmux-docs-protocol',
+      })
+      expect(environment.tmux).toBeUndefined()
+      expect(environment.pane).toBeUndefined()
+      expect(environment.live).toBeUndefined()
+      expect(environment.tmp).toContain('libtmux-docs-mcp-')
+      expect(existsSync(environment.tmp)).toBe(false)
+    })
+  },
+)
 
 it.each([
   ['complete', ['server/list-sessions.md', 'server/index.md'], null],
   ['extra', ['server/list-sessions.md', 'server/unknown-tool.md'], 'documented, not extracted: unknown_tool'],
   ['missing', ['server/index.md'], 'extracted, not documented: list_sessions'],
 ] as const)('checks nested Python tool pages: %s', (_scenario, toolPages, error) => {
-  fixture('py', ({ catalog, invoke }) => {
-    const captured = invoke('protocol')
-    expect(captured.status, captured.stderr).toBe(0)
-    const before = readFileSync(catalog, 'utf8')
-    const generated = invoke('tools')
-    if (error) {
-      expect(generated.status).not.toBe(0)
-      expect(generated.stderr).toContain(error)
-      expect(readFileSync(catalog, 'utf8')).toBe(before)
-    } else {
-      expect(generated.status, generated.stderr).toBe(0)
-      expect(JSON.parse(readFileSync(catalog, 'utf8')).referenceDocumented).toBe(1)
-    }
-  }, { toolPages })
+  fixture(
+    'py',
+    ({ catalog, invoke }) => {
+      const captured = invoke('protocol')
+      expect(captured.status, captured.stderr).toBe(0)
+      const before = readFileSync(catalog, 'utf8')
+      const generated = invoke('tools')
+      if (error) {
+        expect(generated.status).not.toBe(0)
+        expect(generated.stderr).toContain(error)
+        expect(readFileSync(catalog, 'utf8')).toBe(before)
+      } else {
+        expect(generated.status, generated.stderr).toBe(0)
+        expect(JSON.parse(readFileSync(catalog, 'utf8')).referenceDocumented).toBe(1)
+      }
+    },
+    { toolPages },
+  )
 })
 
-it.each(['catalog', 'toolsets'] as const)('binds Java %s registrations to runtime schemas and their source lines', (layout) => {
-  fixture('java', ({ sha, catalog, invoke }) => {
-    const captured = invoke('protocol')
-    expect(captured.status, captured.stderr).toBe(0)
-    const generated = invoke('tools')
-    expect(generated.status, generated.stderr).toBe(0)
-    const result = JSON.parse(readFileSync(catalog, 'utf8')).ports.java
-    expect(result.tools).toEqual(['list_sessions'])
-    expect(result.registrations).toEqual([expect.objectContaining({
-      ...tool, schemaStatus: 'runtime', source: {
-        repo: 'libtmux/libtmux-java', revision: sha, extractedRevision: sha,
-        file: `libtmux-mcp/src/main/java/io/github/libtmux/mcp/${layout === 'catalog' ? 'Catalog' : 'InspectTools'}.java`,
-        line: 2,
+it.each(['catalog', 'toolsets'] as const)(
+  'binds Java %s registrations to runtime schemas and their source lines',
+  (layout) => {
+    fixture(
+      'java',
+      ({ sha, catalog, invoke }) => {
+        const captured = invoke('protocol')
+        expect(captured.status, captured.stderr).toBe(0)
+        const generated = invoke('tools')
+        expect(generated.status, generated.stderr).toBe(0)
+        const result = JSON.parse(readFileSync(catalog, 'utf8')).ports.java
+        expect(result.tools).toEqual(['list_sessions'])
+        expect(result.registrations).toEqual([
+          expect.objectContaining({
+            ...tool,
+            schemaStatus: 'runtime',
+            source: {
+              repo: 'libtmux/libtmux-java',
+              revision: sha,
+              extractedRevision: sha,
+              file: `libtmux-mcp/src/main/java/io/github/libtmux/mcp/${layout === 'catalog' ? 'Catalog' : 'InspectTools'}.java`,
+              line: 2,
+            },
+          }),
+        ])
       },
-    })])
-  }, { javaLayout: layout })
-})
+      { javaLayout: layout },
+    )
+  },
+)
 
-it.each(['core revision', 'MCP revision', 'MCP repository'])('rejects an API model with the wrong %s before starting the server', (field) => {
-  fixture('go', ({ model, discovery, invoke }) => {
-    const value = JSON.parse(readFileSync(model, 'utf8'))
-    if (field === 'core revision') value.revision = 'b'.repeat(40)
-    else if (field === 'MCP revision') value.sources[0].extractedRevision = 'b'.repeat(40)
-    else value.sources[0].repo = 'other/repository'
-    writeFileSync(model, JSON.stringify(value))
-    for (const script of ['protocol', 'tools'] as const) {
-      const result = invoke(script)
-      expect(result.status).not.toBe(0)
-      expect(result.stderr).toContain('API model must describe the selected source and actual MCP checkout')
-    }
-    expect(existsSync(discovery)).toBe(false)
-  })
-})
+it.each(['core revision', 'MCP revision', 'MCP repository'])(
+  'rejects an API model with the wrong %s before starting the server',
+  (field) => {
+    fixture('go', ({ model, discovery, invoke }) => {
+      const value = JSON.parse(readFileSync(model, 'utf8'))
+      if (field === 'core revision') value.revision = 'b'.repeat(40)
+      else if (field === 'MCP revision') value.sources[0].extractedRevision = 'b'.repeat(40)
+      else value.sources[0].repo = 'other/repository'
+      writeFileSync(model, JSON.stringify(value))
+      for (const script of ['protocol', 'tools'] as const) {
+        const result = invoke(script)
+        expect(result.status).not.toBe(0)
+        expect(result.stderr).toContain('API model must describe the selected source and actual MCP checkout')
+      }
+      expect(existsSync(discovery)).toBe(false)
+    })
+  },
+)
 
-it.each(['revision', 'repo', 'missing', 'schema'])('rejects a %s protocol mismatch without replacing the catalog', (field) => {
-  fixture('go', ({ snapshot, catalog, invoke }) => {
-    expect(invoke('protocol').status).toBe(0)
-    const before = readFileSync(catalog, 'utf8')
-    const value = JSON.parse(readFileSync(snapshot, 'utf8'))
-    if (field === 'revision') value.revision = 'b'.repeat(40)
-    else if (field === 'repo') value.repo = 'other/repository'
-    else if (field === 'schema') delete value.protocol.tools[0].inputSchema
-    if (field === 'missing') rmSync(snapshot)
-    else writeFileSync(snapshot, JSON.stringify(value))
-    const result = invoke('tools')
-    expect(result.status).not.toBe(0)
-    expect(result.stderr).toMatch(/another source revision or repository|requires a runtime protocol snapshot|runtime schemas missing/)
-    expect(readFileSync(catalog, 'utf8')).toBe(before)
-  })
-})
+it.each(['revision', 'repo', 'missing', 'schema'])(
+  'rejects a %s protocol mismatch without replacing the catalog',
+  (field) => {
+    fixture('go', ({ snapshot, catalog, invoke }) => {
+      expect(invoke('protocol').status).toBe(0)
+      const before = readFileSync(catalog, 'utf8')
+      const value = JSON.parse(readFileSync(snapshot, 'utf8'))
+      if (field === 'revision') value.revision = 'b'.repeat(40)
+      else if (field === 'repo') value.repo = 'other/repository'
+      else if (field === 'schema') delete value.protocol.tools[0].inputSchema
+      if (field === 'missing') rmSync(snapshot)
+      else writeFileSync(snapshot, JSON.stringify(value))
+      const result = invoke('tools')
+      expect(result.status).not.toBe(0)
+      expect(result.stderr).toMatch(
+        /another source revision or repository|requires a runtime protocol snapshot|runtime schemas missing/,
+      )
+      expect(readFileSync(catalog, 'utf8')).toBe(before)
+    })
+  },
+)
 
 it('reports a missing runtime instead of retaining a stale snapshot', () => {
   fixture('go', ({ snapshot, invoke }) => {
-    const result = invoke('protocol', [], { LIBTMUX_DOCS_MCP_COMMAND_GO: JSON.stringify(['/does-not-exist/libtmux-mcp']) })
+    const result = invoke('protocol', [], {
+      LIBTMUX_DOCS_MCP_COMMAND_GO: JSON.stringify(['/does-not-exist/libtmux-mcp']),
+    })
     expect(result.status).not.toBe(0)
     expect(result.stderr).toContain('ENOENT')
     expect(existsSync(snapshot)).toBe(false)
   })
 })
 
-it.each(['success', 'build failure', 'capture failure', 'override'])('prebuilds Go outside the protocol deadline: %s', (scenario) => {
-  fixture('go', ({ directory, checkout, snapshot, discovery, env, invoke }) => {
-    const bin = join(directory, 'bin')
-    const buildLog = join(directory, 'build.json')
-    const server = join(directory, 'server.mjs')
-    const executable = join(bin, 'go')
-    mkdirSync(bin)
-    writeFileSync(executable, `#!${process.execPath}
+it.each(['success', 'build failure', 'capture failure', 'override'])(
+  'prebuilds Go outside the protocol deadline: %s',
+  (scenario) => {
+    fixture('go', ({ directory, checkout, snapshot, discovery, env, invoke }) => {
+      const bin = join(directory, 'bin')
+      const buildLog = join(directory, 'build.json')
+      const server = join(directory, 'server.mjs')
+      const executable = join(bin, 'go')
+      mkdirSync(bin)
+      writeFileSync(
+        executable,
+        `#!${process.execPath}
 import { writeFileSync } from 'node:fs'
 const args = process.argv.slice(2)
 writeFileSync(${JSON.stringify(buildLog)}, JSON.stringify({ args, cwd: process.cwd() }))
@@ -253,50 +381,68 @@ if (${JSON.stringify(scenario)} === 'build failure') {
   process.stderr.write('fixture Go compile failed\\n')
   process.exit(42)
 }
-writeFileSync(args[args.indexOf('-o') + 1], ${JSON.stringify(`#!${process.execPath}\n${scenario === 'capture failure'
-      ? "process.stderr.write('fixture compiled server failed\\n'); process.exit(37)"
-      : `await import(${JSON.stringify(pathToFileURL(server).href)})`}`)}, { mode: 0o700 })
-`)
-    chmodSync(executable, 0o700)
-    // Shorten only the copied fixture's deadline: compilation exceeds it,
-    // while the already compiled server still answers in time.
-    const helper = join(directory, 'scripts/lib/mcp-protocol.mjs')
-    writeFileSync(helper, readFileSync(helper, 'utf8').replace('timeoutMs = 30000', 'timeoutMs = 200'))
-    const result = invoke('protocol', [], {
-      LIBTMUX_DOCS_MCP_COMMAND_GO: scenario === 'override' ? env.LIBTMUX_DOCS_MCP_COMMAND_GO : undefined,
-      PATH: `${bin}:${env.PATH}`,
+writeFileSync(args[args.indexOf('-o') + 1], ${JSON.stringify(
+          `#!${process.execPath}\n${
+            scenario === 'capture failure'
+              ? "process.stderr.write('fixture compiled server failed\\n'); process.exit(37)"
+              : `await import(${JSON.stringify(pathToFileURL(server).href)})`
+          }`,
+        )}, { mode: 0o700 })
+`,
+      )
+      chmodSync(executable, 0o700)
+      // Shorten only the copied fixture's deadline: compilation exceeds it,
+      // while the already compiled server still answers in time.
+      const helper = join(directory, 'scripts/lib/mcp-protocol.mjs')
+      writeFileSync(helper, readFileSync(helper, 'utf8').replace('timeoutMs = 30000', 'timeoutMs = 200'))
+      const result = invoke('protocol', [], {
+        LIBTMUX_DOCS_MCP_COMMAND_GO: scenario === 'override' ? env.LIBTMUX_DOCS_MCP_COMMAND_GO : undefined,
+        PATH: `${bin}:${env.PATH}`,
+      })
+      if (scenario === 'override') {
+        expect(result.status, result.stderr).toBe(0)
+        expect(existsSync(buildLog)).toBe(false)
+        return
+      }
+      const build = JSON.parse(readFileSync(buildLog, 'utf8'))
+      expect(build.cwd).toBe(join(checkout, 'mcp'))
+      expect(build.args).toEqual([
+        'build',
+        '-mod=readonly',
+        '-o',
+        expect.stringContaining('libtmux-docs-mcp-go-'),
+        './cmd/libtmux-mcp',
+      ])
+      const binary = build.args[3]
+      expect(binary.startsWith(checkout)).toBe(false)
+      expect(existsSync(dirname(binary))).toBe(false)
+      if (scenario === 'success') {
+        expect(result.status, result.stderr).toBe(0)
+        expect(JSON.parse(readFileSync(snapshot, 'utf8')).protocol.tools).toEqual([tool])
+        expect(JSON.parse(readFileSync(discovery, 'utf8')).tmp).toBe(dirname(binary))
+      } else {
+        expect(result.status).not.toBe(0)
+        expect(result.stderr).toContain(
+          scenario === 'build failure' ? 'fixture Go compile failed' : 'fixture compiled server failed',
+        )
+        expect(existsSync(snapshot)).toBe(false)
+        expect(existsSync(discovery)).toBe(false)
+      }
     })
-    if (scenario === 'override') {
-      expect(result.status, result.stderr).toBe(0)
-      expect(existsSync(buildLog)).toBe(false)
-      return
-    }
-    const build = JSON.parse(readFileSync(buildLog, 'utf8'))
-    expect(build.cwd).toBe(join(checkout, 'mcp'))
-    expect(build.args).toEqual(['build', '-mod=readonly', '-o', expect.stringContaining('libtmux-docs-mcp-go-'), './cmd/libtmux-mcp'])
-    const binary = build.args[3]
-    expect(binary.startsWith(checkout)).toBe(false)
-    expect(existsSync(dirname(binary))).toBe(false)
-    if (scenario === 'success') {
-      expect(result.status, result.stderr).toBe(0)
-      expect(JSON.parse(readFileSync(snapshot, 'utf8')).protocol.tools).toEqual([tool])
-      expect(JSON.parse(readFileSync(discovery, 'utf8')).tmp).toBe(dirname(binary))
-    } else {
-      expect(result.status).not.toBe(0)
-      expect(result.stderr).toContain(scenario === 'build failure' ? 'fixture Go compile failed' : 'fixture compiled server failed')
-      expect(existsSync(snapshot)).toBe(false)
-      expect(existsSync(discovery)).toBe(false)
-    }
-  })
-})
+  },
+)
 
-it.each(['success', 'startup failure', 'capture failure', 'cleanup failure', 'capture and cleanup failure'])('owns Ruby discovery daemon setup and cleanup: %s', (scenario) => {
-  fixture('ruby', ({ directory, checkout, snapshot, env, invoke }) => {
-    const bin = join(directory, 'bin')
-    const daemonLog = join(directory, 'daemon.jsonl')
-    const executable = join(bin, 'tmux')
-    mkdirSync(bin)
-    writeFileSync(executable, `#!${process.execPath}
+it.each(['success', 'startup failure', 'capture failure', 'cleanup failure', 'capture and cleanup failure'])(
+  'owns Ruby discovery daemon setup and cleanup: %s',
+  (scenario) => {
+    fixture('ruby', ({ directory, checkout, snapshot, env, invoke }) => {
+      const bin = join(directory, 'bin')
+      const daemonLog = join(directory, 'daemon.jsonl')
+      const executable = join(bin, 'tmux')
+      mkdirSync(bin)
+      writeFileSync(
+        executable,
+        `#!${process.execPath}
 import { appendFileSync, mkdirSync, writeFileSync } from 'node:fs'
 import { join, dirname } from 'node:path'
 const args = process.argv.slice(2)
@@ -307,39 +453,63 @@ if (args[0] === '-L') {
   writeFileSync(socket, 'owned daemon')
   if (${JSON.stringify(scenario)} === 'startup failure') { process.stderr.write('fixture tmux startup failed\\n'); process.exit(42) }
 } else if (${JSON.stringify(scenario)}.includes('cleanup')) { process.stderr.write('fixture tmux cleanup failed\\n'); process.exit(43) }
-`)
-    chmodSync(executable, 0o700)
-    const server = join(directory, 'borrow-daemon.mjs')
-    writeFileSync(server, `
+`,
+      )
+      chmodSync(executable, 0o700)
+      const server = join(directory, 'borrow-daemon.mjs')
+      writeFileSync(
+        server,
+        `
 import { existsSync } from 'node:fs'
 import { join } from 'node:path'
 if (!existsSync(join(process.env.TMUX_TMPDIR, 'tmux-' + process.getuid(), 'libtmux-docs-protocol'))) throw new Error('discovery requires an existing daemon')
 if (${JSON.stringify(scenario)}.includes('capture')) throw new Error('fixture Ruby capture failed')
 await import(${JSON.stringify(pathToFileURL(join(directory, 'server.mjs')).href)})
-`)
-    const result = invoke('protocol', [], {
-      LIBTMUX_DOCS_MCP_COMMAND_RUBY: JSON.stringify([process.execPath, server]), PATH: `${bin}:${env.PATH}`,
+`,
+      )
+      const result = invoke('protocol', [], {
+        LIBTMUX_DOCS_MCP_COMMAND_RUBY: JSON.stringify([process.execPath, server]),
+        PATH: `${bin}:${env.PATH}`,
+      })
+      const calls = JSON.parse(`[${readFileSync(daemonLog, 'utf8').trim().split('\n').join(',')}]`)
+      expect(calls).toHaveLength(2)
+      expect(calls[0].args).toEqual([
+        '-L',
+        'libtmux-docs-protocol',
+        '-f',
+        '/dev/null',
+        'new-session',
+        '-d',
+        '-s',
+        'docs',
+        '/bin/cat',
+      ])
+      expect(calls[0].tmp).toContain('libtmux-docs-mcp-ruby-')
+      expect(calls[0].tmp.startsWith(checkout)).toBe(false)
+      expect(calls[0].tmux).toBeUndefined()
+      expect(calls[0].pane).toBeUndefined()
+      expect(calls[1].args).toEqual([
+        '-S',
+        join(calls[0].tmp, `tmux-${process.getuid!()}`, 'libtmux-docs-protocol'),
+        'kill-server',
+      ])
+      expect(existsSync(calls[0].tmp)).toBe(false)
+      if (scenario === 'success') {
+        expect(result.status, result.stderr).toBe(0)
+        expect(JSON.parse(readFileSync(snapshot, 'utf8')).protocol.tools).toEqual([tool])
+      } else {
+        expect(result.status).not.toBe(0)
+        expect(result.stderr).toContain(
+          scenario.includes('capture')
+            ? 'fixture Ruby capture failed'
+            : `fixture tmux ${scenario.split(' ')[0]} failed`,
+        )
+        if (scenario.includes('cleanup')) expect(result.stderr).toContain('fixture tmux cleanup failed')
+        expect(existsSync(snapshot)).toBe(false)
+      }
     })
-    const calls = JSON.parse(`[${readFileSync(daemonLog, 'utf8').trim().split('\n').join(',')}]`)
-    expect(calls).toHaveLength(2)
-    expect(calls[0].args).toEqual(['-L', 'libtmux-docs-protocol', '-f', '/dev/null', 'new-session', '-d', '-s', 'docs', '/bin/cat'])
-    expect(calls[0].tmp).toContain('libtmux-docs-mcp-ruby-')
-    expect(calls[0].tmp.startsWith(checkout)).toBe(false)
-    expect(calls[0].tmux).toBeUndefined()
-    expect(calls[0].pane).toBeUndefined()
-    expect(calls[1].args).toEqual(['-S', join(calls[0].tmp, `tmux-${process.getuid!()}`, 'libtmux-docs-protocol'), 'kill-server'])
-    expect(existsSync(calls[0].tmp)).toBe(false)
-    if (scenario === 'success') {
-      expect(result.status, result.stderr).toBe(0)
-      expect(JSON.parse(readFileSync(snapshot, 'utf8')).protocol.tools).toEqual([tool])
-    } else {
-      expect(result.status).not.toBe(0)
-      expect(result.stderr).toContain(scenario.includes('capture') ? 'fixture Ruby capture failed' : `fixture tmux ${scenario.split(' ')[0]} failed`)
-      if (scenario.includes('cleanup')) expect(result.stderr).toContain('fixture tmux cleanup failed')
-      expect(existsSync(snapshot)).toBe(false)
-    }
-  })
-})
+  },
+)
 
 it('fails a source-bound check with a missing checkout', () => {
   fixture('go', ({ invoke }) => {
@@ -382,14 +552,19 @@ it('rejects tracked source edits before discovery or catalog generation', () =>
   })
 })
 
-it('does not inherit another language\'s MCP product for a selected library', () => {
+it("does not inherit another language's MCP product for a selected library", () => {
   fixture('go', ({ directory, catalog, discovery, env }) => {
     const before = readFileSync(catalog, 'utf8')
     for (const port of ['lua', 'kotlin', 'scala', 'fsharp']) {
       for (const script of ['protocol', 'tools']) {
-        const result = spawnSync(process.execPath, [join(directory, `scripts/gen-mcp-${script}.mjs`), '--port', port, '--source-bound'], {
-          encoding: 'utf8', env: { ...env, LIBTMUX_DOCS_PORT: port },
-        })
+        const result = spawnSync(
+          process.execPath,
+          [join(directory, `scripts/gen-mcp-${script}.mjs`), '--port', port, '--source-bound'],
+          {
+            encoding: 'utf8',
+            env: { ...env, LIBTMUX_DOCS_PORT: port },
+          },
+        )
         expect(result.status, result.stderr).toBe(0)
         expect(result.stdout).toBe('')
       }
diff --git a/site/test/mcp-source-links.test.ts b/site/test/mcp-source-links.test.ts
index ae760f601..04017392e 100644
--- a/site/test/mcp-source-links.test.ts
+++ b/site/test/mcp-source-links.test.ts
@@ -10,13 +10,25 @@ it('audits protocol names with the renderer’s resolver in bare Node', () => {
   const directory = mkdtempSync(join(tmpdir(), 'mcp-prose-audit-'))
   const file = join(directory, 'guide.md')
   try {
-    writeFileSync(file, '---\nport: py\nproduct: mcp\n---\nUse `capture_pane`, `mcp:prompt:run_and_wait`, and `mcp:resource-template:tmux://panes/{pane_id}{?socket_name}`.\n')
-    const report = JSON.parse(execFileSync(process.execPath, ['scripts/check-api-links.mjs', file, '--json'], { cwd: root, encoding: 'utf8' }))
+    writeFileSync(
+      file,
+      '---\nport: py\nproduct: mcp\n---\nUse `capture_pane`, `mcp:prompt:run_and_wait`, and `mcp:resource-template:tmux://panes/{pane_id}{?socket_name}`.\n',
+    )
+    const report = JSON.parse(
+      execFileSync(process.execPath, ['scripts/check-api-links.mjs', file, '--json'], { cwd: root, encoding: 'utf8' }),
+    )
     expect(report.tally.willLink).toBe(3)
     expect(report.unresolved).toEqual([])
-    writeFileSync(file, '---\nport: ts\nproduct: mcp\n---\nUse `mcp:resource:tmux://capabilities` and `mcp:prompt:run_and_wait`.\n')
+    writeFileSync(
+      file,
+      '---\nport: ts\nproduct: mcp\n---\nUse `mcp:resource:tmux://capabilities` and `mcp:prompt:run_and_wait`.\n',
+    )
     try {
-      execFileSync(process.execPath, ['scripts/check-api-links.mjs', file, '--json'], { cwd: root, encoding: 'utf8', stdio: 'pipe' })
+      execFileSync(process.execPath, ['scripts/check-api-links.mjs', file, '--json'], {
+        cwd: root,
+        encoding: 'utf8',
+        stdio: 'pipe',
+      })
       expect.fail('The TypeScript server does not advertise the Python prompt')
     } catch (error) {
       const failure = error as { status: number; stdout: string }
@@ -25,5 +37,7 @@ it('audits protocol names with the renderer’s resolver in bare Node', () => {
       expect(report.tally.willLink).toBe(1)
       expect(report.unresolved).toEqual([expect.objectContaining({ text: 'mcp:prompt:run_and_wait' })])
     }
-  } finally { rmSync(directory, { recursive: true, force: true }) }
+  } finally {
+    rmSync(directory, { recursive: true, force: true })
+  }
 })
diff --git a/site/test/merge-version-manifests.test.ts b/site/test/merge-version-manifests.test.ts
index 4ddf5cee6..7aca93e85 100644
--- a/site/test/merge-version-manifests.test.ts
+++ b/site/test/merge-version-manifests.test.ts
@@ -9,21 +9,23 @@ const seed = {
 
 describe('published version manifest merge', () => {
   it('replaces one port only after its publisher wrote a fragment', () => {
-    const result = merge(seed, [{
-      port: 'ruby',
-      manifest: {
-        schema: 1,
-        ports: { ruby: [
-          { slug: 'latest', label: 'latest', kind: 'trunk', supported: true },
-          { slug: 'next', label: 'next', kind: 'alias', resolvesTo: 'v0.1.0.alpha.1', supported: true },
-          { slug: 'v0.1.0.alpha.1', label: 'v0.1.0.alpha.1', kind: 'tag', supported: true },
-        ] },
-        defaultVersion: { ruby: 'latest' },
+    const result = merge(seed, [
+      {
+        port: 'ruby',
+        manifest: {
+          schema: 1,
+          ports: {
+            ruby: [
+              { slug: 'latest', label: 'latest', kind: 'trunk', supported: true },
+              { slug: 'next', label: 'next', kind: 'alias', resolvesTo: 'v0.1.0.alpha.1', supported: true },
+              { slug: 'v0.1.0.alpha.1', label: 'v0.1.0.alpha.1', kind: 'tag', supported: true },
+            ],
+          },
+          defaultVersion: { ruby: 'latest' },
+        },
       },
-    }])
-    expect(result.ports.ruby.map((entry: { slug: string }) => entry.slug)).toEqual([
-      'latest', 'next', 'v0.1.0.alpha.1',
     ])
+    expect(result.ports.ruby.map((entry: { slug: string }) => entry.slug)).toEqual(['latest', 'next', 'v0.1.0.alpha.1'])
     expect(seed.ports.ruby).toHaveLength(1)
   })
 
@@ -43,24 +45,36 @@ describe('published version manifest merge', () => {
   })
 
   it('rejects previews and defaults that do not name published entries', () => {
-    expect(() => merge(seed, [{
-      port: 'ruby',
-      manifest: {
-        schema: 1,
-        ports: { ruby: [{ slug: 'pr-3', label: 'pr-3', kind: 'pr', supported: true }] },
-        defaultVersion: {},
-      },
-    }])).toThrow('preview entry')
-    expect(() => merge(seed, [{
-      port: 'ruby',
-      manifest: { schema: 1, ports: { ruby: [] }, defaultVersion: { ruby: 'stable' } },
-    }])).toThrow('has no published entry')
+    expect(() =>
+      merge(seed, [
+        {
+          port: 'ruby',
+          manifest: {
+            schema: 1,
+            ports: { ruby: [{ slug: 'pr-3', label: 'pr-3', kind: 'pr', supported: true }] },
+            defaultVersion: {},
+          },
+        },
+      ]),
+    ).toThrow('preview entry')
+    expect(() =>
+      merge(seed, [
+        {
+          port: 'ruby',
+          manifest: { schema: 1, ports: { ruby: [] }, defaultVersion: { ruby: 'stable' } },
+        },
+      ]),
+    ).toThrow('has no published entry')
   })
 
   it('rejects a fragment that writes another port', () => {
-    expect(() => merge(seed, [{
-      port: 'ruby',
-      manifest: { schema: 1, ports: { lua: [] }, defaultVersion: {} },
-    }])).toThrow('contains another port')
+    expect(() =>
+      merge(seed, [
+        {
+          port: 'ruby',
+          manifest: { schema: 1, ports: { lua: [] }, defaultVersion: {} },
+        },
+      ]),
+    ).toThrow('contains another port')
   })
 })
diff --git a/site/test/native-shell-context.test.ts b/site/test/native-shell-context.test.ts
index 73c8604ea..4c07ae94b 100644
--- a/site/test/native-shell-context.test.ts
+++ b/site/test/native-shell-context.test.ts
@@ -11,23 +11,42 @@ afterEach(() => directories.splice(0).forEach((directory) => rmSync(directory, {
 function fixture() {
   const directory = mkdtempSync(join(tmpdir(), 'native-context-'))
   directories.push(directory)
-  const checkout = join(directory, 'source'), artifact = join(directory, 'artifact')
+  const checkout = join(directory, 'source'),
+    artifact = join(directory, 'artifact')
   mkdirSync(join(checkout, 'docs/api'), { recursive: true })
   mkdirSync(join(artifact, 'api/libtmux.server'), { recursive: true })
   mkdirSync(join(artifact, 'genindex'), { recursive: true })
   const source = '# Server\n\nNative source.\n'
   writeFileSync(join(checkout, 'docs/api/libtmux.server.md'), source)
-  const git = (...args: string[]) => execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+  const git = (...args: string[]) =>
+    execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
   git('init')
   git('add', '.')
-  git('-c', 'user.name=Test', '-c', 'user.email=test@example.invalid', '-c', 'commit.gpgsign=false', 'commit', '-m', 'Native source fixture')
+  git(
+    '-c',
+    'user.name=Test',
+    '-c',
+    'user.email=test@example.invalid',
+    '-c',
+    'commit.gpgsign=false',
+    'commit',
+    '-m',
+    'Native source fixture',
+  )
   const sourceSha = git('rev-parse', 'HEAD')
-  const article = '<h1>Server</h1><dt class="sig" id="libtmux.Server"><code>Server</code></dt>\n<pre>  exact &amp; bytes\n</pre>'
+  const article =
+    '<h1>Server</h1><dt class="sig" id="libtmux.Server"><code>Server</code></dt>\n<pre>  exact &amp; bytes\n</pre>'
   const html = `<html><head><title>Server</title></head><body><article>${article}</article><footer><div class="page-source"><code>docs/api/libtmux.server.md</code></div></footer></body></html>`
   writeFileSync(join(artifact, 'api/libtmux.server/index.html'), html)
   writeFileSync(join(artifact, 'api/libtmux.server.md'), source)
-  writeFileSync(join(artifact, 'genindex/index.html'), '<html><head></head><body><article>Generated index</article></body></html>')
-  writeFileSync(join(artifact, 'docs.json'), JSON.stringify({ pages: [{ url: '/api/libtmux.server/', markdownUrl: '/api/libtmux.server.md' }] }))
+  writeFileSync(
+    join(artifact, 'genindex/index.html'),
+    '<html><head></head><body><article>Generated index</article></body></html>',
+  )
+  writeFileSync(
+    join(artifact, 'docs.json'),
+    JSON.stringify({ pages: [{ url: '/api/libtmux.server/', markdownUrl: '/api/libtmux.server.md' }] }),
+  )
   const options = { prefix: '/pr-42/en', sphinxPort: 'py', version: 'v0.62.0', checkout, sourceSha }
   return { artifact, checkout, options, article, html, source, sourceSha }
 }
@@ -40,7 +59,12 @@ describe('native shell context', () => {
     expect(server.url).toBe('/pr-42/en/py/v0.62.0/api/api/libtmux.server/')
     expect(server.sourcePath).toBe('py/v0.62.0/api/api/libtmux.server/')
     expect(server.markdownHref).toBe('/pr-42/en/py/v0.62.0/api/api/libtmux.server.md')
-    expect(server.source).toEqual({ repo: 'tmux-python/libtmux', ref: sourceSha, path: 'docs/api/libtmux.server.md', sha256: nativeHash(source) })
+    expect(server.source).toEqual({
+      repo: 'tmux-python/libtmux',
+      ref: sourceSha,
+      path: 'docs/api/libtmux.server.md',
+      sha256: nativeHash(source),
+    })
     expect(server.articleSha256).toBe(nativeHash(article))
     expect(server.signatures).toEqual(['libtmux.Server'])
     expect(server.hasTableOfContents).toBe(false)
@@ -53,7 +77,8 @@ describe('native shell context', () => {
   it('offers contents only for real destinations beyond the page title', async () => {
     const { artifact, options, html } = fixture()
     const page = join(artifact, 'api/libtmux.server/index.html')
-    const writeToc = (links: string) => writeFileSync(page, html.replace('</body>', `<aside><div class="toc-tree">${links}</div></aside></body>`))
+    const writeToc = (links: string) =>
+      writeFileSync(page, html.replace('</body>', `<aside><div class="toc-tree">${links}</div></aside></body>`))
     writeToc('<a href="#">Server</a><a href="#missing">Missing</a><a href="#%zz">Invalid</a>')
     expect((await collectNativeContext(artifact, options)).pages[0].hasTableOfContents).toBe(false)
     writeToc('<a href="#libtmux.Server">Server declaration</a>')
@@ -62,14 +87,19 @@ describe('native shell context', () => {
 
   it('rejects a different revision or uncommitted source instead of citing it as the selected revision', async () => {
     const { artifact, options, checkout } = fixture()
-    await expect(collectNativeContext(artifact, { ...options, sourceSha: '0'.repeat(40) })).rejects.toThrow('revision mismatch')
+    await expect(collectNativeContext(artifact, { ...options, sourceSha: '0'.repeat(40) })).rejects.toThrow(
+      'revision mismatch',
+    )
     writeFileSync(join(checkout, 'docs/api/libtmux.server.md'), 'Changed source')
     await expect(collectNativeContext(artifact, options)).rejects.toThrow('tracked changes')
   })
 
   it('fails when metadata or the exact Markdown target is absent', async () => {
     const { artifact, options, html } = fixture()
-    writeFileSync(join(artifact, 'api/libtmux.server/index.html'), html.replace('<code>docs/api/libtmux.server.md</code>', ''))
+    writeFileSync(
+      join(artifact, 'api/libtmux.server/index.html'),
+      html.replace('<code>docs/api/libtmux.server.md</code>', ''),
+    )
     await expect(collectNativeContext(artifact, options)).rejects.toThrow('no valid source path')
     writeFileSync(join(artifact, 'api/libtmux.server/index.html'), html)
     rmSync(join(artifact, 'api/libtmux.server.md'))
@@ -79,7 +109,10 @@ describe('native shell context', () => {
   it('rejects unknown generated routes and traversing paths in the native export inventory', async () => {
     const { artifact, options } = fixture()
     const metadata = JSON.parse(readFileSync(join(artifact, 'docs.json'), 'utf8'))
-    writeFileSync(join(artifact, 'docs.json'), JSON.stringify({ pages: [{ ...metadata.pages[0], url: '/../outside/' }] }))
+    writeFileSync(
+      join(artifact, 'docs.json'),
+      JSON.stringify({ pages: [{ ...metadata.pages[0], url: '/../outside/' }] }),
+    )
     await expect(collectNativeContext(artifact, options)).rejects.toThrow('not a local absolute path')
     writeFileSync(join(artifact, 'docs.json'), JSON.stringify({ pages: [] }))
     await expect(collectNativeContext(artifact, options)).rejects.toThrow('no docs.json entry')
diff --git a/site/test/native-switchers.test.ts b/site/test/native-switchers.test.ts
index 4c28743f4..c244b8d46 100644
--- a/site/test/native-switchers.test.ts
+++ b/site/test/native-switchers.test.ts
@@ -17,7 +17,9 @@ const pageLinks = {
   symbols: {
     py: {
       'libtmux.Session': [{ port: 'ts', href: `${base}/ts/latest/reference/session-session/`, label: 'Session' }],
-      'libtmux.Session.windows': [{ port: 'ts', href: `${base}/ts/latest/reference/session-session-windows/`, label: 'Session windows' }],
+      'libtmux.Session.windows': [
+        { port: 'ts', href: `${base}/ts/latest/reference/session-session-windows/`, label: 'Session windows' },
+      ],
     },
   },
 }
@@ -31,7 +33,7 @@ async function load(path: string, body = '', head = '') {
   const requests: string[] = []
   window.fetch = (async (url: unknown) => {
     requests.push(String(url))
-    return { ok: true, json: async () => String(url).endsWith('versions.json') ? manifest : pageLinks }
+    return { ok: true, json: async () => (String(url).endsWith('versions.json') ? manifest : pageLinks) }
   }) as unknown as typeof window.fetch
   window.eval(source)
   window.document.dispatchEvent(new window.Event('DOMContentLoaded'))
@@ -56,8 +58,9 @@ describe('native API page switchers', () => {
     expect(window.customElements.get('libtmux-version-switcher')).toBeTruthy()
     expect(header.querySelector('select option')?.getAttribute('value')).toBe('latest')
     expect(header.querySelector('nav[aria-label="Documentation destinations"]')).toBeNull()
-    expect(document.querySelector('[data-lt-shell="footer"] [data-port-home="ts"]')?.getAttribute('href'))
-      .toBe(`${base}/ts/stable/`)
+    expect(document.querySelector('[data-lt-shell="footer"] [data-port-home="ts"]')?.getAttribute('href')).toBe(
+      `${base}/ts/stable/`,
+    )
     expect(header.querySelector('[data-page-port-switcher] a[href$="session-session/"]')).not.toBeNull()
   })
 
@@ -65,22 +68,32 @@ describe('native API page switchers', () => {
     const { document, requests } = await load('api/libtmux.session/')
     expect(document.querySelector('nav[aria-label="Documentation destinations"]')).toBeNull()
     expect(document.querySelectorAll('[data-page-port-switcher]')).toHaveLength(1)
-    expect(document.querySelector('[data-page-port-switcher] a[aria-current]')?.getAttribute('href'))
-      .toBe(`${base}/py/latest/api/libtmux.session/`)
-    expect([...document.querySelectorAll('.lt-shell-search-link')].find((link) => link.textContent === 'Search')?.getAttribute('href'))
-      .toBe(`${base}/py/latest/search/`)
+    expect(document.querySelector('[data-page-port-switcher] a[aria-current]')?.getAttribute('href')).toBe(
+      `${base}/py/latest/api/libtmux.session/`,
+    )
+    expect(
+      [...document.querySelectorAll('.lt-shell-search-link')]
+        .find((link) => link.textContent === 'Search')
+        ?.getAttribute('href'),
+    ).toBe(`${base}/py/latest/search/`)
     expect(requests).toEqual([`${base}/versions.json`, `${base}/page-links.json`])
   })
 
   it('keeps the page equivalents when following an ordinary section heading', async () => {
-    const { window, document } = await load('api/api/libtmux.session/', '<section id="sessions"><dt class="sig" id="libtmux.Session">Session</dt></section>')
+    const { window, document } = await load(
+      'api/api/libtmux.session/',
+      '<section id="sessions"><dt class="sig" id="libtmux.Session">Session</dt></section>',
+    )
     window.location.hash = '#sessions'
     window.dispatchEvent(new window.Event('hashchange'))
     expect(document.querySelector('[data-page-port-switcher] a[href$="session-session/"]')).not.toBeNull()
   })
 
   it('disables counterparts for an unmapped member instead of linking its class', async () => {
-    const { window, document } = await load('api/api/libtmux.session/', '<dt class="sig" id="libtmux.Session">Session</dt><dt class="sig" id="libtmux.Session.unmapped">unmapped</dt>')
+    const { window, document } = await load(
+      'api/api/libtmux.session/',
+      '<dt class="sig" id="libtmux.Session">Session</dt><dt class="sig" id="libtmux.Session.unmapped">unmapped</dt>',
+    )
     window.location.hash = '#libtmux.Session.unmapped'
     window.dispatchEvent(new window.Event('hashchange'))
     const menu = document.querySelector('[data-page-port-switcher]')!
diff --git a/site/test/native-theme.test.ts b/site/test/native-theme.test.ts
index 2ecf690be..601bd8f8a 100644
--- a/site/test/native-theme.test.ts
+++ b/site/test/native-theme.test.ts
@@ -17,15 +17,20 @@ function page(storage: Record<string, string> = {}, system = 'light') {
   for (const [key, value] of Object.entries(storage)) window.localStorage.setItem(key, value)
   const media = window.matchMedia('(prefers-color-scheme: dark)')
   window.matchMedia = () => media
-  window.fetch = (async () => ({ ok: true, json: async () => ({ schema: 1, ports: {}, defaultVersion: {} }) })) as unknown as typeof window.fetch
+  window.fetch = (async () => ({
+    ok: true,
+    json: async () => ({ schema: 1, ports: {}, defaultVersion: {} }),
+  })) as unknown as typeof window.fetch
   return { window, media }
 }
 
 function preferences(window: Window) {
-  return Object.fromEntries(keys.flatMap((key) => {
-    const value = window.localStorage.getItem(key)
-    return value === null ? [] : [[key, value]]
-  }))
+  return Object.fromEntries(
+    keys.flatMap((key) => {
+      const value = window.localStorage.getItem(key)
+      return value === null ? [] : [[key, value]]
+    }),
+  )
 }
 
 async function native(window: Window) {
@@ -47,7 +52,9 @@ describe('theme preference across Astro and native pages', () => {
     const { window } = page({ 'color-scheme': 'dark' }, 'light')
     window.document.documentElement.setAttribute('data-home-scheme-preview', preview)
     astro(window)
-    expect(window.document.documentElement.getAttribute('data-theme-mode')).toBe(preview === 'system' ? 'light' : preview)
+    expect(window.document.documentElement.getAttribute('data-theme-mode')).toBe(
+      preview === 'system' ? 'light' : preview,
+    )
     expect(window.document.documentElement.getAttribute('data-color-scheme')).toBe('dark')
     expect(window.localStorage.getItem('color-scheme')).toBe('dark')
     window.document.documentElement.removeAttribute('data-home-scheme-preview')
@@ -70,8 +77,10 @@ describe('theme preference across Astro and native pages', () => {
   })
 
   it.each([
-    ['dark', 'light', 'dark'], ['light', 'dark', 'light'],
-    ['system', 'dark', 'dark'], ['system', 'light', 'light'],
+    ['dark', 'light', 'dark'],
+    ['light', 'dark', 'light'],
+    ['system', 'dark', 'dark'],
+    ['system', 'light', 'light'],
   ])('carries Astro %s into a native page with a %s OS preference', async (choice, system, resolved) => {
     const first = page({ 'color-scheme': choice, theme: 'light', 'libtmux-theme': 'dark' }, system).window
     astro(first)
@@ -139,7 +148,11 @@ describe('theme preference across Astro and native pages', () => {
 
   it('keeps the native toggle usable when storage is blocked', async () => {
     const { window } = page()
-    Object.defineProperty(window, 'localStorage', { get() { throw new Error('Storage blocked') } })
+    Object.defineProperty(window, 'localStorage', {
+      get() {
+        throw new Error('Storage blocked')
+      },
+    })
     await native(window)
     window.document.body.setAttribute('data-theme', 'dark')
     await window.happyDOM.waitUntilComplete()
diff --git a/site/test/no-orphan-code-blocks.test.ts b/site/test/no-orphan-code-blocks.test.ts
index 068f29792..8d4147a8a 100644
--- a/site/test/no-orphan-code-blocks.test.ts
+++ b/site/test/no-orphan-code-blocks.test.ts
@@ -34,19 +34,36 @@ const SITE = SITE_ROOT
 
 /** Languages that map to a port, mirroring `remark-port-code.mjs`. */
 const PORT_LANGS = new Set([
-  'python', 'py', 'typescript', 'ts', 'javascript', 'js', 'rust', 'rs',
-  'go', 'golang', 'java', 'kotlin', 'csharp', 'cs', 'c#', 'cpp', 'c++',
-  'cxx', 'swift',
+  'python',
+  'py',
+  'typescript',
+  'ts',
+  'javascript',
+  'js',
+  'rust',
+  'rs',
+  'go',
+  'golang',
+  'java',
+  'kotlin',
+  'csharp',
+  'cs',
+  'c#',
+  'cpp',
+  'c++',
+  'cxx',
+  'swift',
 ])
 
-const pages = SITE_BUILT && existsSync(join(SITE, 'topics'))
-  ? execFileSync('fd', ['-t', 'f', 'index.html', join(SITE, 'topics'), join(SITE, 'concepts')], {
-      encoding: 'utf8',
-    })
-      .trim()
-      .split('\n')
-      .filter(Boolean)
-  : []
+const pages =
+  SITE_BUILT && existsSync(join(SITE, 'topics'))
+    ? execFileSync('fd', ['-t', 'f', 'index.html', join(SITE, 'topics'), join(SITE, 'concepts')], {
+        encoding: 'utf8',
+      })
+        .trim()
+        .split('\n')
+        .filter(Boolean)
+    : []
 
 /**
  * The fence's language.
@@ -58,9 +75,7 @@ const pages = SITE_BUILT && existsSync(join(SITE, 'topics'))
 function languageOf(pre: Element): string | undefined {
   const attr = pre.getAttribute('data-language')
   if (attr) return attr.toLowerCase()
-  const cls = [...(pre.querySelector('code')?.classList ?? [])]
-    .map((c) => /^language-(.+)$/.exec(c)?.[1])
-    .find(Boolean)
+  const cls = [...(pre.querySelector('code')?.classList ?? [])].map((c) => /^language-(.+)$/.exec(c)?.[1]).find(Boolean)
   return cls?.toLowerCase()
 }
 
diff --git a/site/test/normalize-native-shell.test.ts b/site/test/normalize-native-shell.test.ts
index fa53489e0..c32a4ad3b 100644
--- a/site/test/normalize-native-shell.test.ts
+++ b/site/test/normalize-native-shell.test.ts
@@ -8,107 +8,153 @@ import { nativeArticle, nativeHash } from '../../scripts/native-shell-context.mj
 import { recordBuild, verifyBuild } from '../../scripts/publication-provenance.mjs'
 
 describe('native shell URL normalization', () => {
-  it.each(['copybutton.js', 'design-tabs.js', 'doctools.js'])('rejects an unrecognized native widget before adapting %s', async (name) => {
-    const directory = mkdtempSync(join(tmpdir(), 'native-widget-'))
-    try {
-      mkdirSync(join(directory, '_static'))
-      writeFileSync(join(directory, '_static', name), 'Changed native widget')
-      const contextFile = join(directory, 'context.json')
-      writeFileSync(contextFile, JSON.stringify({ port: 'py', version: 'latest', root: '/en/', pages: [] }))
-      await expect(normalizeNativeShell(directory, '/en', { sphinxPort: 'py', contextFile })).rejects.toThrow('Native widget changed')
-      expect(readFileSync(join(directory, '_static', name), 'utf8')).toBe('Changed native widget')
-    } finally { rmSync(directory, { recursive: true, force: true }) }
-  })
-
-  it.each(['search.html', 'search/index.html'])('routes native %s to scoped search with the query intact', async (name) => {
-    const directory = mkdtempSync(join(tmpdir(), 'native-search-'))
-    try {
-      mkdirSync(join(directory, 'search'), { recursive: true })
-      const page = join(directory, name)
-      writeFileSync(page, '<html><head><title>Search</title></head><body><script>window.location.replace("/search/")</script></body></html>')
-      await normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py', version: 'v0.62.0' })
-      const html = readFileSync(page, 'utf8')
-      const target = '/pr-42/en/py/v0.62.0/search/'
-      expect(html).toContain(`<meta http-equiv="refresh" content="0; url=${target}">`)
-      expect(html).toContain(`<a href="${target}">Search the Python documentation</a>`)
-      expect(html).not.toContain('data-pagefind-body')
-      let destination = ''
-      runInNewContext(html.match(/<script>(.*?)<\/script>/)![1]!, {
-        window: { location: { search: '?q=Server%20panes', hash: '#results', replace: (href: string) => { destination = href } } },
-      })
-      expect(destination).toBe(`${target}?q=Server%20panes#results`)
-      expect(await normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py', version: 'v0.62.0' })).toBe(0)
-      writeFileSync(join(directory, 'index.html'), '<html><head></head><body>Missing article</body></html>')
-      await expect(normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py' })).rejects.toThrow('no compiled context')
-    } finally {
-      rmSync(directory, { recursive: true, force: true })
-    }
-  })
+  it.each(['copybutton.js', 'design-tabs.js', 'doctools.js'])(
+    'rejects an unrecognized native widget before adapting %s',
+    async (name) => {
+      const directory = mkdtempSync(join(tmpdir(), 'native-widget-'))
+      try {
+        mkdirSync(join(directory, '_static'))
+        writeFileSync(join(directory, '_static', name), 'Changed native widget')
+        const contextFile = join(directory, 'context.json')
+        writeFileSync(contextFile, JSON.stringify({ port: 'py', version: 'latest', root: '/en/', pages: [] }))
+        await expect(normalizeNativeShell(directory, '/en', { sphinxPort: 'py', contextFile })).rejects.toThrow(
+          'Native widget changed',
+        )
+        expect(readFileSync(join(directory, '_static', name), 'utf8')).toBe('Changed native widget')
+      } finally {
+        rmSync(directory, { recursive: true, force: true })
+      }
+    },
+  )
 
-  it.each([false, true])('splices compiled regions and handles legacy tabs references (asset present: %s)', async (tabsPresent) => {
-    const directory = mkdtempSync(join(tmpdir(), 'native-sphinx-'))
-    try {
-      const native = join(directory, 'native')
-      const shell = join(directory, 'shell')
-      mkdirSync(join(native, 'api/pane'), { recursive: true })
-      mkdirSync(join(native, '_static'), { recursive: true })
-      if (tabsPresent) writeFileSync(join(native, '_static/tabs.js'), '/* retained tabs extension */')
-      mkdirSync(join(shell, 'api/api/pane'), { recursive: true })
-      const page = join(native, 'api/pane/index.html')
-      const article = '<h2 id="capture">Pane &amp; capture</h2>\n<pre>  $ printf &quot;ok&quot;\n</pre><a href="#capture">Capture</a>'
-      const tabs = '<script src="../../_static/tabs.js?v=legacy"></script>'
-      const otherScripts = '<script src="../../_static/design-tabs.js"></script><script src="https://other.example/_static/tabs.js"></script><script src="../../_static/missing.js"></script>'
-      const baseline = `<html class="no-js"><head><title>Native title</title><link rel="canonical" href="https://native.example/pane/"><link href="../../_static/theme.css" rel="stylesheet"><link href="../../_static/libtmux-org.css?v=old" rel="stylesheet"><script src="/_shell/shell.js"></script>${tabs}${otherScripts}</head><body><header class="mobile-header">Old</header><article role="main">${article}</article><footer><a href="../session/">Next</a><p>Native attribution</p><div class="page-source"><code>docs/pane.md</code></div></footer></body></html>`
-      writeFileSync(page, baseline)
-      const context = {
-        schema: 1, port: 'py', version: 'v0.62.0', root: '/pr-42/en/', base: '/pr-42/en/py/v0.62.0/api/',
-        pages: [{ file: 'api/pane/index.html', htmlSha256: nativeHash(baseline), articleSha256: nativeHash(article) }],
+  it.each(['search.html', 'search/index.html'])(
+    'routes native %s to scoped search with the query intact',
+    async (name) => {
+      const directory = mkdtempSync(join(tmpdir(), 'native-search-'))
+      try {
+        mkdirSync(join(directory, 'search'), { recursive: true })
+        const page = join(directory, name)
+        writeFileSync(
+          page,
+          '<html><head><title>Search</title></head><body><script>window.location.replace("/search/")</script></body></html>',
+        )
+        await normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py', version: 'v0.62.0' })
+        const html = readFileSync(page, 'utf8')
+        const target = '/pr-42/en/py/v0.62.0/search/'
+        expect(html).toContain(`<meta http-equiv="refresh" content="0; url=${target}">`)
+        expect(html).toContain(`<a href="${target}">Search the Python documentation</a>`)
+        expect(html).not.toContain('data-pagefind-body')
+        let destination = ''
+        runInNewContext(html.match(/<script>(.*?)<\/script>/)![1]!, {
+          window: {
+            location: {
+              search: '?q=Server%20panes',
+              hash: '#results',
+              replace: (href: string) => {
+                destination = href
+              },
+            },
+          },
+        })
+        expect(destination).toBe(`${target}?q=Server%20panes#results`)
+        expect(await normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py', version: 'v0.62.0' })).toBe(0)
+        writeFileSync(join(directory, 'index.html'), '<html><head></head><body>Missing article</body></html>')
+        await expect(normalizeNativeShell(directory, '/pr-42/en', { sphinxPort: 'py' })).rejects.toThrow(
+          'no compiled context',
+        )
+      } finally {
+        rmSync(directory, { recursive: true, force: true })
       }
-      const contextFile = join(directory, 'context.json')
-      writeFileSync(contextFile, JSON.stringify(context))
-      const envelope = `<html data-native-shell-export><head data-native-shell-assets><link rel="stylesheet" href="/pr-42/en/py/v0.62.0/_astro/shell.css"><script type="module" src="/pr-42/en/py/v0.62.0/_astro/shell.js"></script></head><body><template data-native-boundary="header-start"></template><header class="site-header">Shared header</header><template data-native-boundary="header-end"></template><template data-native-boundary="footer-start"></template><footer class="shared-footer">Shared footer</footer><template data-native-boundary="footer-end"></template></body></html>`
-      writeFileSync(join(shell, 'api/api/pane/index.html'), envelope)
-      const options = { sphinxPort: 'py', version: 'v0.62.0', contextFile, shellDirectory: shell }
-      await normalizeNativeShell(native, '/pr-42/en', options)
-      const html = readFileSync(page, 'utf8')
-      expect(nativeArticle(html)).toBe(article)
-      expect(html).toContain('<title>Native title</title><link rel="canonical" href="https://native.example/pane/">')
-      expect(html).toContain('href="/pr-42/en/py/v0.62.0/api/_static/theme.css"')
-      expect(html.includes('src="/pr-42/en/py/v0.62.0/api/_static/tabs.js?v=legacy"')).toBe(tabsPresent)
-      expect(html).toContain('src="/pr-42/en/py/v0.62.0/api/_static/design-tabs.js"')
-      expect(html).toContain('src="https://other.example/_static/tabs.js"')
-      expect(html).toContain('src="/pr-42/en/py/v0.62.0/api/_static/missing.js"')
-      expect(html).toContain('<a href="../session/">Next</a><p>Native attribution</p>')
-      expect(html).toContain('data-pagefind-body data-pagefind-filter="port:Python"')
-      expect(html).toContain('data-theme="python" data-brand="python"')
-      expect(html).toContain('src="/pr-42/en/py/v0.62.0/_astro/shell.js"')
-      expect(html).not.toContain('src="/pr-42/en/_shell/shell.js"')
-      expect(html).not.toMatch(/libtmux-org|mobile-header|data-native-shell-export|data-native-boundary|docs\/pane.md/)
-      expect(html.indexOf('class="site-header"')).toBeLessThan(html.indexOf('<article'))
-      expect(await normalizeNativeShell(native, '/pr-42/en/', options)).toBe(0)
-      expect(readFileSync(page, 'utf8')).toBe(html)
+    },
+  )
 
-      writeFileSync(page, html.replace('Pane &amp; capture', 'Changed article'))
-      await expect(normalizeNativeShell(native, '/pr-42/en', options)).rejects.toThrow('article changed')
-      writeFileSync(page, baseline)
-      writeFileSync(join(shell, 'api/api/pane/index.html'), envelope.replace('footer-end', 'missing'))
-      await expect(normalizeNativeShell(native, '/pr-42/en', options)).rejects.toThrow('one footer region')
-      await expect(normalizeNativeShell(native, '/en', options)).rejects.toThrow('assembly identity')
-    } finally {
-      rmSync(directory, { recursive: true, force: true })
-    }
-  })
+  it.each([false, true])(
+    'splices compiled regions and handles legacy tabs references (asset present: %s)',
+    async (tabsPresent) => {
+      const directory = mkdtempSync(join(tmpdir(), 'native-sphinx-'))
+      try {
+        const native = join(directory, 'native')
+        const shell = join(directory, 'shell')
+        mkdirSync(join(native, 'api/pane'), { recursive: true })
+        mkdirSync(join(native, '_static'), { recursive: true })
+        if (tabsPresent) writeFileSync(join(native, '_static/tabs.js'), '/* retained tabs extension */')
+        mkdirSync(join(shell, 'api/api/pane'), { recursive: true })
+        const page = join(native, 'api/pane/index.html')
+        const article =
+          '<h2 id="capture">Pane &amp; capture</h2>\n<pre>  $ printf &quot;ok&quot;\n</pre><a href="#capture">Capture</a>'
+        const tabs = '<script src="../../_static/tabs.js?v=legacy"></script>'
+        const otherScripts =
+          '<script src="../../_static/design-tabs.js"></script><script src="https://other.example/_static/tabs.js"></script><script src="../../_static/missing.js"></script>'
+        const baseline = `<html class="no-js"><head><title>Native title</title><link rel="canonical" href="https://native.example/pane/"><link href="../../_static/theme.css" rel="stylesheet"><link href="../../_static/libtmux-org.css?v=old" rel="stylesheet"><script src="/_shell/shell.js"></script>${tabs}${otherScripts}</head><body><header class="mobile-header">Old</header><article role="main">${article}</article><footer><a href="../session/">Next</a><p>Native attribution</p><div class="page-source"><code>docs/pane.md</code></div></footer></body></html>`
+        writeFileSync(page, baseline)
+        const context = {
+          schema: 1,
+          port: 'py',
+          version: 'v0.62.0',
+          root: '/pr-42/en/',
+          base: '/pr-42/en/py/v0.62.0/api/',
+          pages: [
+            { file: 'api/pane/index.html', htmlSha256: nativeHash(baseline), articleSha256: nativeHash(article) },
+          ],
+        }
+        const contextFile = join(directory, 'context.json')
+        writeFileSync(contextFile, JSON.stringify(context))
+        const envelope = `<html data-native-shell-export><head data-native-shell-assets><link rel="stylesheet" href="/pr-42/en/py/v0.62.0/_astro/shell.css"><script type="module" src="/pr-42/en/py/v0.62.0/_astro/shell.js"></script></head><body><template data-native-boundary="header-start"></template><header class="site-header">Shared header</header><template data-native-boundary="header-end"></template><template data-native-boundary="footer-start"></template><footer class="shared-footer">Shared footer</footer><template data-native-boundary="footer-end"></template></body></html>`
+        writeFileSync(join(shell, 'api/api/pane/index.html'), envelope)
+        const options = { sphinxPort: 'py', version: 'v0.62.0', contextFile, shellDirectory: shell }
+        await normalizeNativeShell(native, '/pr-42/en', options)
+        const html = readFileSync(page, 'utf8')
+        expect(nativeArticle(html)).toBe(article)
+        expect(html).toContain('<title>Native title</title><link rel="canonical" href="https://native.example/pane/">')
+        expect(html).toContain('href="/pr-42/en/py/v0.62.0/api/_static/theme.css"')
+        expect(html.includes('src="/pr-42/en/py/v0.62.0/api/_static/tabs.js?v=legacy"')).toBe(tabsPresent)
+        expect(html).toContain('src="/pr-42/en/py/v0.62.0/api/_static/design-tabs.js"')
+        expect(html).toContain('src="https://other.example/_static/tabs.js"')
+        expect(html).toContain('src="/pr-42/en/py/v0.62.0/api/_static/missing.js"')
+        expect(html).toContain('<a href="../session/">Next</a><p>Native attribution</p>')
+        expect(html).toContain('data-pagefind-body data-pagefind-filter="port:Python"')
+        expect(html).toContain('data-theme="python" data-brand="python"')
+        expect(html).toContain('src="/pr-42/en/py/v0.62.0/_astro/shell.js"')
+        expect(html).not.toContain('src="/pr-42/en/_shell/shell.js"')
+        expect(html).not.toMatch(
+          /libtmux-org|mobile-header|data-native-shell-export|data-native-boundary|docs\/pane.md/,
+        )
+        expect(html.indexOf('class="site-header"')).toBeLessThan(html.indexOf('<article'))
+        expect(await normalizeNativeShell(native, '/pr-42/en/', options)).toBe(0)
+        expect(readFileSync(page, 'utf8')).toBe(html)
+
+        writeFileSync(page, html.replace('Pane &amp; capture', 'Changed article'))
+        await expect(normalizeNativeShell(native, '/pr-42/en', options)).rejects.toThrow('article changed')
+        writeFileSync(page, baseline)
+        writeFileSync(join(shell, 'api/api/pane/index.html'), envelope.replace('footer-end', 'missing'))
+        await expect(normalizeNativeShell(native, '/pr-42/en', options)).rejects.toThrow('one footer region')
+        await expect(normalizeNativeShell(native, '/en', options)).rejects.toThrow('assembly identity')
+      } finally {
+        rmSync(directory, { recursive: true, force: true })
+      }
+    },
+  )
 
   it('normalizes nested HTML/CSS for previews without changing other URLs', async () => {
     const directory = mkdtempSync(join(tmpdir(), 'native-shell-'))
     try {
       mkdirSync(join(directory, '_static'))
-      writeFileSync(join(directory, 'index.html'), '<script src="/_shell/shell.js"></script><a href="/unchanged/">Guide</a>')
-      writeFileSync(join(directory, '_static/theme.css'), "@import url('https://libtmux.org/_shell/tokens.css'); .logo{background:url(https://other.example/_shell/logo.svg)}")
+      writeFileSync(
+        join(directory, 'index.html'),
+        '<script src="/_shell/shell.js"></script><a href="/unchanged/">Guide</a>',
+      )
+      writeFileSync(
+        join(directory, '_static/theme.css'),
+        "@import url('https://libtmux.org/_shell/tokens.css'); .logo{background:url(https://other.example/_shell/logo.svg)}",
+      )
       await normalizeNativeShell(directory, '/pr-42/en/')
       await normalizeNativeShell(directory, '/pr-42/en')
-      expect(readFileSync(join(directory, 'index.html'), 'utf8')).toBe('<script src="/pr-42/en/_shell/shell.js"></script><a href="/unchanged/">Guide</a>')
-      expect(readFileSync(join(directory, '_static/theme.css'), 'utf8')).toBe("@import url('/pr-42/en/_shell/tokens.css'); .logo{background:url(https://other.example/_shell/logo.svg)}")
+      expect(readFileSync(join(directory, 'index.html'), 'utf8')).toBe(
+        '<script src="/pr-42/en/_shell/shell.js"></script><a href="/unchanged/">Guide</a>',
+      )
+      expect(readFileSync(join(directory, '_static/theme.css'), 'utf8')).toBe(
+        "@import url('/pr-42/en/_shell/tokens.css'); .logo{background:url(https://other.example/_shell/logo.svg)}",
+      )
     } finally {
       rmSync(directory, { recursive: true, force: true })
     }
@@ -123,9 +169,13 @@ it('normalizes native HTML and CSS before hashing and preserves those bytes when
     const css = join(directory, 'dist/theme.css')
     writeFileSync(html, '<script src="/_shell/shell.js"></script>')
     writeFileSync(css, "@import url('https://libtmux.org/_shell/tokens.css');")
-    const sourceSha = 'a'.repeat(40), docsSha = 'b'.repeat(40)
+    const sourceSha = 'a'.repeat(40),
+      docsSha = 'b'.repeat(40)
     recordBuild(join(directory, 'dist'), {
-      schema: 1, port: 'go', version: 'latest', locale: 'en',
+      schema: 1,
+      port: 'go',
+      version: 'latest',
+      locale: 'en',
       docs: { repository: 'libtmux/docs', sha: docsSha, dirty: false },
       sources: [{ product: 'core', repository: 'libtmux/libtmux-go', sha: sourceSha, dirty: false }],
     })
@@ -133,8 +183,14 @@ it('normalizes native HTML and CSS before hashing and preserves those bytes when
     expect(readFileSync(css, 'utf8')).toBe("@import url('/en/_shell/tokens.css');")
     const before = [readFileSync(html, 'utf8'), readFileSync(css, 'utf8')]
     verifyBuild(join(directory, 'dist'), {
-      port: 'go', version: 'latest', locale: 'en', prefix: 'en/go/latest',
-      publisherRepository: 'libtmux/docs', publisherSha: docsSha, repository: 'libtmux/libtmux-go', sourceSha,
+      port: 'go',
+      version: 'latest',
+      locale: 'en',
+      prefix: 'en/go/latest',
+      publisherRepository: 'libtmux/docs',
+      publisherSha: docsSha,
+      repository: 'libtmux/libtmux-go',
+      sourceSha,
     })
     expect([readFileSync(html, 'utf8'), readFileSync(css, 'utf8')]).toEqual(before)
   } finally {
diff --git a/site/test/nuget-install.test.ts b/site/test/nuget-install.test.ts
index b5ae1dc38..82a2a91a6 100644
--- a/site/test/nuget-install.test.ts
+++ b/site/test/nuget-install.test.ts
@@ -15,7 +15,10 @@ import { HOME_PORT_PREVIEW_EVENT } from '../src/lib/home-hover-preview'
 
 const models = { csharp, fsharp }
 const windows: Window[] = []
-afterEach(async () => { vi.unstubAllEnvs(); for (const win of windows.splice(0)) await win.happyDOM.abort() })
+afterEach(async () => {
+  vi.unstubAllEnvs()
+  for (const win of windows.splice(0)) await win.happyDOM.abort()
+})
 const forms = (slug: string, env: Record<string, string> = {}) => {
   const port = PORT_BY_SLUG[slug]
   return installsFor(port, nugetInstallSelection(port, models[slug as keyof typeof models]?.sources, env))
@@ -23,9 +26,21 @@ const forms = (slug: string, env: Record<string, string> = {}) => {
 
 describe('NuGet installation recipes', () => {
   it.each(['csharp', 'fsharp'])('offers each applicable method for %s with its own source version', (slug) => {
-    const port = PORT_BY_SLUG[slug], commands = forms(slug)
-    expect(commands.map((cmd) => cmd.label)).toEqual(['.NET CLI', 'PMC', 'PackageReference', 'CPM', 'Paket CLI', 'Script & Interactive', 'File-Based Apps', 'Cake'])
-    const version = models[slug as keyof typeof models].sources.find((source) => source.package === port.packageName)!.version
+    const port = PORT_BY_SLUG[slug],
+      commands = forms(slug)
+    expect(commands.map((cmd) => cmd.label)).toEqual([
+      '.NET CLI',
+      'PMC',
+      'PackageReference',
+      'CPM',
+      'Paket CLI',
+      'Script & Interactive',
+      'File-Based Apps',
+      'Cake',
+    ])
+    const version = models[slug as keyof typeof models].sources.find(
+      (source) => source.package === port.packageName,
+    )!.version
     expect(commands[2].code).toContain(`Version="${version}"`)
     expect(commands[1].code).toBe(`NuGet\\Install-Package ${port.packageName} -Version ${version}`)
     expect(commands.every((cmd) => cmd.code.includes(port.packageName))).toBe(true)
@@ -35,25 +50,40 @@ describe('NuGet installation recipes', () => {
     expect(commands[5].note).toContain('F# .fsx')
     expect(commands[3].additionalBlocks?.[0].code).toBe(`<PackageReference Include="${port.packageName}" />`)
     expect(commands[3].code).toContain('<ManagePackageVersionsCentrally>true</ManagePackageVersionsCentrally>')
-    expect(commands[0].code).toBe(slug === 'csharp' ? 'dotnet package add LibTmux --prerelease' : `dotnet package add LibTmux.FSharp --version ${version}`)
+    expect(commands[0].code).toBe(
+      slug === 'csharp'
+        ? 'dotnet package add LibTmux --prerelease'
+        : `dotnet package add LibTmux.FSharp --version ${version}`,
+    )
   })
 
-  it.each(['csharp', 'fsharp'])('gives the selected historical %s release priority over the model and registry', (slug) => {
-    const commands = forms(slug, { LIBTMUX_DOCS_PORT: slug, LIBTMUX_DOCS_VERSION: 'v0.0.0-alpha.12' })
-    expect(commands[0].code).toContain('--version 0.0.0-alpha.12')
-    for (const command of commands) expect(command.code).toContain('0.0.0-alpha.12')
-    expect(commands[3].additionalBlocks?.[0].code).not.toContain('Version=')
-    expect(JSON.stringify(commands.map(({ code, additionalBlocks }) => ({ code, additionalBlocks })))).not.toContain('{version}')
-  })
+  it.each(['csharp', 'fsharp'])(
+    'gives the selected historical %s release priority over the model and registry',
+    (slug) => {
+      const commands = forms(slug, { LIBTMUX_DOCS_PORT: slug, LIBTMUX_DOCS_VERSION: 'v0.0.0-alpha.12' })
+      expect(commands[0].code).toContain('--version 0.0.0-alpha.12')
+      for (const command of commands) expect(command.code).toContain('0.0.0-alpha.12')
+      expect(commands[3].additionalBlocks?.[0].code).not.toContain('Version=')
+      expect(JSON.stringify(commands.map(({ code, additionalBlocks }) => ({ code, additionalBlocks })))).not.toContain(
+        '{version}',
+      )
+    },
+  )
 
   it('does not borrow a selected C# release for F# or mistake a maintenance branch for a package version', () => {
-    for (const env of [{ LIBTMUX_DOCS_PORT: 'csharp', LIBTMUX_DOCS_VERSION: 'v0.0.0-alpha.12' }, { LIBTMUX_DOCS_PORT: 'fsharp', LIBTMUX_DOCS_VERSION: 'v0.x' }]) {
+    for (const env of [
+      { LIBTMUX_DOCS_PORT: 'csharp', LIBTMUX_DOCS_VERSION: 'v0.0.0-alpha.12' },
+      { LIBTMUX_DOCS_PORT: 'fsharp', LIBTMUX_DOCS_VERSION: 'v0.x' },
+    ]) {
       expect(forms('fsharp', env)[0].code).toEqual(forms('fsharp')[0].code)
     }
   })
 
   it('fills additional fragments when a recipe needs its version there', () => {
-    const port = { ...PORT_BY_SLUG.fsharp, installs: [{ label: 'CPM', code: 'main', lang: 'xml', additionalBlocks: [{ code: '{version}', lang: 'xml' }] }] }
+    const port = {
+      ...PORT_BY_SLUG.fsharp,
+      installs: [{ label: 'CPM', code: 'main', lang: 'xml', additionalBlocks: [{ code: '{version}', lang: 'xml' }] }],
+    }
     expect(installsFor(port, { version: '1.2.3' })[0].additionalBlocks?.[0].code).toBe('1.2.3')
   })
 })
@@ -61,38 +91,59 @@ describe('NuGet installation recipes', () => {
 const astroRequire = createRequire(realpathSync(new URL('../node_modules/astro/package.json', import.meta.url)))
 const packageFile = new URL('../src/components/widgets/PackageInstall.astro', import.meta.url)
 const copyFile = new URL('../src/components/widgets/InstallCode.astro', import.meta.url)
-const bindings = { registry: { installsFor, nugetInstallSelection }, models: { API_MODELS: models },
-  highlight: { highlightInline, highlightWithCooldownSlots }, ports: { PORTS },
+const bindings = {
+  registry: { installsFor, nugetInstallSelection },
+  models: { API_MODELS: models },
+  highlight: { highlightInline, highlightWithCooldownSlots },
+  ports: { PORTS },
 }
 // The actual source functions stay in the test module; only collection loading and
 // unused example rendering are omitted from this focused component fixture.
 Object.assign(globalThis, { __nugetInstallBindings: bindings })
-const exported = (name: keyof typeof bindings) => `data:text/javascript,export const {${Object.keys(bindings[name]).join(',')}} = globalThis.__nugetInstallBindings.${name}`
-let componentPromise: Promise<Parameters<Awaited<ReturnType<typeof experimental_AstroContainer.create>>['renderToString']>[0]> | undefined
+const exported = (name: keyof typeof bindings) =>
+  `data:text/javascript,export const {${Object.keys(bindings[name]).join(',')}} = globalThis.__nugetInstallBindings.${name}`
+let componentPromise:
+  | Promise<Parameters<Awaited<ReturnType<typeof experimental_AstroContainer.create>>['renderToString']>[0]>
+  | undefined
 async function component() {
-  return componentPromise ??= (async () => {
+  return (componentPromise ??= (async () => {
     const { transform } = await import(astroRequire.resolve('@astrojs/compiler-rs'))
     async function compile(file: URL, imports: Record<string, string>) {
-      const source = readFileSync(file, 'utf8').replace(/<script>[\s\S]*?<\/script>/g, '').replace("import './package-install.css'", '')
-      const result = await transform(source, { filename: file.pathname, internalURL: 'astro/compiler-runtime', resultScopedSlot: true, resolvePath: (specifier: string) => specifier })
+      const source = readFileSync(file, 'utf8')
+        .replace(/<script>[\s\S]*?<\/script>/g, '')
+        .replace("import './package-install.css'", '')
+      const result = await transform(source, {
+        filename: file.pathname,
+        internalURL: 'astro/compiler-runtime',
+        resultScopedSlot: true,
+        resolvePath: (specifier: string) => specifier,
+      })
       expect(result.diagnostics.filter((item: { severity: string }) => item.severity === 'error')).toEqual([])
-      let code = result.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
-      for (const [specifier, url] of Object.entries(imports)) code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(url))
+      let code = result.code.replaceAll(
+        '"astro/compiler-runtime"',
+        JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+      )
+      for (const [specifier, url] of Object.entries(imports))
+        code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(url))
       return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`
     }
     const copy = await compile(copyFile, {})
     const url = await compile(packageFile, {
-      './InstallCode.astro': copy, '../../lib/registry': exported('registry'), '../../lib/api-models': exported('models'), '../../lib/highlight': exported('highlight'),
+      './InstallCode.astro': copy,
+      '../../lib/registry': exported('registry'),
+      '../../lib/api-models': exported('models'),
+      '../../lib/highlight': exported('highlight'),
       '../../lib/ports': `data:text/javascript,export const {PORTS}=globalThis.__nugetInstallBindings.ports;export const portHomeUrl=()=>'',referenceUrl=()=>''`,
       '../../lib/versions': 'data:text/javascript,export const defaultVersionFor=()=>"latest"',
       '../../lib/install-matrix': 'data:text/javascript,export const DEFAULT_COOLDOWN_DAYS=3',
       'astro-expressive-code/components': 'data:text/javascript,export const Code=()=>""',
     })
     return (await import(/* @vite-ignore */ url)).default
-  })()
+  })())
 }
 async function render(slug: string, saved?: string) {
-  const win = new Window({ url: `https://libtmux.org/en/${slug}/latest/` }); windows.push(win)
+  const win = new Window({ url: `https://libtmux.org/en/${slug}/latest/` })
+  windows.push(win)
   if (saved) {
     win.localStorage.setItem(`libtmux-docs.package-install.manager.${slug}`, saved)
     win.document.documentElement.setAttribute(`data-pkg-manager-${slug}`, saved)
@@ -100,29 +151,49 @@ async function render(slug: string, saved?: string) {
   const container = await experimental_AstroContainer.create()
   win.document.body.innerHTML = await container.renderToString(await component(), { props: { ports: [slug] } })
   const style = win.document.createElement('style')
-  style.textContent = readFileSync(new URL('../src/components/widgets/package-install.css', import.meta.url), 'utf8') + pickerPaintRules()
+  style.textContent =
+    readFileSync(new URL('../src/components/widgets/package-install.css', import.meta.url), 'utf8') + pickerPaintRules()
   win.document.head.append(style)
   return win
 }
 function hydrate(win: Window, file: URL) {
-  const script = readFileSync(file, 'utf8').match(/<script>([\s\S]*?)<\/script>/)![1]
-    .replace(/import \{ HOME_PORT_PREVIEW_EVENT \}[^\n]+/, `const HOME_PORT_PREVIEW_EVENT = ${JSON.stringify(HOME_PORT_PREVIEW_EVENT)}`)
-  win.eval(ts.transpileModule(`(() => {${script}})()`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText)
+  const script = readFileSync(file, 'utf8')
+    .match(/<script>([\s\S]*?)<\/script>/)![1]
+    .replace(
+      /import \{ HOME_PORT_PREVIEW_EVENT \}[^\n]+/,
+      `const HOME_PORT_PREVIEW_EVENT = ${JSON.stringify(HOME_PORT_PREVIEW_EVENT)}`,
+    )
+  win.eval(
+    ts.transpileModule(`(() => {${script}})()`, { compilerOptions: { target: ts.ScriptTarget.ES2022 } }).outputText,
+  )
   win.document.dispatchEvent(new win.Event('astro:page-load'))
 }
 
 describe('NuGet widget rendering and copied fragments', () => {
   it.each(['csharp', 'fsharp'])('paints the saved CPM choice and copies each %s fragment separately', async (slug) => {
-    const win = await render(slug, '3'), doc = win.document
+    const win = await render(slug, '3'),
+      doc = win.document
     const panels = [...doc.querySelectorAll('.lm-pkg-install__cmd')]
-    expect(panels.filter((panel) => win.getComputedStyle(panel).display !== 'none').map((panel) => panel.getAttribute('data-manager'))).toEqual(['3'])
-    const cpm = panels[3], blocks = [...cpm.querySelectorAll('[data-install-code]')]
+    expect(
+      panels
+        .filter((panel) => win.getComputedStyle(panel).display !== 'none')
+        .map((panel) => panel.getAttribute('data-manager')),
+    ).toEqual(['3'])
+    const cpm = panels[3],
+      blocks = [...cpm.querySelectorAll('[data-install-code]')]
     expect(blocks).toHaveLength(2)
     expect(cpm.querySelectorAll('code span[style]').length).toBeGreaterThan(5)
     expect(blocks[0].querySelector('button')?.getAttribute('aria-label')).toBe('Copy Directory.Packages.props')
     const copied: string[] = []
-    Object.defineProperty(win.navigator, 'clipboard', { value: { writeText: async (text: string) => { copied.push(text) } } })
-    hydrate(win, packageFile); hydrate(win, copyFile)
+    Object.defineProperty(win.navigator, 'clipboard', {
+      value: {
+        writeText: async (text: string) => {
+          copied.push(text)
+        },
+      },
+    })
+    hydrate(win, packageFile)
+    hydrate(win, copyFile)
     for (const block of blocks) block.querySelector('button')!.click()
     await Promise.resolve()
     expect(copied).toEqual([forms(slug)[3].code, forms(slug)[3].additionalBlocks![0].code])
@@ -130,14 +201,24 @@ describe('NuGet widget rendering and copied fragments', () => {
     const active = doc.querySelector('.lm-pkg-install__manager[aria-selected="true"]')!
     expect(active.getAttribute('data-manager-value')).toBe('3')
     active.dispatchEvent(new win.KeyboardEvent('keydown', { key: 'ArrowRight', bubbles: true }))
-    expect(doc.querySelector('.lm-pkg-install__manager[aria-selected="true"]')?.getAttribute('data-manager-value')).toBe('4')
+    expect(
+      doc.querySelector('.lm-pkg-install__manager[aria-selected="true"]')?.getAttribute('data-manager-value'),
+    ).toBe('4')
     expect(doc.activeElement?.getAttribute('data-manager-value')).toBe('4')
   })
 
   it.each(['csharp', 'fsharp'])('copies every %s method without prompts or sibling fragments', async (slug) => {
-    const win = await render(slug), copied: string[] = []
-    Object.defineProperty(win.navigator, 'clipboard', { value: { writeText: async (text: string) => { copied.push(text) } } })
-    hydrate(win, packageFile); hydrate(win, copyFile)
+    const win = await render(slug),
+      copied: string[] = []
+    Object.defineProperty(win.navigator, 'clipboard', {
+      value: {
+        writeText: async (text: string) => {
+          copied.push(text)
+        },
+      },
+    })
+    hydrate(win, packageFile)
+    hydrate(win, copyFile)
     const commands = forms(slug)
     for (const [index, command] of commands.entries()) {
       win.document.querySelector<HTMLButtonElement>(`.lm-pkg-install__manager[data-manager-value="${index}"]`)!.click()
@@ -151,12 +232,17 @@ describe('NuGet widget rendering and copied fragments', () => {
 
   it('keeps the no-script default visible and highlights C# directives at render time', async () => {
     const win = await render('csharp')
-    expect([...win.document.querySelectorAll('.lm-pkg-install__cmd')].filter((panel) => win.getComputedStyle(panel).display !== 'none')).toHaveLength(1)
+    expect(
+      [...win.document.querySelectorAll('.lm-pkg-install__cmd')].filter(
+        (panel) => win.getComputedStyle(panel).display !== 'none',
+      ),
+    ).toHaveLength(1)
     expect(win.document.querySelector('[data-manager="6"] code span[style]')).not.toBeNull()
   })
 
   it('does not hide Source fallback when storage remembers an unavailable manager', async () => {
-    const originalEntry = REGISTRY.ports.fsharp, originalSources = fsharp.sources
+    const originalEntry = REGISTRY.ports.fsharp,
+      originalSources = fsharp.sources
     try {
       REGISTRY.ports.fsharp = { status: 'unpublished', version: null, stable: null, tag: 'v0.0.0-alpha.18' }
       fsharp.sources = []
@@ -166,6 +252,9 @@ describe('NuGet widget rendering and copied fragments', () => {
       expect(win.getComputedStyle(source).display).toBe('block')
       hydrate(win, packageFile)
       expect(win.getComputedStyle(source).display).toBe('block')
-    } finally { REGISTRY.ports.fsharp = originalEntry; fsharp.sources = originalSources }
+    } finally {
+      REGISTRY.ports.fsharp = originalEntry
+      fsharp.sources = originalSources
+    }
   })
 })
diff --git a/site/test/page-port-links.test.ts b/site/test/page-port-links.test.ts
index 628085bfa..10ffbb4ad 100644
--- a/site/test/page-port-links.test.ts
+++ b/site/test/page-port-links.test.ts
@@ -21,7 +21,10 @@ describe('prose route ownership', () => {
   const lua = { id: '_staged/lua/concepts', data: { port: 'lua', route: 'concepts' } }
 
   it('selects native prose independently of collection order and keeps shared fallbacks', () => {
-    for (const entries of [[shared, ruby, lua], [lua, ruby, shared]]) {
+    for (const entries of [
+      [shared, ruby, lua],
+      [lua, ruby, shared],
+    ]) {
       expect(docsEntriesAvailable(entries, 'ruby')).toEqual([ruby])
       expect(docsEntriesAvailable(entries, 'lua')).toEqual([lua])
       expect(docsEntriesAvailable(entries, 'go')).toEqual([shared])
@@ -32,16 +35,27 @@ describe('prose route ownership', () => {
   it('keeps locale ownership separate and respects unsupported-port exclusions', () => {
     const translation = { id: 'ja/concepts', data: {} }
     const nativeTranslation = { id: 'ja/_staged/ruby/concepts', data: { port: 'ruby', route: 'concepts' } }
-    expect(docsEntriesAvailable([shared, translation, ruby, nativeTranslation], 'ruby')).toEqual([ruby, nativeTranslation])
-    expect(docsEntriesAvailable([shared, { ...ruby, data: { ...ruby.data, supportedPorts: ['lua'] } }], 'ruby')).toEqual([shared])
+    expect(docsEntriesAvailable([shared, translation, ruby, nativeTranslation], 'ruby')).toEqual([
+      ruby,
+      nativeTranslation,
+    ])
+    expect(
+      docsEntriesAvailable([shared, { ...ruby, data: { ...ruby.data, supportedPorts: ['lua'] } }], 'ruby'),
+    ).toEqual([shared])
   })
 
   it('rejects conflicting pages within an owner even when another owner overrides them', () => {
     const duplicate = { id: 'other-concepts', data: { route: 'concepts' } }
-    for (const entries of [[shared, ruby, duplicate], [ruby, shared, duplicate], [duplicate, ruby, shared]]) {
+    for (const entries of [
+      [shared, ruby, duplicate],
+      [ruby, shared, duplicate],
+      [duplicate, ruby, shared],
+    ]) {
       expect(() => docsEntriesAvailable(entries, 'ruby')).toThrow(/Duplicate documentation route concepts/)
     }
-    expect(() => docsEntriesAvailable([ruby, { ...ruby, id: 'other-ruby-concepts' }], 'ruby')).toThrow(/_staged\/ruby\/concepts and other-ruby-concepts/)
+    expect(() => docsEntriesAvailable([ruby, { ...ruby, id: 'other-ruby-concepts' }], 'ruby')).toThrow(
+      /_staged\/ruby\/concepts and other-ruby-concepts/,
+    )
   })
 })
 
@@ -49,15 +63,21 @@ describe('reference picker exits', () => {
   it('keeps missing equivalents distinct from product and language home shortcuts', () => {
     const entries = pagePortLinks({ ...options, pagePath: 'mcp/reference/libtmux-mcp-arguments', portSlug: 'cxx' })
     expect(entries.find((entry) => entry.port === 'rs')).toMatchObject({
-      links: [], home: { href: '/pr-42/en/rs/latest/mcp/', label: 'Go to Rust MCP home' },
+      links: [],
+      home: { href: '/pr-42/en/rs/latest/mcp/', label: 'Go to Rust MCP home' },
     })
     expect(entries.find((entry) => entry.port === 'lua')).toMatchObject({
-      links: [], home: { href: '/pr-42/en/lua/latest/', label: 'Go to Lua home' },
+      links: [],
+      home: { href: '/pr-42/en/lua/latest/', label: 'Go to Lua home' },
     })
     expect(entries.find((entry) => entry.port === 'py')?.home?.href).toBe('/pr-42/en/py/stable/mcp/')
-    expect(entries.find((entry) => entry.port === 'cxx')?.links[0]?.href).toBe('/pr-42/en/cxx/v1.2.3/mcp/reference/libtmux-mcp-arguments/')
+    expect(entries.find((entry) => entry.port === 'cxx')?.links[0]?.href).toBe(
+      '/pr-42/en/cxx/v1.2.3/mcp/reference/libtmux-mcp-arguments/',
+    )
     const workspace = pagePortLinks({ ...options, pagePath: 'workspace/reference/unknown', portSlug: 'powershell' })
-    expect(workspace.find((entry) => entry.port === 'powershell')?.home?.href).toBe('/pr-42/en/powershell/v1.2.3/workspace/')
+    expect(workspace.find((entry) => entry.port === 'powershell')?.home?.href).toBe(
+      '/pr-42/en/powershell/v1.2.3/workspace/',
+    )
     const core = pagePortLinks({ ...options, pagePath: 'reference/unknown', portSlug: 'rs' })
     expect(core.find((entry) => entry.port === 'rs')?.home?.href).toBe('/pr-42/en/rs/v1.2.3/')
   })
@@ -84,24 +104,33 @@ describe('matching pages in another port', () => {
     const { productApiIndex } = await import('../src/lib/product-api')
     const { parameterId } = await import('@libtmux/api-model')
     const examples = [
-      ['julia', 'LibTmux.snapshot', 'Depth'], ['cxx', 'libtmux::Session::windows', 'Session'],
-      ['cxx', 'libtmux::Window::panes', 'Window'], ['cxx', 'libtmux::Server::sessions', 'Server'],
+      ['julia', 'LibTmux.snapshot', 'Depth'],
+      ['cxx', 'libtmux::Session::windows', 'Session'],
+      ['cxx', 'libtmux::Window::panes', 'Window'],
+      ['cxx', 'libtmux::Server::sessions', 'Server'],
     ]
     for (const [port, id, name] of examples) {
-      const entry = referenceAlternatives(port, id).flatMap((group) => group.ports).find((entry) => entry.port === 'powershell')!
+      const entry = referenceAlternatives(port, id)
+        .flatMap((group) => group.ports)
+        .find((entry) => entry.port === 'powershell')!
       const target = API_MODELS.powershell.symbols.find((symbol) => symbol.id === entry.publicId)!
       const spans = productApiIndex(API_MODELS.powershell, 'latest').linkText(entry.note!)
       const link = spans.find((span) => span.kind === 'link' && span.text === `-${name}`)
-      expect(link, `${id}: -${name}`).toMatchObject({ href: entry.href + '#' + encodeURIComponent(parameterId(target, name)), code: true })
+      expect(link, `${id}: -${name}`).toMatchObject({
+        href: entry.href + '#' + encodeURIComponent(parameterId(target, name)),
+        code: true,
+      })
       expect(spans.some((span) => span.kind === 'ref' && span.target === `-${name}`)).toBe(false)
     }
     for (const id of ['LibTmux.windows', 'LibTmux.panes', 'LibTmux.sessions', 'LibTmux.clients']) {
-      const entries = referenceAlternatives('julia', id).flatMap((group) => group.ports).filter((entry) => entry.port === 'julia')
+      const entries = referenceAlternatives('julia', id)
+        .flatMap((group) => group.ports)
+        .filter((entry) => entry.port === 'julia')
       for (const entry of entries) {
         const index = productApiIndex(API_MODELS.julia, 'latest')
         const spans = index.linkText(entry.note!)
         expect(spans.filter((span) => span.kind === 'ref').every((span) => span.link)).toBe(true)
-        const links = spans.flatMap((span) => span.kind === 'ref' && span.link ? [span.link.href] : [])
+        const links = spans.flatMap((span) => (span.kind === 'ref' && span.link ? [span.link.href] : []))
         expect(links.some((href) => /libtmux-(session|window|snapshot)\/$/.test(href))).toBe(false)
       }
     }
@@ -111,28 +140,38 @@ describe('matching pages in another port', () => {
     const manifest = referencePageLinks()
     const server = manifest.symbols.cxx['libtmux::Server']
     expect(server.find((entry) => entry.port === 'powershell')).toMatchObject({
-      kind: 'cmdlet', href: '/pr-42/en/powershell/latest/reference/libtmux-new-tmuxserver/',
+      kind: 'cmdlet',
+      href: '/pr-42/en/powershell/latest/reference/libtmux-new-tmuxserver/',
       note: expect.stringContaining('shared .NET `LibTmux.Server`'),
     })
     expect(server.find((entry) => entry.port === 'fsharp')).toMatchObject({ kind: 'module' })
-    expect(manifest.symbols.julia['LibTmux.SessionRef']).toEqual(expect.arrayContaining([
-      expect.objectContaining({ port: 'cxx', href: '/pr-42/en/cxx/latest/reference/libtmux-session/' }),
-    ]))
+    expect(manifest.symbols.julia['LibTmux.SessionRef']).toEqual(
+      expect.arrayContaining([
+        expect.objectContaining({ port: 'cxx', href: '/pr-42/en/cxx/latest/reference/libtmux-session/' }),
+      ]),
+    )
   })
 
   it('links server types to verified Julia types, PowerShell cmdlets and F# modules in both directions', () => {
     const pages = [
-      ['cxx', 'libtmux-server'], ['julia', 'libtmux-server'],
-      ['powershell', 'libtmux-new-tmuxserver'], ['fsharp', 'libtmux-fsharp-server'],
+      ['cxx', 'libtmux-server'],
+      ['julia', 'libtmux-server'],
+      ['powershell', 'libtmux-new-tmuxserver'],
+      ['fsharp', 'libtmux-fsharp-server'],
     ]
     for (const [portSlug, slug] of pages) {
       const entries = pagePortLinks({ ...options, portSlug, pagePath: `reference/${slug}` })
       for (const [port, target] of pages) {
-        const version = port === portSlug ? options.version : options.defaults[port as keyof typeof options.defaults] ?? 'latest'
-        expect(entries.find((entry) => entry.port === port)?.links[0].href).toBe(`/pr-42/en/${port}/${version}/reference/${target}/`)
+        const version =
+          port === portSlug ? options.version : (options.defaults[port as keyof typeof options.defaults] ?? 'latest')
+        expect(entries.find((entry) => entry.port === port)?.links[0].href).toBe(
+          `/pr-42/en/${port}/${version}/reference/${target}/`,
+        )
       }
-      if (portSlug !== 'powershell') expect(entries.find((entry) => entry.port === 'powershell')?.links[0].label).toBe('New-TmuxServer (cmdlet)')
-      if (portSlug !== 'fsharp') expect(entries.find((entry) => entry.port === 'fsharp')?.links[0].label).toBe('Server (module)')
+      if (portSlug !== 'powershell')
+        expect(entries.find((entry) => entry.port === 'powershell')?.links[0].label).toBe('New-TmuxServer (cmdlet)')
+      if (portSlug !== 'fsharp')
+        expect(entries.find((entry) => entry.port === 'fsharp')?.links[0].label).toBe('Server (module)')
     }
   })
 
@@ -144,11 +183,14 @@ describe('matching pages in another port', () => {
       expect(links[0], port).not.toHaveProperty('label')
     }
     expect(entries.find((entry) => entry.port === 'julia')?.links[0]).toMatchObject({
-      href: '/pr-42/en/julia/latest/reference/libtmux-sessions/', label: 'sessions (function)',
+      href: '/pr-42/en/julia/latest/reference/libtmux-sessions/',
+      label: 'sessions (function)',
     })
     expect(entries.find((entry) => entry.port === 'powershell')?.links[0].label).toContain('(cmdlet)')
     expect(entries.find((entry) => entry.port === 'fsharp')?.links[0].label).toBeTruthy()
-    expect(entries.every((entry) => entry.links.every((link) => link.label !== 'List the server’s sessions'))).toBe(true)
+    expect(entries.every((entry) => entry.links.every((link) => link.label !== 'List the server’s sessions'))).toBe(
+      true,
+    )
   })
 
   it('finds library counterparts from the tmux prose namespace', () => {
@@ -158,10 +200,18 @@ describe('matching pages in another port', () => {
   })
   it('uses native equivalents when a shared article does not cover a port', () => {
     const shared = { id: 'topics/pane-interaction', data: { supportedPorts: ['go', 'py'] } }
-    const native = { id: '_staged/lua/guides/panes', data: { port: 'lua', route: 'guides/panes', aliases: ['topics/pane-interaction'] } }
+    const native = {
+      id: '_staged/lua/guides/panes',
+      data: { port: 'lua', route: 'guides/panes', aliases: ['topics/pane-interaction'] },
+    }
     expect(docsEntryAvailable(shared, 'lua')).toBe(false)
     expect(docsEntryAvailable(shared, 'go')).toBe(true)
-    const links = pagePortLinks({ ...options, docs: [shared, native], pagePath: 'topics/pane-interaction', portSlug: 'go' })
+    const links = pagePortLinks({
+      ...options,
+      docs: [shared, native],
+      pagePath: 'topics/pane-interaction',
+      portSlug: 'go',
+    })
     expect(links.find((p) => p.port === 'lua')?.links[0].href).toBe('/pr-42/en/lua/latest/guides/panes/')
     expect(links.find((p) => p.port === 'ruby')?.links).toEqual([])
     const reverse = pagePortLinks({ ...options, docs: [shared, native], pagePath: 'guides/panes', portSlug: 'lua' })
@@ -176,7 +226,8 @@ describe('matching pages in another port', () => {
 
   it('matches verified setup tasks across native and authored routes in both directions', () => {
     const page = (port: string, route: string, title: string, equivalence = 'mcp-client-setup', product = 'mcp') => ({
-      id: `ports/${port}/${route}`, data: { port, route, title, product, equivalence, sidebar: { group: 'Guides' } },
+      id: `ports/${port}/${route}`,
+      data: { port, route, title, product, equivalence, sidebar: { group: 'Guides' } },
     })
     const entries = [
       page('julia', 'mcp/source-guide', 'MCP server guide'),
@@ -193,19 +244,32 @@ describe('matching pages in another port', () => {
     ]
     for (const docs of [entries, [...entries].reverse()]) {
       const links = pagePortLinks({ ...options, docs, pagePath: 'mcp/source-guide', portSlug: 'julia' })
-      expect(links.find((p) => p.port === 'julia')?.links).toEqual([{ href: '/pr-42/en/julia/v1.2.3/mcp/source-guide/' }])
-      expect(links.find((p) => p.port === 'go')?.links).toEqual([{ href: '/pr-42/en/go/latest/mcp/guides/connect-client/' }])
+      expect(links.find((p) => p.port === 'julia')?.links).toEqual([
+        { href: '/pr-42/en/julia/v1.2.3/mcp/source-guide/' },
+      ])
+      expect(links.find((p) => p.port === 'go')?.links).toEqual([
+        { href: '/pr-42/en/go/latest/mcp/guides/connect-client/' },
+      ])
       expect(links.find((p) => p.port === 'py')?.links).toEqual([{ href: '/pr-42/en/py/stable/mcp/guides/' }])
       expect(links.find((p) => p.port === 'ruby')?.links).toEqual([
         { href: '/pr-42/en/ruby/latest/mcp/guides/connect-client/', label: 'Connect a client' },
         { href: '/pr-42/en/ruby/latest/mcp/source-guide/', label: 'MCP server guide' },
       ])
-      expect(links.find((p) => p.port === 'ts')?.links).toEqual([{ href: '/pr-42/en/ts/latest/mcp/guides/', label: 'Guides overview', fallback: 'section' }])
+      expect(links.find((p) => p.port === 'ts')?.links).toEqual([
+        { href: '/pr-42/en/ts/latest/mcp/guides/', label: 'Guides overview', fallback: 'section' },
+      ])
       for (const port of ['java', 'lua', 'powershell']) expect(links.find((p) => p.port === port)?.links).toEqual([])
-      for (const [portSlug, pagePath] of [['ruby', 'mcp/guides/connect-client'], ['py', 'mcp/guides']]) {
+      for (const [portSlug, pagePath] of [
+        ['ruby', 'mcp/guides/connect-client'],
+        ['py', 'mcp/guides'],
+      ]) {
         const reverse = pagePortLinks({ ...options, docs, pagePath, portSlug })
-        expect(reverse.find((p) => p.port === 'julia')?.links).toEqual([{ href: '/pr-42/en/julia/latest/mcp/source-guide/' }])
-        expect(reverse.find((p) => p.port === portSlug)?.links).toEqual([{ href: `/pr-42/en/${portSlug}/v1.2.3/${pagePath}/` }])
+        expect(reverse.find((p) => p.port === 'julia')?.links).toEqual([
+          { href: '/pr-42/en/julia/latest/mcp/source-guide/' },
+        ])
+        expect(reverse.find((p) => p.port === portSlug)?.links).toEqual([
+          { href: `/pr-42/en/${portSlug}/v1.2.3/${pagePath}/` },
+        ])
       }
     }
   })
@@ -217,7 +281,9 @@ describe('matching pages in another port', () => {
       { id: 'ports/rs/workspace/guides', data: { port: 'rs', product: 'workspace' } },
     ]
     const links = pagePortLinks({ ...options, docs, pagePath: 'workspace/internals/guides/special', portSlug: 'ts' })
-    expect(links.find((p) => p.port === 'go')?.links).toEqual([{ href: '/pr-42/en/go/latest/workspace/internals/guides/', label: 'Guides overview', fallback: 'section' }])
+    expect(links.find((p) => p.port === 'go')?.links).toEqual([
+      { href: '/pr-42/en/go/latest/workspace/internals/guides/', label: 'Guides overview', fallback: 'section' },
+    ])
     expect(links.find((p) => p.port === 'rs')?.links).toEqual([])
   })
   it('preserves the prose page and chooses the target port default', () => {
@@ -233,17 +299,31 @@ describe('matching pages in another port', () => {
       { id: 'ports/csharp/examples', data: { port: 'csharp', route: 'examples' } },
       { id: 'ports/fsharp/examples', data: { port: 'fsharp', route: 'examples' } },
     ]
-    const links = pagePortLinks({ ...options, docs: entries, pagePath: 'examples/create-layout', portSlug: 'powershell' })
-    expect(links.find((entry) => entry.port === 'powershell')?.links).toEqual([{ href: '/pr-42/en/powershell/v1.2.3/examples/create-layout/' }])
-    expect(links.find((entry) => entry.port === 'julia')?.links).toEqual([{ href: '/pr-42/en/julia/latest/examples/create-layout/' }])
-    for (const port of ['csharp', 'fsharp']) expect(links.find((entry) => entry.port === port)?.links).toEqual([
-      { href: `/pr-42/en/${port}/latest/examples/`, label: 'Examples overview', fallback: 'section' },
+    const links = pagePortLinks({
+      ...options,
+      docs: entries,
+      pagePath: 'examples/create-layout',
+      portSlug: 'powershell',
+    })
+    expect(links.find((entry) => entry.port === 'powershell')?.links).toEqual([
+      { href: '/pr-42/en/powershell/v1.2.3/examples/create-layout/' },
+    ])
+    expect(links.find((entry) => entry.port === 'julia')?.links).toEqual([
+      { href: '/pr-42/en/julia/latest/examples/create-layout/' },
     ])
+    for (const port of ['csharp', 'fsharp'])
+      expect(links.find((entry) => entry.port === port)?.links).toEqual([
+        { href: `/pr-42/en/${port}/latest/examples/`, label: 'Examples overview', fallback: 'section' },
+      ])
     expect(links.find((entry) => entry.port === 'java')?.links).toEqual([])
   })
 
   it('disables pages excluded by their port and unknown root-only routes', () => {
-    expect(pagePortLinks({ ...options, pagePath: 'guides/python-only' }).filter((p) => p.links.length).map((p) => p.port)).toEqual(['py'])
+    expect(
+      pagePortLinks({ ...options, pagePath: 'guides/python-only' })
+        .filter((p) => p.links.length)
+        .map((p) => p.port),
+    ).toEqual(['py'])
     expect(pagePortLinks({ ...options, pagePath: 'missing-page' }).every((p) => !p.links.length)).toBe(true)
   })
 
@@ -255,49 +335,98 @@ describe('matching pages in another port', () => {
   it('switches MCP tools using each port’s registered wire name', () => {
     const links = pagePortLinks({ ...options, pagePath: 'mcp/tools/capture_pane', portSlug: 'ts' })
     expect(links.find((entry) => entry.port === 'lua')?.links).toEqual([])
-    expect(links.filter((entry) => entry.links.some((link) => !link.label)).map((entry) => entry.port).sort())
-      .toEqual(['py', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'julia'].sort())
-    expect(links.find((entry) => entry.port === 'ruby')?.links).toEqual([{ href: '/pr-42/en/ruby/latest/mcp/tools/', label: 'Tools overview', fallback: 'section' }])
-    expect(links.find((entry) => entry.port === 'ts')?.links[0].href).toBe('/pr-42/en/ts/v1.2.3/mcp/tools/capture_pane/')
-    expect(links.find((entry) => entry.port === 'py')?.links[0].href).toBe('/pr-42/en/py/stable/mcp/tools/capture_pane/')
-    expect(links.find((entry) => entry.port === 'csharp')?.links[0].href).toBe('/pr-42/en/csharp/latest/mcp/tools/capture_pane/')
-    expect(links.find((entry) => entry.port === 'julia')?.links[0].href).toBe('/pr-42/en/julia/latest/mcp/tools/capture_pane/')
+    expect(
+      links
+        .filter((entry) => entry.links.some((link) => !link.label))
+        .map((entry) => entry.port)
+        .sort(),
+    ).toEqual(['py', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'julia'].sort())
+    expect(links.find((entry) => entry.port === 'ruby')?.links).toEqual([
+      { href: '/pr-42/en/ruby/latest/mcp/tools/', label: 'Tools overview', fallback: 'section' },
+    ])
+    expect(links.find((entry) => entry.port === 'ts')?.links[0].href).toBe(
+      '/pr-42/en/ts/v1.2.3/mcp/tools/capture_pane/',
+    )
+    expect(links.find((entry) => entry.port === 'py')?.links[0].href).toBe(
+      '/pr-42/en/py/stable/mcp/tools/capture_pane/',
+    )
+    expect(links.find((entry) => entry.port === 'csharp')?.links[0].href).toBe(
+      '/pr-42/en/csharp/latest/mcp/tools/capture_pane/',
+    )
+    expect(links.find((entry) => entry.port === 'julia')?.links[0].href).toBe(
+      '/pr-42/en/julia/latest/mcp/tools/capture_pane/',
+    )
     const reverse = pagePortLinks({ ...options, pagePath: 'mcp/tools/capture_pane', portSlug: 'csharp' })
-    expect(reverse.find((entry) => entry.port === 'ts')?.links[0].href).toBe('/pr-42/en/ts/latest/mcp/tools/capture_pane/')
+    expect(reverse.find((entry) => entry.port === 'ts')?.links[0].href).toBe(
+      '/pr-42/en/ts/latest/mcp/tools/capture_pane/',
+    )
   })
 
   it('links the current snapshot tool across ports and rejects unknown tools', () => {
     const links = pagePortLinks({ ...options, pagePath: 'mcp/tools/snapshot_pane', portSlug: 'ts' })
-    expect(links.find((entry) => entry.port === 'py')?.links[0]?.href).toBe('/pr-42/en/py/stable/mcp/tools/snapshot_pane/')
-    expect(links.find((entry) => entry.port === 'cxx')?.links[0]?.href).toBe('/pr-42/en/cxx/latest/mcp/tools/snapshot_pane/')
-    expect(links.find((entry) => entry.port === 'swift')?.links[0]?.href).toBe('/pr-42/en/swift/latest/mcp/tools/snapshot_pane/')
-    expect(pagePortLinks({ ...options, pagePath: 'mcp/tools/missing', portSlug: 'ts' }).every((entry) => !entry.links.length)).toBe(true)
+    expect(links.find((entry) => entry.port === 'py')?.links[0]?.href).toBe(
+      '/pr-42/en/py/stable/mcp/tools/snapshot_pane/',
+    )
+    expect(links.find((entry) => entry.port === 'cxx')?.links[0]?.href).toBe(
+      '/pr-42/en/cxx/latest/mcp/tools/snapshot_pane/',
+    )
+    expect(links.find((entry) => entry.port === 'swift')?.links[0]?.href).toBe(
+      '/pr-42/en/swift/latest/mcp/tools/snapshot_pane/',
+    )
+    expect(
+      pagePortLinks({ ...options, pagePath: 'mcp/tools/missing', portSlug: 'ts' }).every(
+        (entry) => !entry.links.length,
+      ),
+    ).toBe(true)
   })
 
   it('rejects retired raw tmux commands and links current pane shell commands', () => {
     const swift = pagePortLinks({ ...options, pagePath: 'mcp/tools/run_command', portSlug: 'swift' })
     expect(swift.filter((entry) => entry.links.length).map((entry) => entry.port)).toEqual([])
     const python = pagePortLinks({ ...options, pagePath: 'mcp/tools/run_command', portSlug: 'py' })
-    expect(python.find((entry) => entry.port === 'swift')?.links[0]?.href).toBe('/pr-42/en/swift/latest/mcp/tools/run_shell_command/')
-    expect(python.find((entry) => entry.port === 'go')?.links[0]?.href).toBe('/pr-42/en/go/latest/mcp/tools/run_shell_command/')
+    expect(python.find((entry) => entry.port === 'swift')?.links[0]?.href).toBe(
+      '/pr-42/en/swift/latest/mcp/tools/run_shell_command/',
+    )
+    expect(python.find((entry) => entry.port === 'go')?.links[0]?.href).toBe(
+      '/pr-42/en/go/latest/mcp/tools/run_shell_command/',
+    )
   })
 
   it('keeps scrollback-only clearing separate from clearing the visible screen', () => {
     const rust = pagePortLinks({ ...options, pagePath: 'mcp/tools/clear_pane_scrollback', portSlug: 'rs' })
-    expect(rust.filter((entry) => entry.links.some((link) => !link.label)).map((entry) => entry.port)).toEqual(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])
-    expect(rust.find((entry) => entry.port === 'py')?.links).toEqual([{ href: '/pr-42/en/py/stable/mcp/tools/', label: 'Tools overview', fallback: 'section' }])
-    const python = pagePortLinks({ ...options, pagePath: 'mcp/tools/clear_pane', portSlug: 'py' })
-    for (const port of ['rs', 'csharp']) expect(python.find((entry) => entry.port === port)?.links).toEqual([
-      { href: `/pr-42/en/${port}/latest/mcp/tools/`, label: 'Tools overview', fallback: 'section' },
+    expect(rust.filter((entry) => entry.links.some((link) => !link.label)).map((entry) => entry.port)).toEqual([
+      'ts',
+      'rs',
+      'go',
+      'java',
+      'csharp',
+      'cxx',
+      'swift',
+    ])
+    expect(rust.find((entry) => entry.port === 'py')?.links).toEqual([
+      { href: '/pr-42/en/py/stable/mcp/tools/', label: 'Tools overview', fallback: 'section' },
     ])
+    const python = pagePortLinks({ ...options, pagePath: 'mcp/tools/clear_pane', portSlug: 'py' })
+    for (const port of ['rs', 'csharp'])
+      expect(python.find((entry) => entry.port === port)?.links).toEqual([
+        { href: `/pr-42/en/${port}/latest/mcp/tools/`, label: 'Tools overview', fallback: 'section' },
+      ])
   })
 
   it('switches fixed resources by URI despite different display names', () => {
     const links = pagePortLinks({ ...options, pagePath: 'mcp/resources/capabilities', portSlug: 'ts' })
-    expect(links.find((entry) => entry.port === 'go')?.links).toEqual([{ href: '/pr-42/en/go/latest/mcp/resources/tmux-capabilities/' }])
-    expect(links.find((entry) => entry.port === 'csharp')?.links).toEqual([{ href: '/pr-42/en/csharp/latest/mcp/resources/tmux_capabilities/' }])
-    expect(links.find((entry) => entry.port === 'py')?.links).toEqual([{ href: '/pr-42/en/py/stable/mcp/resources/', label: 'Resources overview', fallback: 'section' }])
-    expect(links.find((entry) => entry.port === 'julia')?.links).toEqual([{ href: '/pr-42/en/julia/latest/mcp/resources/', label: 'Resources overview', fallback: 'section' }])
+    expect(links.find((entry) => entry.port === 'go')?.links).toEqual([
+      { href: '/pr-42/en/go/latest/mcp/resources/tmux-capabilities/' },
+    ])
+    expect(links.find((entry) => entry.port === 'csharp')?.links).toEqual([
+      { href: '/pr-42/en/csharp/latest/mcp/resources/tmux_capabilities/' },
+    ])
+    expect(links.find((entry) => entry.port === 'py')?.links).toEqual([
+      { href: '/pr-42/en/py/stable/mcp/resources/', label: 'Resources overview', fallback: 'section' },
+    ])
+    expect(links.find((entry) => entry.port === 'julia')?.links).toEqual([
+      { href: '/pr-42/en/julia/latest/mcp/resources/', label: 'Resources overview', fallback: 'section' },
+    ])
   })
 
   it.each([
@@ -306,25 +435,38 @@ describe('matching pages in another port', () => {
   ])('offers an explicitly labelled section when %s has no counterpart', (pagePath, section) => {
     const links = pagePortLinks({ ...options, pagePath, portSlug: 'py' })
     expect(links.find((entry) => entry.port === 'py')?.links).toEqual([{ href: `/pr-42/en/py/v1.2.3/${pagePath}/` }])
-    expect(links.find((entry) => entry.port === 'ts')?.links).toEqual([{ href: `/pr-42/en/ts/latest/mcp/${section.toLowerCase()}/`, label: `${section} overview`, fallback: 'section' }])
+    expect(links.find((entry) => entry.port === 'ts')?.links).toEqual([
+      { href: `/pr-42/en/ts/latest/mcp/${section.toLowerCase()}/`, label: `${section} overview`, fallback: 'section' },
+    ])
     expect(links.find((entry) => entry.port === 'powershell')?.links).toEqual([])
   })
 
   it('offers reference indexes rather than transplanting the current reference path', () => {
-    expect(pagePortLinks({ ...options, pagePath: 'reference', portSlug: 'ts' }).find((p) => p.port === 'py')?.links[0].href).toBe('/pr-42/en/py/stable/reference/')
+    expect(
+      pagePortLinks({ ...options, pagePath: 'reference', portSlug: 'ts' }).find((p) => p.port === 'py')?.links[0].href,
+    ).toBe('/pr-42/en/py/stable/reference/')
   })
 
   it('links session pane equivalents and disables Java without a direct accessor', () => {
     const links = pagePortLinks({ ...options, pagePath: 'reference/session-session-panes', portSlug: 'ts' })
-    expect(links.find((p) => p.port === 'py')?.links[0].href).toBe('/pr-42/en/py/stable/reference/libtmux-session-panes/')
+    expect(links.find((p) => p.port === 'py')?.links[0].href).toBe(
+      '/pr-42/en/py/stable/reference/libtmux-session-panes/',
+    )
     // The page's own port keeps the version being built, not the default.
-    expect(links.find((p) => p.port === 'ts')?.links[0].href).toBe('/pr-42/en/ts/v1.2.3/reference/session-session-panes/')
+    expect(links.find((p) => p.port === 'ts')?.links[0].href).toBe(
+      '/pr-42/en/ts/v1.2.3/reference/session-session-panes/',
+    )
     expect(links.find((p) => p.port === 'java')?.links).toEqual([])
   })
 
   it('keeps both scopes when a Swift page documents session and window overloads', () => {
     const links = pagePortLinks({ ...options, pagePath: 'reference/snapshot-panes(of-)', portSlug: 'swift' })
-    expect(links.find((p) => p.port === 'py')?.links.map((link) => link.href).sort()).toEqual([
+    expect(
+      links
+        .find((p) => p.port === 'py')
+        ?.links.map((link) => link.href)
+        .sort(),
+    ).toEqual([
       '/pr-42/en/py/stable/reference/libtmux-session-panes/',
       '/pr-42/en/py/stable/reference/libtmux-window-panes/',
     ])
@@ -347,20 +489,29 @@ describe('locale switcher targets', () => {
   })
 })
 
-
 describe('workspace documentation compatibility', () => {
   it.each(['cli/load', 'configuration/commands', 'reference/compatibility', 'guides/automation', 'examples/gallery'])(
-    'switches the nested %s reference across authored ports', (section) => {
+    'switches the nested %s reference across authored ports',
+    (section) => {
       const pagePath = `workspace/${section}`
       const entries = PORTS.filter((port) => !port.parentLibrary).map((port) => ({
-        id: `ports/${port.slug}/${pagePath}`, data: { port: port.slug, product: 'workspace' },
+        id: `ports/${port.slug}/${pagePath}`,
+        data: { port: port.slug, product: 'workspace' },
       }))
       const links = pagePortLinks({ ...options, docs: entries, pagePath, portSlug: 'go' })
       for (const entry of links) {
         const version = entry.port === 'go' ? 'v1.2.3' : entry.port === 'py' ? 'stable' : 'latest'
-        expect(entry.links).toEqual(productAvailable(PORT_BY_SLUG[entry.port], 'workspace') ? [{ href: `/pr-42/en/${entry.port}/${version}/${pagePath}/` }] : [])
+        expect(entry.links).toEqual(
+          productAvailable(PORT_BY_SLUG[entry.port], 'workspace')
+            ? [{ href: `/pr-42/en/${entry.port}/${version}/${pagePath}/` }]
+            : [],
+        )
       }
-      const missing = pagePortLinks({ ...options, pagePath, docs: entries.filter((entry) => entry.data.port !== 'cxx') })
+      const missing = pagePortLinks({
+        ...options,
+        pagePath,
+        docs: entries.filter((entry) => entry.data.port !== 'cxx'),
+      })
       expect(missing.find((entry) => entry.port === 'cxx')?.links).toEqual([])
     },
   )
@@ -369,26 +520,33 @@ describe('workspace documentation compatibility', () => {
     const entries = [...docs, { id: 'ports/py/workspace/guides', data: { port: 'py', product: 'workspace' } }]
     const cli = pagePortLinks({ ...options, docs: entries, pagePath: 'workspace/guides', portSlug: 'py' })
     expect(cli.filter((entry) => entry.links.length).map((entry) => entry.port)).toEqual(['py'])
-    const internals = pagePortLinks({ ...options, docs: entries, pagePath: 'workspace/internals/guides', portSlug: 'ts' })
+    const internals = pagePortLinks({
+      ...options,
+      docs: entries,
+      pagePath: 'workspace/internals/guides',
+      portSlug: 'ts',
+    })
     expect(internals.filter((entry) => entry.links.length).map((entry) => entry.port)).toEqual(['ts', 'rs'])
   })
 
   it('lifts a port without a workspace CLI out of Internals, and leaves Python alone', async () => {
     const { workspaceRedirects } = await import('../src/lib/docs-paths')
-    expect(workspaceRedirects([
-      'py/stable/workspace/examples', 'py/stable/workspace/internals/examples',
-      'go/latest/workspace/internals/examples', 'go/latest/workspace/reference/builder',
-      'go/latest/workspace/internals', 'go/latest/guides',
-    ])).toEqual([
-      { path: 'go/latest/workspace/examples', target: 'go/latest/workspace/internals/examples' },
-    ])
+    expect(
+      workspaceRedirects([
+        'py/stable/workspace/examples',
+        'py/stable/workspace/internals/examples',
+        'go/latest/workspace/internals/examples',
+        'go/latest/workspace/reference/builder',
+        'go/latest/workspace/internals',
+        'go/latest/guides',
+      ]),
+    ).toEqual([{ path: 'go/latest/workspace/examples', target: 'go/latest/workspace/internals/examples' }])
     // The reference is its own section now, so there is nothing under
     // Internals for it to be lifted out of.
     expect(workspaceRedirects(['workspace/reference/builder'])).toEqual([])
   })
 })
 
-
 it('marks only real fallback sections on Julia ownership and preserves the selected version and target defaults', () => {
   const entries = [
     { id: '_staged/julia/topics/ownership', data: { port: 'julia', route: 'topics/ownership' } },
@@ -396,15 +554,24 @@ it('marks only real fallback sections on Julia ownership and preserves the selec
     { id: 'ports/ruby/topics/ownership', data: { port: 'ruby', route: 'topics/ownership' } },
   ]
   const links = pagePortLinks({ ...options, docs: entries, pagePath: 'topics/ownership', portSlug: 'julia' })
-  expect(links.find((entry) => entry.port === 'julia')?.links).toEqual([{ href: '/pr-42/en/julia/v1.2.3/topics/ownership/' }])
-  expect(links.find((entry) => entry.port === 'ruby')?.links).toEqual([{ href: '/pr-42/en/ruby/latest/topics/ownership/' }])
+  expect(links.find((entry) => entry.port === 'julia')?.links).toEqual([
+    { href: '/pr-42/en/julia/v1.2.3/topics/ownership/' },
+  ])
+  expect(links.find((entry) => entry.port === 'ruby')?.links).toEqual([
+    { href: '/pr-42/en/ruby/latest/topics/ownership/' },
+  ])
   expect(links.find((entry) => entry.port === 'py')?.links).toEqual([
     { href: '/pr-42/en/py/stable/topics/', label: 'Topics overview', fallback: 'section' },
   ])
-  const withoutOverview = pagePortLinks({ ...options, docs: entries.filter((entry) => entry.id !== 'topics'),
-    pagePath: 'topics/ownership', portSlug: 'julia' })
+  const withoutOverview = pagePortLinks({
+    ...options,
+    docs: entries.filter((entry) => entry.id !== 'topics'),
+    pagePath: 'topics/ownership',
+    portSlug: 'julia',
+  })
   expect(withoutOverview.find((entry) => entry.port === 'py')?.links).toEqual([])
   expect(withoutOverview.find((entry) => entry.port === 'py')?.home).toEqual({
-    href: '/pr-42/en/py/stable/', label: 'Go to Python home',
+    href: '/pr-42/en/py/stable/',
+    label: 'Go to Python home',
   })
 })
diff --git a/site/test/port-docs-identity.test.ts b/site/test/port-docs-identity.test.ts
index 4d99d9171..32ff779a9 100644
--- a/site/test/port-docs-identity.test.ts
+++ b/site/test/port-docs-identity.test.ts
@@ -9,26 +9,50 @@ import { publicationMatrix } from '../../scripts/port-docs-matrix.mjs'
 const script = fileURLToPath(new URL('../../scripts/port-docs-identity.sh', import.meta.url))
 const workflow = readFileSync(new URL('../../.github/workflows/port-docs.yml', import.meta.url), 'utf8')
 
-interface Entry { version: string; kind: string; isDefault: boolean; resolvesTo: string; publish: boolean }
+interface Entry {
+  version: string
+  kind: string
+  isDefault: boolean
+  resolvesTo: string
+  publish: boolean
+}
 
 function identity(env: Record<string, string>) {
   const directory = mkdtempSync(join(tmpdir(), 'libtmux-port-docs-identity-'))
   const output = join(directory, 'output')
   try {
     const result = spawnSync('bash', [script], {
-      encoding: 'utf8', timeout: 10000,
+      encoding: 'utf8',
+      timeout: 10000,
       env: {
-        PATH: process.env.PATH ?? '', GITHUB_OUTPUT: output, SHA: 'abc123', DEFAULT_BRANCH: 'master',
-        REF_NAME: '', REF_TYPE: 'branch', TAG_PREFIX: '', INPUT_SOURCE_REF: '', INPUT_VERSION: '',
-        INPUT_KIND: '', INPUT_DEFAULT: 'false', INPUT_RESOLVES_TO: '', INPUT_PUBLISH: 'false', ...env,
+        PATH: process.env.PATH ?? '',
+        GITHUB_OUTPUT: output,
+        SHA: 'abc123',
+        DEFAULT_BRANCH: 'master',
+        REF_NAME: '',
+        REF_TYPE: 'branch',
+        TAG_PREFIX: '',
+        INPUT_SOURCE_REF: '',
+        INPUT_VERSION: '',
+        INPUT_KIND: '',
+        INPUT_DEFAULT: 'false',
+        INPUT_RESOLVES_TO: '',
+        INPUT_PUBLISH: 'false',
+        ...env,
       },
     })
-    const outputs = result.status === 0
-      ? Object.fromEntries(readFileSync(output, 'utf8').trim().split('\n').map((line) => {
-        const at = line.indexOf('=')
-        return [line.slice(0, at), line.slice(at + 1)]
-      }))
-      : {}
+    const outputs =
+      result.status === 0
+        ? Object.fromEntries(
+            readFileSync(output, 'utf8')
+              .trim()
+              .split('\n')
+              .map((line) => {
+                const at = line.indexOf('=')
+                return [line.slice(0, at), line.slice(at + 1)]
+              }),
+          )
+        : {}
     const entries: Entry[] = outputs.matrix ? JSON.parse(outputs.matrix).include : []
     return { status: result.status, stderr: result.stderr, outputs, entries }
   } finally {
@@ -36,8 +60,10 @@ function identity(env: Record<string, string>) {
   }
 }
 
-const tag = (name: string, prefix = '') => identity({ EVENT: 'push', REF_TYPE: 'tag', REF_NAME: name, TAG_PREFIX: prefix })
-const versions = (entries: Entry[]) => entries.map(({ version, kind, isDefault, resolvesTo }) => [version, kind, isDefault, resolvesTo])
+const tag = (name: string, prefix = '') =>
+  identity({ EVENT: 'push', REF_TYPE: 'tag', REF_NAME: name, TAG_PREFIX: prefix })
+const versions = (entries: Entry[]) =>
+  entries.map(({ version, kind, isDefault, resolvesTo }) => [version, kind, isDefault, resolvesTo])
 
 describe('port docs identity', () => {
   it('builds a pull request at the merge commit and publishes nothing', () => {
@@ -48,8 +74,12 @@ describe('port docs identity', () => {
   })
 
   it('publishes an opted-in same-repository preview from the tested merge commit', () => {
-    const result = identity({ EVENT: 'pull_request', PUBLISH_PREVIEWS: 'true',
-      PR_NUMBER: '37', SAME_REPOSITORY_PR: 'true' })
+    const result = identity({
+      EVENT: 'pull_request',
+      PUBLISH_PREVIEWS: 'true',
+      PR_NUMBER: '37',
+      SAME_REPOSITORY_PR: 'true',
+    })
     expect(result.status).toBe(0)
     expect(result.outputs.source_ref).toBe('abc123')
     expect(versions(result.entries)).toEqual([['pr-37', 'pr', false, '']])
@@ -61,16 +91,24 @@ describe('port docs identity', () => {
   })
 
   it.each(['false', ''])('keeps fork or missing-identity previews unpublishable (%s)', (sameRepository) => {
-    const result = identity({ EVENT: 'pull_request', PUBLISH_PREVIEWS: 'true',
-      PR_NUMBER: '37', SAME_REPOSITORY_PR: sameRepository })
+    const result = identity({
+      EVENT: 'pull_request',
+      PUBLISH_PREVIEWS: 'true',
+      PR_NUMBER: '37',
+      SAME_REPOSITORY_PR: sameRepository,
+    })
     expect(result.status).toBe(0)
     expect(versions(result.entries)).toEqual([['pr-37', 'pr', false, '']])
     expect(result.outputs.should_publish).toBe('false')
   })
 
   it.each(['', '../latest', '37/../../latest'])('rejects an invalid opted-in preview number: %s', (number) => {
-    const result = identity({ EVENT: 'pull_request', PUBLISH_PREVIEWS: 'true',
-      PR_NUMBER: number, SAME_REPOSITORY_PR: 'true' })
+    const result = identity({
+      EVENT: 'pull_request',
+      PUBLISH_PREVIEWS: 'true',
+      PR_NUMBER: number,
+      SAME_REPOSITORY_PR: 'true',
+    })
     expect(result.status).toBe(1)
     expect(result.stderr).toContain('preview requires a numeric pull request number')
   })
@@ -79,11 +117,19 @@ describe('port docs identity', () => {
     const trunk = identity({ EVENT: 'push', REF_NAME: 'master' })
     expect(versions(trunk.entries)).toEqual([['latest', 'trunk', true, '']])
     expect(trunk.outputs.should_publish).toBe('true')
-    const prerelease = identity({ EVENT: 'push', REF_NAME: 'master', TAG_PREFIX: 'libtmux@',
-      TAGS: 'libtmux@v0.1.0-alpha.14\ntmux-mcp@v1.0.0\nv2.0.0' })
-    expect(versions(prerelease.entries), 'another package\'s release').toEqual([['latest', 'trunk', true, '']])
-    const released = identity({ EVENT: 'push', REF_NAME: 'master', TAG_PREFIX: 'libtmux@',
-      TAGS: 'libtmux@v0.1.0-alpha.14\nlibtmux@v0.1.0' })
+    const prerelease = identity({
+      EVENT: 'push',
+      REF_NAME: 'master',
+      TAG_PREFIX: 'libtmux@',
+      TAGS: 'libtmux@v0.1.0-alpha.14\ntmux-mcp@v1.0.0\nv2.0.0',
+    })
+    expect(versions(prerelease.entries), "another package's release").toEqual([['latest', 'trunk', true, '']])
+    const released = identity({
+      EVENT: 'push',
+      REF_NAME: 'master',
+      TAG_PREFIX: 'libtmux@',
+      TAGS: 'libtmux@v0.1.0-alpha.14\nlibtmux@v0.1.0',
+    })
     expect(versions(released.entries), 'after a stable release').toEqual([['latest', 'trunk', false, '']])
     const other = identity({ EVENT: 'push', REF_NAME: 'docs-site' })
     expect(other.status).toBe(1)
@@ -110,16 +156,21 @@ describe('port docs identity', () => {
     }
   })
 
-  it('refuses a tag that is not this package\'s release', () => {
+  it("refuses a tag that is not this package's release", () => {
     expect(tag('tmux-mcp@v0.1.0', 'libtmux@').stderr).toContain('does not start with libtmux@')
     expect(tag('libtmux@nightly', 'libtmux@').stderr).toContain('unsupported release tag')
   })
 
   it('publishes exactly what a dispatch names, and refuses what cannot be published', () => {
-    const dispatch = (inputs: Record<string, string>) => identity({
-      EVENT: 'workflow_dispatch', INPUT_SOURCE_REF: 'libtmux@v0.1.0-alpha.14', INPUT_VERSION: 'v0.1.0-alpha.14',
-      INPUT_KIND: 'tag', INPUT_PUBLISH: 'true', ...inputs,
-    })
+    const dispatch = (inputs: Record<string, string>) =>
+      identity({
+        EVENT: 'workflow_dispatch',
+        INPUT_SOURCE_REF: 'libtmux@v0.1.0-alpha.14',
+        INPUT_VERSION: 'v0.1.0-alpha.14',
+        INPUT_KIND: 'tag',
+        INPUT_PUBLISH: 'true',
+        ...inputs,
+      })
     const ok = dispatch({})
     expect(ok.outputs.source_ref).toBe('libtmux@v0.1.0-alpha.14')
     expect(versions(ok.entries)).toEqual([['v0.1.0-alpha.14', 'tag', false, '']])
@@ -137,18 +188,32 @@ describe('port docs workflow', () => {
     const entries = tag('v0.0.1-alpha.17').entries
     const matrix = publicationMatrix({ include: entries }, 'java', 'libtmux/libtmux-java', true)
     expect(matrix.include.map(({ port, version }) => `${port}/${version}`)).toEqual([
-      'java/v0.0.1-alpha.17', 'kotlin/v0.0.1-alpha.17', 'scala/v0.0.1-alpha.17',
-      'java/next', 'kotlin/next', 'scala/next',
+      'java/v0.0.1-alpha.17',
+      'kotlin/v0.0.1-alpha.17',
+      'scala/v0.0.1-alpha.17',
+      'java/next',
+      'kotlin/next',
+      'scala/next',
     ])
     expect(publicationMatrix({ include: entries }, 'java', 'libtmux/libtmux-java').include).toHaveLength(2)
-    expect(publicationMatrix({ include: entries }, 'fsharp', 'libtmux/libtmux-dotnet').include.every((entry) => entry.port === 'fsharp')).toBe(true)
-    expect(() => publicationMatrix({ include: entries }, 'java', 'libtmux/libtmux-dotnet', true)).toThrow('cannot build java')
+    expect(
+      publicationMatrix({ include: entries }, 'fsharp', 'libtmux/libtmux-dotnet').include.every(
+        (entry) => entry.port === 'fsharp',
+      ),
+    ).toBe(true)
+    expect(() => publicationMatrix({ include: entries }, 'java', 'libtmux/libtmux-dotnet', true)).toThrow(
+      'cannot build java',
+    )
     expect(() => publicationMatrix({ include: entries }, 'scala', 'libtmux/libtmux-ts')).toThrow('cannot build scala')
-    expect(() => publicationMatrix({ include: entries }, 'unknown', 'libtmux/docs')).toThrow('unknown documentation port')
+    expect(() => publicationMatrix({ include: entries }, 'unknown', 'libtmux/docs')).toThrow(
+      'unknown documentation port',
+    )
   })
 
   it('builds with the scripts of its own commit, not a second pin', () => {
-    const docsCheckouts = workflow.match(/repository: \$\{\{ job\.workflow_repository \}\}\n\s+ref: \$\{\{ job\.workflow_sha \}\}/g)
+    const docsCheckouts = workflow.match(
+      /repository: \$\{\{ job\.workflow_repository \}\}\n\s+ref: \$\{\{ job\.workflow_sha \}\}/g,
+    )
     expect(docsCheckouts).toHaveLength(2)
     expect(workflow).not.toMatch(/ref: [0-9a-f]{40}/)
   })
diff --git a/site/test/port-docs-runtime.test.ts b/site/test/port-docs-runtime.test.ts
index c7dc93ae4..bd6d9b6d1 100644
--- a/site/test/port-docs-runtime.test.ts
+++ b/site/test/port-docs-runtime.test.ts
@@ -21,13 +21,18 @@ function selectedVersion(port: string, source?: string) {
   try {
     mkdirSync(join(directory, 'port'))
     writeFileSync(output, '')
-    if (source !== undefined) writeFileSync(join(directory, 'port', port === 'rs' ? 'rust-toolchain.toml' : '.mise.toml'), source)
+    if (source !== undefined)
+      writeFileSync(join(directory, 'port', port === 'rs' ? 'rust-toolchain.toml' : '.mise.toml'), source)
     const result = spawnSync('bash', ['-e', '-c', script('Read selected Rust and Swift toolchains')], {
-      cwd: directory, encoding: 'utf8', timeout: 5000,
+      cwd: directory,
+      encoding: 'utf8',
+      timeout: 5000,
       env: { ...process.env, PORT: port, GITHUB_OUTPUT: output },
     })
     return { ...result, output: readFileSync(output, 'utf8') }
-  } finally { rmSync(directory, { recursive: true, force: true }) }
+  } finally {
+    rmSync(directory, { recursive: true, force: true })
+  }
 }
 
 function documentationVersion(port: string, source: string) {
@@ -41,11 +46,15 @@ function documentationVersion(port: string, source: string) {
     writeFileSync(output, '')
     writeFileSync(environment, '')
     const result = spawnSync('bash', ['-e', '-c', script('Read native documentation toolchain')], {
-      cwd: directory, encoding: 'utf8', timeout: 5000,
+      cwd: directory,
+      encoding: 'utf8',
+      timeout: 5000,
       env: { ...process.env, PORT: port, GENERATOR_CHECKOUT: tooling, GITHUB_OUTPUT: output, GITHUB_ENV: environment },
     })
     return { ...result, output: readFileSync(output, 'utf8'), environment: readFileSync(environment, 'utf8'), tooling }
-  } finally { rmSync(directory, { recursive: true, force: true }) }
+  } finally {
+    rmSync(directory, { recursive: true, force: true })
+  }
 }
 
 describe('native documentation producers', () => {
@@ -78,20 +87,34 @@ describe('native documentation producers', () => {
       const output = join(directory, 'path')
       const extracted = join(directory, 'extracted')
       writeFileSync(output, '')
-      writeFileSync(join(directory, 'curl'), `#!${process.execPath}
+      writeFileSync(
+        join(directory, 'curl'),
+        `#!${process.execPath}
 const fs = require('node:fs')
 fs.writeFileSync(process.argv[process.argv.indexOf('--output') + 1], 'changed archive')
-`, { mode: 0o700 })
+`,
+        { mode: 0o700 },
+      )
       writeFileSync(join(directory, 'tar'), `#!/bin/sh\ntouch '${extracted}'\n`, { mode: 0o700 })
       const result = spawnSync('bash', ['-e', '-c', script('Install tested PowerShell documentation runtime')], {
-        cwd: root, encoding: 'utf8', timeout: 5000,
-        env: { ...process.env, PATH: `${directory}:${process.env.PATH}`, POWERSHELL_VERSION: '7.4.20', RUNNER_TEMP: directory, GITHUB_PATH: output },
+        cwd: root,
+        encoding: 'utf8',
+        timeout: 5000,
+        env: {
+          ...process.env,
+          PATH: `${directory}:${process.env.PATH}`,
+          POWERSHELL_VERSION: '7.4.20',
+          RUNNER_TEMP: directory,
+          GITHUB_PATH: output,
+        },
       })
       expect(result.status).not.toBe(0)
       expect(result.stderr).toContain('computed checksum did NOT match')
       expect(readFileSync(output, 'utf8')).toBe('')
       expect(() => readFileSync(extracted)).toThrow()
-    } finally { rmSync(directory, { recursive: true, force: true }) }
+    } finally {
+      rmSync(directory, { recursive: true, force: true })
+    }
   })
 
   it('prepares the PowerShell exporter before extracting the selected source checkout', () => {
@@ -102,19 +125,37 @@ fs.writeFileSync(process.argv[process.argv.indexOf('--output') + 1], 'changed ar
       const output = join(directory, 'invocations')
       mkdirSync(source)
       mkdirSync(tooling)
-      writeFileSync(join(directory, 'pwsh'), `#!${process.execPath}
+      writeFileSync(
+        join(directory, 'pwsh'),
+        `#!${process.execPath}
 require('node:fs').appendFileSync(process.env.EXPORT_INVOCATIONS, JSON.stringify(process.argv.slice(2)) + '\\n')
-`, { mode: 0o700 })
+`,
+        { mode: 0o700 },
+      )
       const result = spawnSync('bash', ['-e', '-c', script('Export PowerShell API from the selected source')], {
-        cwd: source, encoding: 'utf8', timeout: 5000,
-        env: { ...process.env, PATH: `${directory}:${process.env.PATH}`, LIBTMUX_DOCS_GENERATOR_CHECKOUT: tooling, EXPORT_INVOCATIONS: output },
+        cwd: source,
+        encoding: 'utf8',
+        timeout: 5000,
+        env: {
+          ...process.env,
+          PATH: `${directory}:${process.env.PATH}`,
+          LIBTMUX_DOCS_GENERATOR_CHECKOUT: tooling,
+          EXPORT_INVOCATIONS: output,
+        },
       })
       expect(result.status, result.stderr).toBe(0)
-      expect(readFileSync(output, 'utf8').trim().split('\n').map((line) => JSON.parse(line))).toEqual([
+      expect(
+        readFileSync(output, 'utf8')
+          .trim()
+          .split('\n')
+          .map((line) => JSON.parse(line)),
+      ).toEqual([
         ['-NoLogo', '-NoProfile', '-File', join(tooling, 'eng/Setup.ps1')],
         ['-NoLogo', '-NoProfile', '-File', join(tooling, 'eng/Export-Docs.ps1'), '-SourceRoot', source, '-Restore'],
       ])
-    } finally { rmSync(directory, { recursive: true, force: true }) }
+    } finally {
+      rmSync(directory, { recursive: true, force: true })
+    }
   })
 })
 
@@ -122,7 +163,9 @@ function doxygenProbe(version: string, aliases = 1, overloads = 2, protection =
   const directory = mkdtempSync(join(tmpdir(), 'libtmux-doxygen-test-'))
   try {
     const binary = join(directory, 'doxygen')
-    writeFileSync(binary, `#!${process.execPath}
+    writeFileSync(
+      binary,
+      `#!${process.execPath}
 const fs = require('node:fs')
 if (process.argv[2] === '--version') {
   console.log(${JSON.stringify(version)})
@@ -135,11 +178,16 @@ const member = name => '<memberdef kind="function" prot="${protection}"><qualifi
 fs.writeFileSync('xml/namespacelibtmux.xml', '<doxygen><compounddef>' +
   Array(${aliases}).fill(member('libtmux::matching')).join('') +
   Array(${overloads}).fill(member('libtmux::tmuxq::matching')).join('') + '</compounddef></doxygen>')
-`, { mode: 0o700 })
+`,
+      { mode: 0o700 },
+    )
     return spawnSync('python3', [doxygenCheck, binary, '1.18.0'], {
-      encoding: 'utf8', timeout: 5000,
+      encoding: 'utf8',
+      timeout: 5000,
     })
-  } finally { rmSync(directory, { recursive: true, force: true }) }
+  } finally {
+    rmSync(directory, { recursive: true, force: true })
+  }
 }
 
 describe('C++ Doxygen producer', () => {
@@ -167,45 +215,55 @@ describe('C++ Doxygen producer', () => {
       const output = join(directory, 'path')
       const extracted = join(directory, 'extracted')
       writeFileSync(output, '')
-      writeFileSync(join(directory, 'curl'), `#!${process.execPath}
+      writeFileSync(
+        join(directory, 'curl'),
+        `#!${process.execPath}
 const fs = require('node:fs')
 fs.writeFileSync(process.argv[process.argv.indexOf('--output') + 1], 'changed archive')
-`, { mode: 0o700 })
+`,
+        { mode: 0o700 },
+      )
       writeFileSync(join(directory, 'tar'), `#!/bin/sh\ntouch '${extracted}'\n`, { mode: 0o700 })
       const result = spawnSync('bash', ['-e', '-c', script('Install tested Doxygen producer')], {
-        cwd: root, encoding: 'utf8', timeout: 5000,
+        cwd: root,
+        encoding: 'utf8',
+        timeout: 5000,
         env: { ...process.env, PATH: `${directory}:${process.env.PATH}`, RUNNER_TEMP: directory, GITHUB_PATH: output },
       })
       expect(result.status).not.toBe(0)
       expect(result.stderr).toContain('computed checksum did NOT match')
       expect(readFileSync(output, 'utf8')).toBe('')
       expect(() => readFileSync(extracted)).toThrow()
-    } finally { rmSync(directory, { recursive: true, force: true }) }
+    } finally {
+      rmSync(directory, { recursive: true, force: true })
+    }
   })
 
   it.each(['1.18.0', '1.18.0 (8e760943e5d9581a444cf327f43a0b4d20d29482)'])(
-    'accepts %s with the public alias and both original overloads', (version) => {
+    'accepts %s with the public alias and both original overloads',
+    (version) => {
       const result = doxygenProbe(version)
       expect(result.status, result.stderr).toBe(0)
       expect(result.stdout).toContain('public using-declaration and two original overloads verified')
     },
   )
 
-  it.each(['1.9.8', '1.14.0', '1.18.1', '1.18.0 unexpected'])(
-    'rejects an untested producer %s', (version) => {
-      const result = doxygenProbe(version)
-      expect(result.status).not.toBe(0)
-      expect(result.stderr).toContain('Expected Doxygen 1.18.0')
-    },
-  )
+  it.each(['1.9.8', '1.14.0', '1.18.1', '1.18.0 unexpected'])('rejects an untested producer %s', (version) => {
+    const result = doxygenProbe(version)
+    expect(result.status).not.toBe(0)
+    expect(result.stderr).toContain('Expected Doxygen 1.18.0')
+  })
 
-  it.each([[0, 2, 'public'], [2, 2, 'public'], [1, 1, 'public'], [1, 2, 'private']] as const)(
-    'rejects %s aliases, %s original overloads, and %s visibility', (aliases, overloads, protection) => {
-      const result = doxygenProbe('1.18.0', aliases, overloads, protection)
-      expect(result.status).not.toBe(0)
-      expect(result.stderr).toContain('must emit the public libtmux::matching using-declaration')
-    },
-  )
+  it.each([
+    [0, 2, 'public'],
+    [2, 2, 'public'],
+    [1, 1, 'public'],
+    [1, 2, 'private'],
+  ] as const)('rejects %s aliases, %s original overloads, and %s visibility', (aliases, overloads, protection) => {
+    const result = doxygenProbe('1.18.0', aliases, overloads, protection)
+    expect(result.status).not.toBe(0)
+    expect(result.stderr).toContain('must emit the public libtmux::matching using-declaration')
+  })
 })
 
 describe('selected MCP runtime provisioning', () => {
@@ -235,45 +293,71 @@ describe('selected MCP runtime provisioning', () => {
   })
 
   it.each([
-    ['go', true], ['py', true], ['ruby', true],
-    ['lua', false], ['kotlin', false], ['scala', false], ['fsharp', false], ['powershell', false], ['julia', true],
+    ['go', true],
+    ['py', true],
+    ['ruby', true],
+    ['lua', false],
+    ['kotlin', false],
+    ['scala', false],
+    ['fsharp', false],
+    ['powershell', false],
+    ['julia', true],
   ])('uses the product catalog for %s runtime availability', (port, required) => {
     const directory = mkdtempSync(join(tmpdir(), 'libtmux-mcp-availability-'))
     try {
       const output = join(directory, 'output')
       writeFileSync(output, '')
       const result = spawnSync('bash', ['-e', '-c', script('Resolve MCP availability from the port catalog')], {
-        cwd: root, encoding: 'utf8', timeout: 5000,
+        cwd: root,
+        encoding: 'utf8',
+        timeout: 5000,
         env: { ...process.env, PORT: String(port), GITHUB_OUTPUT: output },
       })
       expect(result.status, result.stderr).toBe(0)
       expect(readFileSync(output, 'utf8')).toBe(`required=${required}\n`)
-    } finally { rmSync(directory, { recursive: true, force: true }) }
+    } finally {
+      rmSync(directory, { recursive: true, force: true })
+    }
   })
 
-  it.each(['6.2.4', '6.2.3', 'unrecognized'])('verifies the installed Swift compiler reports %s before adding it to PATH', (version) => {
-    const directory = mkdtempSync(join(tmpdir(), 'libtmux-swift-version-'))
-    try {
-      const bin = join(directory, 'bin')
-      const output = join(directory, 'path')
-      mkdirSync(bin)
-      writeFileSync(output, '')
-      writeFileSync(join(bin, 'mise'), '#!/bin/sh\nprintf "%s\\n" "$STUB_TOOLCHAIN"\n', { mode: 0o700 })
-      writeFileSync(join(bin, 'swift'), `#!/bin/sh\nprintf '%s\\n' 'Swift version ${version} (fixture)'\n`, { mode: 0o700 })
-      const result = spawnSync('bash', ['-e', '-c', script('Verify selected Swift toolchain')], {
-        cwd: directory, encoding: 'utf8', timeout: 5000,
-        env: { ...process.env, PATH: `${bin}:${process.env.PATH}`, STUB_TOOLCHAIN: directory, SWIFT_VERSION: '6.2.4', GITHUB_PATH: output },
-      })
-      if (version === '6.2.4') {
-        expect(result.status, result.stderr).toBe(0)
-        expect(readFileSync(output, 'utf8')).toBe(`${bin}\n`)
-      } else {
-        expect(result.status).not.toBe(0)
-        expect(result.stderr).toContain('Expected Swift 6.2.4')
-        expect(readFileSync(output, 'utf8')).toBe('')
+  it.each(['6.2.4', '6.2.3', 'unrecognized'])(
+    'verifies the installed Swift compiler reports %s before adding it to PATH',
+    (version) => {
+      const directory = mkdtempSync(join(tmpdir(), 'libtmux-swift-version-'))
+      try {
+        const bin = join(directory, 'bin')
+        const output = join(directory, 'path')
+        mkdirSync(bin)
+        writeFileSync(output, '')
+        writeFileSync(join(bin, 'mise'), '#!/bin/sh\nprintf "%s\\n" "$STUB_TOOLCHAIN"\n', { mode: 0o700 })
+        writeFileSync(join(bin, 'swift'), `#!/bin/sh\nprintf '%s\\n' 'Swift version ${version} (fixture)'\n`, {
+          mode: 0o700,
+        })
+        const result = spawnSync('bash', ['-e', '-c', script('Verify selected Swift toolchain')], {
+          cwd: directory,
+          encoding: 'utf8',
+          timeout: 5000,
+          env: {
+            ...process.env,
+            PATH: `${bin}:${process.env.PATH}`,
+            STUB_TOOLCHAIN: directory,
+            SWIFT_VERSION: '6.2.4',
+            GITHUB_PATH: output,
+          },
+        })
+        if (version === '6.2.4') {
+          expect(result.status, result.stderr).toBe(0)
+          expect(readFileSync(output, 'utf8')).toBe(`${bin}\n`)
+        } else {
+          expect(result.status).not.toBe(0)
+          expect(result.stderr).toContain('Expected Swift 6.2.4')
+          expect(readFileSync(output, 'utf8')).toBe('')
+        }
+      } finally {
+        rmSync(directory, { recursive: true, force: true })
       }
-    } finally { rmSync(directory, { recursive: true, force: true }) }
-  })
+    },
+  )
 
   it('installs the separate Python MCP checkout without altering the captured inputs', () => {
     const snapshot = workflow.indexOf('name: Snapshot source inputs before native generation')
diff --git a/site/test/port-documentation.test.ts b/site/test/port-documentation.test.ts
index e96b781e8..2a19539ca 100644
--- a/site/test/port-documentation.test.ts
+++ b/site/test/port-documentation.test.ts
@@ -1,15 +1,34 @@
 import { describe, expect, it } from 'vitest'
-import { documentationAreas, documentationCards, documentationNavigation, sourceGuideFor } from '../src/lib/port-documentation'
+import {
+  documentationAreas,
+  documentationCards,
+  documentationNavigation,
+  sourceGuideFor,
+} from '../src/lib/port-documentation'
 
 describe('port documentation domains', () => {
   it('keeps Ruby packages separate from products and Lua runtime adapters', () => {
-    expect(documentationAreas('ruby').map(({ id, kind, package: packageId, product }) => ({ id, kind, package: packageId, product }))).toEqual([
+    expect(
+      documentationAreas('ruby').map(({ id, kind, package: packageId, product }) => ({
+        id,
+        kind,
+        package: packageId,
+        product,
+      })),
+    ).toEqual([
       { id: 'core', kind: 'core', package: 'core', product: undefined },
       { id: 'async', kind: 'companion-package', package: 'async', product: undefined },
       { id: 'mcp', kind: 'product', package: 'mcp', product: 'mcp' },
       { id: 'workspace', kind: 'product', package: 'workspace', product: 'workspace' },
     ])
-    expect(documentationAreas('lua').map(({ id, kind, package: packageId, product }) => ({ id, kind, package: packageId, product }))).toEqual([
+    expect(
+      documentationAreas('lua').map(({ id, kind, package: packageId, product }) => ({
+        id,
+        kind,
+        package: packageId,
+        product,
+      })),
+    ).toEqual([
       { id: 'core', kind: 'core', package: 'core', product: undefined },
       { id: 'runtime', kind: 'runtime', package: undefined, product: undefined },
       { id: 'mcp', kind: 'unavailable', package: undefined, product: 'mcp' },
@@ -31,12 +50,17 @@ describe('port documentation domains', () => {
     ])
     expect(documentationNavigation('lua', 'latest')).toEqual([
       { label: 'Library', items: [{ type: 'link', label: 'Core library', href: '/lua/latest/' }] },
-      { label: 'Runtime adapters', items: [{ type: 'link', label: 'luv and Neovim', href: '/lua/latest/guides/runtime/' }] },
+      {
+        label: 'Runtime adapters',
+        items: [{ type: 'link', label: 'luv and Neovim', href: '/lua/latest/guides/runtime/' }],
+      },
     ])
-    expect(documentationCards('ruby', 'latest').map((card) => card.label)).toEqual(['Async', 'MCP', 'Workspace Manager'])
-    expect(documentationCards('lua', 'latest').map((card) => card.label)).toEqual([
-      'luv and Neovim',
+    expect(documentationCards('ruby', 'latest').map((card) => card.label)).toEqual([
+      'Async',
+      'MCP',
+      'Workspace Manager',
     ])
+    expect(documentationCards('lua', 'latest').map((card) => card.label)).toEqual(['luv and Neovim'])
   })
 
   it('owns canonical source-guide routes and legacy aliases without duplicating a revision', () => {
diff --git a/site/test/port-metadata.test.ts b/site/test/port-metadata.test.ts
index 42466a666..c7e7fa219 100644
--- a/site/test/port-metadata.test.ts
+++ b/site/test/port-metadata.test.ts
@@ -45,7 +45,15 @@ describe('TypeScript port metadata', () => {
     expect(ts.workspaceCliAvailability).toBe('published')
     const cli = ts.packages?.find((entry) => entry.id === 'workspace')
     expect(cli).toMatchObject({ name: '@libtmux/workspace-cli', executable: 'tmux-workspace' })
-    expect(cli?.installs?.map(({ label }) => label)).toEqual(['npx', 'bunx', 'pnpm dlx', 'yarn dlx', 'npm -g', 'pnpm -g', 'bun -g'])
+    expect(cli?.installs?.map(({ label }) => label)).toEqual([
+      'npx',
+      'bunx',
+      'pnpm dlx',
+      'yarn dlx',
+      'npm -g',
+      'pnpm -g',
+      'bun -g',
+    ])
     expect(cli?.installs?.every(({ code }) => code.includes('@libtmux/workspace-cli'))).toBe(true)
   })
 })
diff --git a/site/test/port-prose.test.ts b/site/test/port-prose.test.ts
index bb33c8121..f93febb8d 100644
--- a/site/test/port-prose.test.ts
+++ b/site/test/port-prose.test.ts
@@ -13,8 +13,14 @@ import { docsEntryAvailable } from '../src/lib/page-port-links'
 import { PORT_BY_SLUG } from '../src/lib/ports'
 
 const languageNames: Record<string, string[]> = {
-  py: ['Python'], ts: ['TypeScript'], go: ['Go'], rs: ['Rust'], java: ['Java'],
-  csharp: ['.NET', 'C#'], cxx: ['C++'], swift: ['Swift'],
+  py: ['Python'],
+  ts: ['TypeScript'],
+  go: ['Go'],
+  rs: ['Rust'],
+  java: ['Java'],
+  csharp: ['.NET', 'C#'],
+  cxx: ['C++'],
+  swift: ['Swift'],
 }
 const contentRoot = fileURLToPath(new URL('../src/content/', import.meta.url))
 
@@ -64,8 +70,13 @@ describe('port prose ownership', () => {
 
   it('retains explicit ownership for root API links and guide backlinks', async () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', '')
-    const body = '## Calls\n\n<!-- port:go -->Use `Session.Panes`.\n<!-- /port -->\n<!-- port:py -->Use `Session.panes`.\n<!-- /port -->'
-    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
+    const body =
+      '## Calls\n\n<!-- port:go -->Use `Session.Panes`.\n<!-- /port -->\n<!-- port:py -->Use `Session.panes`.\n<!-- /port -->'
+    const renderer = await createMarkdownProcessor({
+      remarkPlugins: [remarkPortCode],
+      rehypePlugins: [rehypeApiLinks],
+      syntaxHighlight: false,
+    })
     const rendered = await renderer.render(body)
     expect(rendered.code).toContain('href="/go/latest/reference/tmux-session-panes/"')
     expect(rendered.code).toContain('href="/py/latest/reference/libtmux-session-panes/"')
@@ -88,12 +99,14 @@ describe('port prose ownership', () => {
   })
 
   it('selects setup commands inside shared console fences', () => {
-    const body = '```console\n<!-- port:go -->$ go test ./...\n<!-- /port --><!-- port:ts -->$ bun test\n<!-- /port -->```'
+    const body =
+      '```console\n<!-- port:go -->$ go test ./...\n<!-- /port --><!-- port:ts -->$ bun test\n<!-- /port -->```'
     expect(resolvePortBody(body, 'go')).toBe('```console\n$ go test ./...\n```')
   })
 
   it('keeps conditional rows in one Markdown table', async () => {
-    const body = '| Port | Call |\n| --- | --- |\n<!-- port:go -->\n| Go | SendKeys |\n<!-- /port -->\n<!-- port:py -->\n| Python | send_keys |\n<!-- /port -->'
+    const body =
+      '| Port | Call |\n| --- | --- |\n<!-- port:go -->\n| Go | SendKeys |\n<!-- /port -->\n<!-- port:py -->\n| Python | send_keys |\n<!-- /port -->'
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
     const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
     const rendered = await renderer.render(body)
@@ -103,8 +116,11 @@ describe('port prose ownership', () => {
   })
 
   it.each(['', 'py', 'ts', 'go', 'java', 'csharp', 'cxx', 'swift'])(
-    'renders transport choices as complete prose for %s in HTML and Markdown', async (port) => {
-      const { content } = parseFrontmatter(readFileSync(`${contentRoot}docs/concepts/transports.md`, 'utf8'), { frontmatter: 'remove' })
+    'renders transport choices as complete prose for %s in HTML and Markdown',
+    async (port) => {
+      const { content } = parseFrontmatter(readFileSync(`${contentRoot}docs/concepts/transports.md`, 'utf8'), {
+        frontmatter: 'remove',
+      })
       vi.stubEnv('LIBTMUX_DOCS_PORT', port)
       const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
       const html = (await renderer.render(content)).code
@@ -115,7 +131,11 @@ describe('port prose ownership', () => {
   )
 
   it('rejects misspelled, empty and unmatched ownership markers', () => {
-    for (const body of ['<!-- port:golang -->bad<!-- /port -->', '<!-- port: -->bad<!-- /port -->', '<!-- port:go -->bad']) {
+    for (const body of [
+      '<!-- port:golang -->bad<!-- /port -->',
+      '<!-- port: -->bad<!-- /port -->',
+      '<!-- port:go -->bad',
+    ]) {
       expect(() => resolvePortBody(body, 'go')).toThrow()
     }
   })
@@ -128,51 +148,92 @@ describe('port prose ownership', () => {
     }
   })
 
-  it.each(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])('keeps native workspace commands on %s pages', (port) => {
-    for (const name of ['index', 'convert', 'edit', 'freeze', 'ls', 'debug-info', 'search', 'load', 'import', 'import-teamocil', 'import-tmuxinator', 'completion', 'shell']) {
-      const raw = readFileSync(`${contentRoot}_workspace-shared/workspace/cli/${name}.md`, 'utf8')
-      const body = resolvePortBody(raw, port)
-      expect(body, `${port}:${name}`).toMatch(/\$ (?:EDITOR=vi )?tmux-workspace /)
-      expect(body, `${port}:${name}`).not.toMatch(/\$ tmuxp |tmuxp compatibility reference|proposed native|seven native ports/i)
-      expect(body, `${port}:${name}`).toContain(`https://github.com/${PORT_BY_SLUG[port]!.repo}/blob/`)
-      expect(body, `${port}:${name}`).not.toContain('https://github.com/tmux-python/tmuxp/')
-    }
-  })
+  it.each(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])(
+    'keeps native workspace commands on %s pages',
+    (port) => {
+      for (const name of [
+        'index',
+        'convert',
+        'edit',
+        'freeze',
+        'ls',
+        'debug-info',
+        'search',
+        'load',
+        'import',
+        'import-teamocil',
+        'import-tmuxinator',
+        'completion',
+        'shell',
+      ]) {
+        const raw = readFileSync(`${contentRoot}_workspace-shared/workspace/cli/${name}.md`, 'utf8')
+        const body = resolvePortBody(raw, port)
+        expect(body, `${port}:${name}`).toMatch(/\$ (?:EDITOR=vi )?tmux-workspace /)
+        expect(body, `${port}:${name}`).not.toMatch(
+          /\$ tmuxp |tmuxp compatibility reference|proposed native|seven native ports/i,
+        )
+        expect(body, `${port}:${name}`).toContain(`https://github.com/${PORT_BY_SLUG[port]!.repo}/blob/`)
+        expect(body, `${port}:${name}`).not.toContain('https://github.com/tmux-python/tmuxp/')
+      }
+    },
+  )
 
-  it.each(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])('keeps every shared workspace guide about %s', (port) => {
-    for (const path of globSync(`${contentRoot}_workspace-shared/workspace/**/*.md`)) {
-      const body = resolvePortBody(readFileSync(path, 'utf8'), port)
-      expect(body, path).not.toMatch(/\$ (?:uv tool install tmuxp|tmuxp )|Python alternative|tmuxp compatibility reference|proposed native|seven native ports|workspace-cli worktree/i)
-      const { frontmatter } = parseFrontmatter(body)
-      if (/\/(?:guides|examples)\/index\.md$/.test(path) && Array.isArray(frontmatter.cards)) {
-        // Browse pages link to complete guides; the guides own the programs
-        // and source attribution. Every card must still name a real page.
-        expect(body, path).not.toContain('```')
-        expect(frontmatter.cards.length, path).toBeGreaterThan(0)
-        for (const card of frontmatter.cards) {
-          if (card.ports && !card.ports.includes(port)) continue
-          expect(card.href, path).toMatch(/^\.\.?\//)
-          const target = resolve(dirname(path), card.href)
-          const relative = target.slice(`${contentRoot}_workspace-shared/`.length)
-          const override = `${contentRoot}docs/ports/${port}/${relative}`
-          expect([target, override].some((page) => existsSync(`${page}.md`) || existsSync(`${page}/index.md`)), `${path}: ${card.href}`).toBe(true)
-        }
-      } else expect(body, path).toContain(`https://github.com/${PORT_BY_SLUG[port]!.repo}/blob/`)
-      expect(body, path).not.toContain('https://github.com/tmux-python/tmuxp/')
-      const repositories = [...body.matchAll(/https:\/\/github\.com\/libtmux\/libtmux-([a-z]+)\//g)]
-      expect(repositories.every((match) => `libtmux/libtmux-${match[1]}` === PORT_BY_SLUG[port]!.repo), path).toBe(true)
-    }
-  })
+  it.each(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])(
+    'keeps every shared workspace guide about %s',
+    (port) => {
+      for (const path of globSync(`${contentRoot}_workspace-shared/workspace/**/*.md`)) {
+        const body = resolvePortBody(readFileSync(path, 'utf8'), port)
+        expect(body, path).not.toMatch(
+          /\$ (?:uv tool install tmuxp|tmuxp )|Python alternative|tmuxp compatibility reference|proposed native|seven native ports|workspace-cli worktree/i,
+        )
+        const { frontmatter } = parseFrontmatter(body)
+        if (/\/(?:guides|examples)\/index\.md$/.test(path) && Array.isArray(frontmatter.cards)) {
+          // Browse pages link to complete guides; the guides own the programs
+          // and source attribution. Every card must still name a real page.
+          expect(body, path).not.toContain('```')
+          expect(frontmatter.cards.length, path).toBeGreaterThan(0)
+          for (const card of frontmatter.cards) {
+            if (card.ports && !card.ports.includes(port)) continue
+            expect(card.href, path).toMatch(/^\.\.?\//)
+            const target = resolve(dirname(path), card.href)
+            const relative = target.slice(`${contentRoot}_workspace-shared/`.length)
+            const override = `${contentRoot}docs/ports/${port}/${relative}`
+            expect(
+              [target, override].some((page) => existsSync(`${page}.md`) || existsSync(`${page}/index.md`)),
+              `${path}: ${card.href}`,
+            ).toBe(true)
+          }
+        } else expect(body, path).toContain(`https://github.com/${PORT_BY_SLUG[port]!.repo}/blob/`)
+        expect(body, path).not.toContain('https://github.com/tmux-python/tmuxp/')
+        const repositories = [...body.matchAll(/https:\/\/github\.com\/libtmux\/libtmux-([a-z]+)\//g)]
+        expect(
+          repositories.every((match) => `libtmux/libtmux-${match[1]}` === PORT_BY_SLUG[port]!.repo),
+          path,
+        ).toBe(true)
+      }
+    },
+  )
 
   it.each(Object.entries(languageNames))('keeps shared articles specific to %s', (port, ownNames) => {
     const paths = globSync(`${contentRoot}docs/{concepts,guides,topics,examples}/*.md`)
     expect(paths.length).toBeGreaterThan(1)
     for (const path of paths) {
       const { content: source, frontmatter } = parseFrontmatter(readFileSync(path, 'utf8'))
-      if (!docsEntryAvailable({ id: path.slice(`${contentRoot}docs/`.length).replace(/\.md$/, ''), data: frontmatter }, port)) continue
+      if (
+        !docsEntryAvailable(
+          { id: path.slice(`${contentRoot}docs/`.length).replace(/\.md$/, ''), data: frontmatter },
+          port,
+        )
+      )
+        continue
       const prose = resolvePortCode(source, port).replace(/^ *```[\s\S]*?^ *```.*$/gm, '')
-      const names = [...prose.matchAll(/\b(?:Python|TypeScript|Go|Rust|Java|Swift)\b|\.NET|C\+\+|C#/g)].map((match) => match[0])
-      expect(names.filter((name) => !ownNames.includes(name)), path).toEqual([])
+      const names = [...prose.matchAll(/\b(?:Python|TypeScript|Go|Rust|Java|Swift)\b|\.NET|C\+\+|C#/g)].map(
+        (match) => match[0],
+      )
+      expect(
+        names.filter((name) => !ownNames.includes(name)),
+        path,
+      ).toEqual([])
     }
   })
 
@@ -184,25 +245,54 @@ describe('port prose ownership', () => {
     ]
     for (const path of paths) {
       const { content, frontmatter } = parseFrontmatter(readFileSync(path, 'utf8'))
-      if (path.includes('/docs/') && !path.includes(`/ports/${port}/`)
-        && !docsEntryAvailable({ id: path.slice(`${contentRoot}docs/`.length).replace(/\.md$/, ''), data: frontmatter }, port)) continue
-      const prose = resolvePortCode(content, port, frontmatter.port).replace(/^ *(`{3,}|~{3,})[^\n]*\n[\s\S]*?^ *\1[^\n]*$/gm, '')
+      if (
+        path.includes('/docs/') &&
+        !path.includes(`/ports/${port}/`) &&
+        !docsEntryAvailable(
+          { id: path.slice(`${contentRoot}docs/`.length).replace(/\.md$/, ''), data: frontmatter },
+          port,
+        )
+      )
+        continue
+      const prose = resolvePortCode(content, port, frontmatter.port).replace(
+        /^ *(`{3,}|~{3,})[^\n]*\n[\s\S]*?^ *\1[^\n]*$/gm,
+        '',
+      )
       expect(prose, path).not.toMatch(/^\s*\|\s*(?:Port|Language)\s*\|/m)
-      expect(prose, path).not.toMatch(/^\s*[-*]\s+\*\*(?:Python|TypeScript|Rust|Go|Java|C#|\.NET|C\+\+|Swift|Ruby|Lua|Kotlin|Scala|F#)\*\*(?::|\s)/m)
+      expect(prose, path).not.toMatch(
+        /^\s*[-*]\s+\*\*(?:Python|TypeScript|Rust|Go|Java|C#|\.NET|C\+\+|Swift|Ruby|Lua|Kotlin|Scala|F#)\*\*(?::|\s)/m,
+      )
     }
   })
 
   it('links architecture files at the selected revision and preserves the old heading anchor', async () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'rs')
     const { content } = parseFrontmatter(readFileSync(`${contentRoot}docs/topics/architecture.md`, 'utf8'))
-    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
+    const renderer = await createMarkdownProcessor({
+      remarkPlugins: [remarkPortCode],
+      rehypePlugins: [rehypeApiLinks],
+      syntaxHighlight: false,
+    })
     const html = (await renderer.render(content)).code
     const inventory = JSON.parse(readFileSync(new URL('../src/data/api/rs.paths.json', import.meta.url), 'utf8'))
-    for (const file of ['formats.rs', 'snapshot.rs', 'hooks.rs', 'options.rs', 'server/settings.rs', 'session/settings.rs', 'window/settings.rs', 'pane/settings.rs']) {
-      expect(html).toContain(`href="https://github.com/${inventory.repo}/blob/${inventory.revision}/crates/libtmux/src/${file}"`)
+    for (const file of [
+      'formats.rs',
+      'snapshot.rs',
+      'hooks.rs',
+      'options.rs',
+      'server/settings.rs',
+      'session/settings.rs',
+      'window/settings.rs',
+      'pane/settings.rs',
+    ]) {
+      expect(html).toContain(
+        `href="https://github.com/${inventory.repo}/blob/${inventory.revision}/crates/libtmux/src/${file}"`,
+      )
     }
     for (const object of ['server', 'session', 'window', 'pane']) {
-      expect(html).toContain(`href="https://github.com/${inventory.repo}/tree/${inventory.revision}/crates/libtmux/src/${object}"`)
+      expect(html).toContain(
+        `href="https://github.com/${inventory.repo}/tree/${inventory.revision}/crates/libtmux/src/${object}"`,
+      )
       expect(html).toContain(`href="/rs/latest/reference/${object}-${object}/"`)
     }
     expect(html).toContain('id="a-generated-data-table-under-a-hand-written-surface"')
@@ -238,7 +328,9 @@ describe('port prose ownership', () => {
     const body = '[Task](/guides/sending-keys/)\n\n`[literal](/guides/x/)`\n\n```go\n// [literal](/guides/x/)\n```'
     const renderer = await createMarkdownProcessor({ rehypePlugins: [rehypeSiteRoot], syntaxHighlight: false })
     expect((await renderer.render(body)).code).toContain('href="/pr-42/en/go/v0.1/guides/sending-keys/"')
-    const markdown = resolvePortCode(body, 'go', undefined, (href: string) => proseHref(href, '/pr-42/en', 'go', 'v0.1'))
+    const markdown = resolvePortCode(body, 'go', undefined, (href: string) =>
+      proseHref(href, '/pr-42/en', 'go', 'v0.1'),
+    )
     expect(markdown).toContain('[Task](/pr-42/en/go/v0.1/guides/sending-keys/)')
     expect(markdown).toContain('`[literal](/guides/x/)`')
     expect(markdown).toContain('// [literal](/guides/x/)')
@@ -246,23 +338,26 @@ describe('port prose ownership', () => {
     expect(proseHref('/py/latest/', '/en', 'go')).toBe('/en/py/latest/')
   })
 
-  it.each(['pane-interaction', 'options-and-hooks'])('curates the %s article in HTML and machine-readable text', async (name) => {
-    const raw = readFileSync(new URL(`../src/content/docs/topics/${name}.md`, import.meta.url), 'utf8')
-    const body = raw.replace(/^---\n[\s\S]*?\n---\n/, '')
-    vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
-    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
-    const rendered = await renderer.render(body)
-    const markdown = resolvePortCode(body, 'go')
-    for (const output of [rendered.code, markdown]) {
-      expect(output).not.toMatch(/Python|TypeScript|Rust|Java|\.NET|C\+\+|Swift|pane\.send_keys|pane\.show_options/)
-      expect(output).toContain('ctx')
-    }
-    expect(rendered.metadata.headings.map((heading) => heading.text)).not.toContain('Go')
-    vi.stubEnv('LIBTMUX_DOCS_PORT', '')
-    const rootRenderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
-    const root = await rootRenderer.render(body)
-    expect(root.code).toContain('Python')
-    expect(root.code).toContain('language-python')
-    expect(root.code).toContain('language-go')
-  })
+  it.each(['pane-interaction', 'options-and-hooks'])(
+    'curates the %s article in HTML and machine-readable text',
+    async (name) => {
+      const raw = readFileSync(new URL(`../src/content/docs/topics/${name}.md`, import.meta.url), 'utf8')
+      const body = raw.replace(/^---\n[\s\S]*?\n---\n/, '')
+      vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
+      const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+      const rendered = await renderer.render(body)
+      const markdown = resolvePortCode(body, 'go')
+      for (const output of [rendered.code, markdown]) {
+        expect(output).not.toMatch(/Python|TypeScript|Rust|Java|\.NET|C\+\+|Swift|pane\.send_keys|pane\.show_options/)
+        expect(output).toContain('ctx')
+      }
+      expect(rendered.metadata.headings.map((heading) => heading.text)).not.toContain('Go')
+      vi.stubEnv('LIBTMUX_DOCS_PORT', '')
+      const rootRenderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], syntaxHighlight: false })
+      const root = await rootRenderer.render(body)
+      expect(root.code).toContain('Python')
+      expect(root.code).toContain('language-python')
+      expect(root.code).toContain('language-go')
+    },
+  )
 })
diff --git a/site/test/powershell-prose-links.test.ts b/site/test/powershell-prose-links.test.ts
index 102103d46..dcf87900b 100644
--- a/site/test/powershell-prose-links.test.ts
+++ b/site/test/powershell-prose-links.test.ts
@@ -15,7 +15,10 @@ const refs = (text: string, owner: ApiSymbol) => index.linkText(text, owner).fil
 describe('PowerShell native help references', () => {
   it('links plain result types and declared parameters without linking unknown names', () => {
     const owner = command('Invoke-TmuxCommand')
-    const result = refs('TmuxCommandResult returns objects. WhatIf performs no dispatch. ErrorAction Stop handles errors. MissingType stays plain.', owner)
+    const result = refs(
+      'TmuxCommandResult returns objects. WhatIf performs no dispatch. ErrorAction Stop handles errors. MissingType stays plain.',
+      owner,
+    )
     expect(result.map((span) => span.target)).toEqual(['TmuxCommandResult', 'WhatIf', 'ErrorAction'])
     expect(result[0].link?.href).toContain('/csharp/latest/reference/libtmux-tmuxcommandresult/')
     expect(result[1].link?.href).toBe(`${hrefFor(owner)}#LibTmux%5CInvoke-TmuxCommand.parameter.WhatIf`)
@@ -42,13 +45,20 @@ describe('PowerShell native help references', () => {
     expect(result.filter((span) => span.kind === 'link')).toEqual([
       { kind: 'link', text: 'WhatIf', href: 'https://example.com/explanation' },
     ])
-    expect(result.find((span) => span.kind === 'ref')?.link?.href).toContain('/csharp/latest/reference/libtmux-tmuxcommandresult/')
+    expect(result.find((span) => span.kind === 'ref')?.link?.href).toContain(
+      '/csharp/latest/reference/libtmux-tmuxcommandresult/',
+    )
   })
 
   it('links validation through its reflected full type and preserves unknown custom attributes', () => {
-    const parameter = structuredClone(command('Get-TmuxServer').signatures[0].params.find((param) => param.name === 'Server')!)
+    const parameter = structuredClone(
+      command('Get-TmuxServer').signatures[0].params.find((param) => param.name === 'Server')!,
+    )
     const target = builtinHref('powershell', 'System.Management.Automation.ValidateNotNullAttribute')!
-    expect(parameterBindingFacts(parameter)).toContainEqual({ label: 'Validation', value: '[`ValidateNotNull()`](' + target + ')' })
+    expect(parameterBindingFacts(parameter)).toContainEqual({
+      label: 'Validation',
+      value: '[`ValidateNotNull()`](' + target + ')',
+    })
     expect(parameterBindingText(parameter)).toContain('[`ValidateNotNull()`](' + target + ')')
     parameter.binding!.attributes = [{ type: 'Custom.ValidateNotNullAttribute', arguments: [], namedArguments: {} }]
     expect(parameterBindingFacts(parameter)).toContainEqual({ label: 'Validation', value: '`ValidateNotNull()`' })
@@ -56,17 +66,25 @@ describe('PowerShell native help references', () => {
 
   it('renders the real validation arguments as one linked code label, including bracketed regexes and sets', () => {
     let count = 0
-    for (const owner of model.symbols) for (const signature of owner.signatures) for (const parameter of signature.params) {
-      for (const fact of parameterBindingFacts(parameter).filter((fact) => fact.label === 'Validation' || fact.label === 'Completion')) {
-        const spans = index.linkText(fact.value, owner)
-        expect(spans, `${owner.name} ${parameter.name} ${fact.value}`).toHaveLength(1)
-        expect(spans[0]).toMatchObject({ kind: 'link', code: true })
-        count++
-      }
-    }
+    for (const owner of model.symbols)
+      for (const signature of owner.signatures)
+        for (const parameter of signature.params) {
+          for (const fact of parameterBindingFacts(parameter).filter(
+            (fact) => fact.label === 'Validation' || fact.label === 'Completion',
+          )) {
+            const spans = index.linkText(fact.value, owner)
+            expect(spans, `${owner.name} ${parameter.name} ${fact.value}`).toHaveLength(1)
+            expect(spans[0]).toMatchObject({ kind: 'link', code: true })
+            count++
+          }
+        }
     expect(count).toBeGreaterThan(100)
-    const parameter = structuredClone(command('Get-TmuxServer').signatures[0].params.find((param) => param.name === 'Server')!)
-    parameter.binding!.attributes = [{ type: 'System.Management.Automation.ValidatePatternAttribute', arguments: ['[`]'], namedArguments: {} }]
+    const parameter = structuredClone(
+      command('Get-TmuxServer').signatures[0].params.find((param) => param.name === 'Server')!,
+    )
+    parameter.binding!.attributes = [
+      { type: 'System.Management.Automation.ValidatePatternAttribute', arguments: ['[`]'], namedArguments: {} },
+    ]
     const fact = parameterBindingFacts(parameter).find((fact) => fact.label === 'Validation')!
     expect(index.linkText(fact.value)[0]).toMatchObject({ kind: 'link', code: true, text: 'ValidatePattern("[`]")' })
   })
@@ -74,7 +92,9 @@ describe('PowerShell native help references', () => {
   it('links the command-kind label to the glossary, and rejects unsafe Markdown destinations', () => {
     const owner = command('Get-TmuxServer')
     const kind = apiCommandFacts(owner).find((fact) => fact.label === 'Command type')!
-    expect(index.linkText(kind.value, owner)).toEqual([{ kind: 'link', text: 'cmdlet', code: true, href: apiGlossaryHref('cmdlet') }])
+    expect(index.linkText(kind.value, owner)).toEqual([
+      { kind: 'link', text: 'cmdlet', code: true, href: apiGlossaryHref('cmdlet') },
+    ])
     expect(tokenizeDoc('[Run](javascript:alert)', 'powershell').some((span) => span.kind === 'link')).toBe(false)
     expect(tokenizeDoc('[Go](//unverified.example)', 'powershell').some((span) => span.kind === 'link')).toBe(false)
   })
@@ -84,7 +104,9 @@ describe('PowerShell native help references', () => {
     const text = symbolMarkdown({ model, symbol: owner, index })
     expect(text).toContain('[`TmuxCommandResult`](')
     expect(text).toContain('[`WhatIf`](' + hrefFor(owner) + '#LibTmux%5CInvoke-TmuxCommand.parameter.WhatIf)')
-    const blocks = fromMarkdown(text).children.filter((node) => node.type === 'code').map((node) => node.value)
+    const blocks = fromMarkdown(text)
+      .children.filter((node) => node.type === 'code')
+      .map((node) => node.value)
     for (const example of owner.doc!.examples!) expect(blocks).toContain(example.code.trimEnd())
     const server = symbolMarkdown({ model, symbol: command('Get-TmuxServer'), index })
     expect(server).toContain('[`Tmux.ServerInspectionFailed`](https://github.com/')
diff --git a/site/test/powershell-signature.test.ts b/site/test/powershell-signature.test.ts
index 43cbd57be..91d687619 100644
--- a/site/test/powershell-signature.test.ts
+++ b/site/test/powershell-signature.test.ts
@@ -26,21 +26,34 @@ describe('PowerShell syntax layout', () => {
 
   it('preserves every native parameter set and its parameter, type and common-parameter links', () => {
     let count = 0
-    for (const symbol of model.symbols) for (const signature of symbol.signatures) {
-      if (!signature.raw) continue
-      const text = nativeSignatureText(symbol, signature, 'powershell')
-      expect(text.split('\n')[0], symbol.id).toBe(symbol.name)
-      expect(text.replace(/\s+/g, ' '), symbol.id).toBe(signature.raw.replace(/\s+/g, ' '))
-      const params = signature.params.filter((parameter) => !parameter.binding?.common)
-      const common = signature.params.some((parameter) => parameter.binding?.common) ? 1 : 0
-      expect(text.split('\n'), symbol.id).toHaveLength(1 + params.length + common)
-      expect(text.split('\n').slice(1).every((line) => /^ {4}\S/.test(line)), symbol.id).toBe(true)
-      const linked = (value: string) => index.linkType(value, symbol, signature).filter((span) => span.link).map((span) => ({ text: span.text, href: span.link!.href }))
-      expect(linked(text), symbol.id).toEqual(linked(signature.raw))
-      count++
-    }
+    for (const symbol of model.symbols)
+      for (const signature of symbol.signatures) {
+        if (!signature.raw) continue
+        const text = nativeSignatureText(symbol, signature, 'powershell')
+        expect(text.split('\n')[0], symbol.id).toBe(symbol.name)
+        expect(text.replace(/\s+/g, ' '), symbol.id).toBe(signature.raw.replace(/\s+/g, ' '))
+        const params = signature.params.filter((parameter) => !parameter.binding?.common)
+        const common = signature.params.some((parameter) => parameter.binding?.common) ? 1 : 0
+        expect(text.split('\n'), symbol.id).toHaveLength(1 + params.length + common)
+        expect(
+          text
+            .split('\n')
+            .slice(1)
+            .every((line) => /^ {4}\S/.test(line)),
+          symbol.id,
+        ).toBe(true)
+        const linked = (value: string) =>
+          index
+            .linkType(value, symbol, signature)
+            .filter((span) => span.link)
+            .map((span) => ({ text: span.text, href: span.link!.href }))
+        expect(linked(text), symbol.id).toEqual(linked(signature.raw))
+        count++
+      }
     expect(count).toBeGreaterThan(60)
-    const links = index.linkType(nativeSignatureText(invoke, invoke.signatures[0], 'powershell'), invoke, invoke.signatures[0]).filter((span) => span.link)
+    const links = index
+      .linkType(nativeSignatureText(invoke, invoke.signatures[0], 'powershell'), invoke, invoke.signatures[0])
+      .filter((span) => span.link)
     expect(links.find((span) => span.text === 'Arguments')?.link?.href).toContain('.parameter.Arguments')
     expect(links.find((span) => span.text === 'CommonParameters')?.link?.href).toContain('learn.microsoft.com')
   })
@@ -48,7 +61,9 @@ describe('PowerShell syntax layout', () => {
   it('exports the same multiline syntax to Markdown and leaves other native languages unchanged', () => {
     const text = nativeSignatureText(invoke, invoke.signatures[0], 'powershell')
     const markdown = symbolMarkdown({ model, symbol: invoke, index })
-    const code = fromMarkdown(markdown).children.filter((node) => node.type === 'code').map((node) => node.value)
+    const code = fromMarkdown(markdown)
+      .children.filter((node) => node.type === 'code')
+      .map((node) => node.value)
     expect(code).toContain(text)
     for (const language of ['csharp', 'fsharp', 'julia', 'c']) {
       expect(nativeSignatureText(invoke, invoke.signatures[0], language)).toBe(invoke.signatures[0].raw)
diff --git a/site/test/prefetch-lifecycle.test.ts b/site/test/prefetch-lifecycle.test.ts
index 6aa6a531c..86f904a8b 100644
--- a/site/test/prefetch-lifecycle.test.ts
+++ b/site/test/prefetch-lifecycle.test.ts
@@ -6,7 +6,10 @@ import { type HTMLAnchorElement, Window } from 'happy-dom'
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
 
 const require = createRequire(import.meta.url)
-const implementation = readFileSync(join(dirname(require.resolve('astro/package.json')), 'dist/prefetch/index.js'), 'utf8')
+const implementation = readFileSync(
+  join(dirname(require.resolve('astro/package.json')), 'dist/prefetch/index.js'),
+  'utf8',
+)
 // Exercise the installed dependency, including its pinned patch, without
 // loading the browser-only virtual modules used by the other strategies.
 const observerSource = implementation.slice(
@@ -29,13 +32,22 @@ function viewport() {
   let callback: (entries: Entry[], observer: Observer) => void
   class Observer {
     unobserve = vi.fn()
-    constructor(onIntersection: typeof callback) { callback = onIntersection }
+    constructor(onIntersection: typeof callback) {
+      callback = onIntersection
+    }
   }
   const prefetch = vi.fn()
   const observer = runInNewContext(`${observerSource}\ncreateViewportIntersectionObserver()`, {
-    IntersectionObserver: Observer, setTimeout, clearTimeout, prefetch,
+    IntersectionObserver: Observer,
+    setTimeout,
+    clearTimeout,
+    prefetch,
   }) as Observer
-  return { prefetch, observer, intersect: (target: HTMLAnchorElement, isIntersecting = true) => callback([{ target, isIntersecting }], observer) }
+  return {
+    prefetch,
+    observer,
+    intersect: (target: HTMLAnchorElement, isIntersecting = true) => callback([{ target, isIntersecting }], observer),
+  }
 }
 
 function link(href: string) {
@@ -47,12 +59,15 @@ function link(href: string) {
 
 describe('viewport prefetch across client navigation', () => {
   it('prefetches an attached link after its full viewport dwell', () => {
-    const v = viewport(), anchor = link('architecture/?example=one#source-layout')
+    const v = viewport(),
+      anchor = link('architecture/?example=one#source-layout')
     v.intersect(anchor)
     vi.advanceTimersByTime(299)
     expect(v.prefetch).not.toHaveBeenCalled()
     vi.advanceTimersByTime(1)
-    expect(v.prefetch).toHaveBeenCalledExactlyOnceWith('https://libtmux.org/en/swift/latest/topics/architecture/?example=one#source-layout')
+    expect(v.prefetch).toHaveBeenCalledExactlyOnceWith(
+      'https://libtmux.org/en/swift/latest/topics/architecture/?example=one#source-layout',
+    )
     expect(v.observer.unobserve).toHaveBeenCalledExactlyOnceWith(anchor)
     expect(vi.getTimerCount()).toBe(0)
   })
@@ -63,7 +78,9 @@ describe('viewport prefetch across client navigation', () => {
     ['/pr-42/ja/tmux/topics/', '../concepts/', '/pr-42/ja/tmux/topics/architecture/'],
   ])('drops a removed relative link from %s before reading its rebased URL', (source, href, destination) => {
     win.history.replaceState(null, '', source)
-    const v = viewport(), anchor = link(href), original = anchor.href
+    const v = viewport(),
+      anchor = link(href),
+      original = anchor.href
     v.intersect(anchor)
     anchor.remove()
     win.history.pushState(null, '', destination)
@@ -78,7 +95,8 @@ describe('viewport prefetch across client navigation', () => {
   })
 
   it('cancels a departed link and gives a returning link a new dwell', () => {
-    const v = viewport(), anchor = link('architecture/')
+    const v = viewport(),
+      anchor = link('architecture/')
     v.intersect(anchor)
     vi.advanceTimersByTime(150)
     v.intersect(anchor, false)
diff --git a/site/test/product-docs.test.ts b/site/test/product-docs.test.ts
index 2bcfd7eb0..4a170d109 100644
--- a/site/test/product-docs.test.ts
+++ b/site/test/product-docs.test.ts
@@ -2,7 +2,14 @@ import { existsSync, readFileSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { Window } from 'happy-dom'
 import { describe, expect, it } from 'vitest'
-import { PORTS, productAvailable, productDescription, productInDevelopment, workspaceOverviewNotice, type Port } from '../src/lib/ports'
+import {
+  PORTS,
+  productAvailable,
+  productDescription,
+  productInDevelopment,
+  workspaceOverviewNotice,
+  type Port,
+} from '../src/lib/ports'
 import { LANG_TO_PORT } from '../src/plugins/remark-port-code.mjs'
 import { SITE_BUILT, SITE_PREFIX, PREVIEW_PREFIX, productionPath, publishedPath, sitePath } from './site-root'
 import { MCP_REFERENCE, MCP_SECTIONS, mcpObjects } from '../src/lib/mcp-catalog'
@@ -30,7 +37,15 @@ interface DocsManifest {
   pages: { url: string; markdownUrl: string }[]
   ports: {
     slug: string
-    products: { slug: string; availability: string; inDevelopment: boolean; cli?: string | null; cliAvailability?: string | null; reference: string | null; protocol?: string | null }[]
+    products: {
+      slug: string
+      availability: string
+      inDevelopment: boolean
+      cli?: string | null
+      cliAvailability?: string | null
+      reference: string | null
+      protocol?: string | null
+    }[]
     documentation: { id: string; name: string; kind: string; availability: string; url: string; package?: string }[]
   }[]
 }
@@ -43,10 +58,16 @@ const urlFor = (path: string) => new URL(`/${SITE_PREFIX}${path}`, 'https://libt
 const productUrl = /\/(?:py|ruby|lua|powershell|julia|ts|rs|go|java|csharp|cxx|swift)\/[^/]+\/(?:mcp|workspace)(?:\/|$)/
 const nativeProductDocs = (port: string) => ['powershell', 'julia'].includes(port)
 const mcpClientSetupRoutes: Record<string, string[]> = {
-  py: ['mcp/guides'], ruby: ['mcp/guides/connect-client', 'mcp/source-guide'],
-  julia: ['mcp/source-guide'], ts: ['mcp/guides'], rs: ['mcp/guides/connect-client'],
-  go: ['mcp/guides/connect-client'], java: ['mcp/guides'], csharp: ['mcp/guides/connect-client'],
-  cxx: ['mcp/guides'], swift: ['mcp/guides'],
+  py: ['mcp/guides'],
+  ruby: ['mcp/guides/connect-client', 'mcp/source-guide'],
+  julia: ['mcp/source-guide'],
+  ts: ['mcp/guides'],
+  rs: ['mcp/guides/connect-client'],
+  go: ['mcp/guides/connect-client'],
+  java: ['mcp/guides'],
+  csharp: ['mcp/guides/connect-client'],
+  cxx: ['mcp/guides'],
+  swift: ['mcp/guides'],
 }
 
 it('advertises local native loaders while retaining their development status', () => {
@@ -55,13 +76,17 @@ it('advertises local native loaders while retaining their development status', (
   // py-vs-generic-local-CLI dichotomy this test covers.
   const native = (p: Port) => p.workspaceCliAvailability === 'local' || p.workspaceCliAvailability === 'published'
   for (const port of PORTS.filter((p) => p.slug === 'py' || native(p))) {
-    expect(port.workspaceCli).toBe(port.slug === 'julia' ? 'libtmux-workspace load' : native(port) ? 'tmux-workspace load' : 'tmuxp load')
+    expect(port.workspaceCli).toBe(
+      port.slug === 'julia' ? 'libtmux-workspace load' : native(port) ? 'tmux-workspace load' : 'tmuxp load',
+    )
     if (!native(port)) expect(port.workspaceCliAvailability).toBe('released')
     expect(productInDevelopment(port, 'workspace')).toBe(native(port))
     expect(productInDevelopment(port, 'mcp')).toBe(true)
     expect(productDescription(port, 'workspace')).not.toMatch(/worktree|checkpoint/)
     if (port.workspaceCliAvailability === 'local') {
-      expect(productDescription(port, 'workspace')).toContain(port.slug === 'julia' ? 'LibTmuxWorkspace' : 'Build the CLI from source')
+      expect(productDescription(port, 'workspace')).toContain(
+        port.slug === 'julia' ? 'LibTmuxWorkspace' : 'Build the CLI from source',
+      )
     }
     if (native(port)) expect(workspaceOverviewNotice(port)?.body).toContain(`\`${port.workspaceCli!.split(/\s+/)[0]}\``)
     if (port.workspaceCliAvailability === 'published') {
@@ -90,11 +115,18 @@ function pages(): ProductPage[] {
   return primaryPorts.flatMap((port) => {
     const supported = versions.ports[port.slug]?.filter((entry) => entry.supported) ?? []
     expect(supported.length, `${port.slug} has assembled supported versions`).toBeGreaterThan(0)
-    return supported.flatMap(({ slug: version }) => products.flatMap((product) =>
-      sectionsFor(port.slug, product).map((section) => ({
-        port: port.slug, name: port.name, version, product, section,
-        path: `${port.slug}/${version}/${product}/${section ? `${section}/` : ''}`,
-      }))))
+    return supported.flatMap(({ slug: version }) =>
+      products.flatMap((product) =>
+        sectionsFor(port.slug, product).map((section) => ({
+          port: port.slug,
+          name: port.name,
+          version,
+          product,
+          section,
+          path: `${port.slug}/${version}/${product}/${section ? `${section}/` : ''}`,
+        })),
+      ),
+    )
   })
 }
 
@@ -121,16 +153,21 @@ async function inspect<T>(path: string, check: (document: Window['document']) =>
 }
 
 const pageHtml = (path: string) => readFileSync(sitePath(path, 'index.html'), 'utf8')
-const tags = (html: string, name: string) => [...html.matchAll(new RegExp(`<${name}\\b[^>]*>`, 'gi'))].map((match) => match[0])
+const tags = (html: string, name: string) =>
+  [...html.matchAll(new RegExp(`<${name}\\b[^>]*>`, 'gi'))].map((match) => match[0])
 const attribute = (tag: string, name: string) => tag.match(new RegExp(`\\b${name}="([^"]*)"`, 'i'))?.[1]
-const text = (html: string) => html.replace(/<[^>]+>/g, '').replaceAll('&amp;', '&').replaceAll('&#39;', "'").trim()
+const text = (html: string) =>
+  html
+    .replace(/<[^>]+>/g, '')
+    .replaceAll('&amp;', '&')
+    .replaceAll('&#39;', "'")
+    .trim()
 
 function graph(document: Window['document']): StructuredEntry[] {
-  return [...document.querySelectorAll('script[type="application/ld+json"]')]
-    .flatMap((script) => {
-      const value = JSON.parse(script.textContent)
-      return value['@graph'] ?? [value]
-    })
+  return [...document.querySelectorAll('script[type="application/ld+json"]')].flatMap((script) => {
+    const value = JSON.parse(script.textContent)
+    return value['@graph'] ?? [value]
+  })
 }
 
 /**
@@ -153,7 +190,9 @@ async function redirectsTo(path: string, target: string): Promise<void> {
     expect(destination, `${path} redirect destination`).toBeDefined()
     expect(new URL(destination!, urlFor(path)).pathname, path).toBe(urlFor(target).pathname)
     expect(resolves(destination!, urlFor(path).href), `${path} redirect target exists`).toBe(true)
-    expect(document.querySelector('link[rel="canonical"]')?.getAttribute('href'), `${path} canonical`).toBe(urlFor(target).href)
+    expect(document.querySelector('link[rel="canonical"]')?.getAttribute('href'), `${path} canonical`).toBe(
+      urlFor(target).href,
+    )
     expect(document.querySelector('[data-pagefind-body]'), `${path} redirects are not searchable`).toBeNull()
   })
 }
@@ -172,7 +211,9 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
     await redirectsTo('powershell/latest/mcp/', 'powershell/latest/guides/mcp/')
     await inspect('powershell/latest/mcp/', (document) => {
       expect(document.querySelector('meta[name="robots"]')?.getAttribute('content')).toContain('noindex')
-      expect(document.querySelector('a[href]')?.getAttribute('href')).toBe(urlFor('powershell/latest/guides/mcp/').pathname)
+      expect(document.querySelector('a[href]')?.getAttribute('href')).toBe(
+        urlFor('powershell/latest/guides/mcp/').pathname,
+      )
     })
     await inspect('powershell/latest/guides/mcp/', (document) => {
       expect(document.querySelector('article h1')?.textContent).toBe('Using the .NET MCP server')
@@ -183,7 +224,9 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
 
   it('renders Lua Server in the public Server branch of its API sidebar', async () => {
     await inspect('lua/latest/reference/libtmux-server', (document) => {
-      const current = document.querySelector('[role="tree"] a[aria-current="page"][href$="/lua/latest/reference/libtmux-server/"]')
+      const current = document.querySelector(
+        '[role="tree"] a[aria-current="page"][href$="/lua/latest/reference/libtmux-server/"]',
+      )
       expect(current).toBeDefined()
       const ancestors: Array<NonNullable<typeof current>> = []
       let node = current?.closest('[role="treeitem"]')
@@ -204,62 +247,104 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
     })
   })
 
-  it.each(PORTS.filter((port) => !port.parentLibrary).map((port) => port.slug))('%s exposes supported products from latest homes and core navigation', async (port) => {
-    for (const section of ['', 'guides/', 'topics/']) {
-      const path = `${port}/latest/${section}`
-      await inspect(path, (document) => {
-        const navigation = document.querySelectorAll(section ? '[data-surface-picker]' : 'main')
-        expect(navigation.length, `${path} product entry points`).toBeGreaterThan(0)
-        for (const container of navigation) {
-          for (const product of products) {
-            const expected = urlFor(`${port}/latest/${product}/`).pathname
-            const link = [...container.querySelectorAll('a[href]')]
-              .find((entry) => new URL(entry.getAttribute('href')!, urlFor(path)).pathname === expected)
-            if (!productAvailable(PORTS.find((entry) => entry.slug === port)!, product)) {
-              expect(link, `${path} omits unavailable ${product}`).toBeUndefined()
-              continue
+  it.each(PORTS.filter((port) => !port.parentLibrary).map((port) => port.slug))(
+    '%s exposes supported products from latest homes and core navigation',
+    async (port) => {
+      for (const section of ['', 'guides/', 'topics/']) {
+        const path = `${port}/latest/${section}`
+        await inspect(path, (document) => {
+          const navigation = document.querySelectorAll(section ? '[data-surface-picker]' : 'main')
+          expect(navigation.length, `${path} product entry points`).toBeGreaterThan(0)
+          for (const container of navigation) {
+            for (const product of products) {
+              const expected = urlFor(`${port}/latest/${product}/`).pathname
+              const link = [...container.querySelectorAll('a[href]')].find(
+                (entry) => new URL(entry.getAttribute('href')!, urlFor(path)).pathname === expected,
+              )
+              if (
+                !productAvailable(
+                  PORTS.find((entry) => entry.slug === port)!,
+                  product,
+                )
+              ) {
+                expect(link, `${path} omits unavailable ${product}`).toBeUndefined()
+                continue
+              }
+              expect(link, `${path} links to ${expected}`).toBeDefined()
+              const label = section ? link!.closest('[data-surface-group]')!.textContent : link!.textContent
+              expect(label, `${path} product label`).toContain(product === 'workspace' ? 'Workspace Manager' : 'MCP')
+              expect(resolves(link!.getAttribute('href')!, urlFor(path).href), `${path} resolves ${expected}`).toBe(
+                true,
+              )
             }
-            expect(link, `${path} links to ${expected}`).toBeDefined()
-            const label = section ? link!.closest('[data-surface-group]')!.textContent : link!.textContent
-            expect(label, `${path} product label`).toContain(product === 'workspace' ? 'Workspace Manager' : 'MCP')
-            expect(resolves(link!.getAttribute('href')!, urlFor(path).href), `${path} resolves ${expected}`).toBe(true)
           }
-        }
-        if (section) {
-          expect(document.querySelector('[data-surface-picker] .surface-current strong')?.textContent).toBe('Core Library')
-          const current = document.querySelector('[data-surface-picker] [aria-current="location"]')
-          expect(current?.getAttribute('href'), `${path} selected section`).toBe(urlFor(path).pathname)
-          for (const nav of document.querySelectorAll('[data-section-navigation] nav')) {
-            expect([...nav.querySelectorAll('a[href]')].some((link) => products.some((product) =>
-              new URL(link.getAttribute('href')!, urlFor(path)).pathname.startsWith(urlFor(`${port}/latest/${product}/`).pathname))),
-              `${path} section sidebar excludes other apps`).toBe(false)
+          if (section) {
+            expect(document.querySelector('[data-surface-picker] .surface-current strong')?.textContent).toBe(
+              'Core Library',
+            )
+            const current = document.querySelector('[data-surface-picker] [aria-current="location"]')
+            expect(current?.getAttribute('href'), `${path} selected section`).toBe(urlFor(path).pathname)
+            for (const nav of document.querySelectorAll('[data-section-navigation] nav')) {
+              expect(
+                [...nav.querySelectorAll('a[href]')].some((link) =>
+                  products.some((product) =>
+                    new URL(link.getAttribute('href')!, urlFor(path)).pathname.startsWith(
+                      urlFor(`${port}/latest/${product}/`).pathname,
+                    ),
+                  ),
+                ),
+                `${path} section sidebar excludes other apps`,
+              ).toBe(false)
+            }
           }
-        }
-        const assets = [...document.querySelectorAll('script[src], link[rel="stylesheet"][href], link[rel="preload"][as="font"][href]')]
-          .map((asset) => asset.getAttribute('src') ?? asset.getAttribute('href')!)
-        expect(assets.length, `${path} linked assets`).toBeGreaterThan(0)
-        expect([...new Set(assets)].filter((href) => !resolves(href, urlFor(path).href)), `${path} missing assets`).toEqual([])
-      })
-    }
-  })
+          const assets = [
+            ...document.querySelectorAll(
+              'script[src], link[rel="stylesheet"][href], link[rel="preload"][as="font"][href]',
+            ),
+          ].map((asset) => asset.getAttribute('src') ?? asset.getAttribute('href')!)
+          expect(assets.length, `${path} linked assets`).toBeGreaterThan(0)
+          expect(
+            [...new Set(assets)].filter((href) => !resolves(href, urlFor(path).href)),
+            `${path} missing assets`,
+          ).toEqual([])
+        })
+      }
+    },
+  )
 
   it('surfaces Ruby Async and Lua runtime domains without presenting Lua products as available', async () => {
     const domains = [
-      { port: 'ruby', path: 'ruby/latest/', target: 'ruby/latest/guides/async/', label: 'Async', group: 'Companion packages' },
-      { port: 'lua', path: 'lua/latest/', target: 'lua/latest/guides/runtime/', label: 'luv and Neovim', group: 'Runtime adapters' },
+      {
+        port: 'ruby',
+        path: 'ruby/latest/',
+        target: 'ruby/latest/guides/async/',
+        label: 'Async',
+        group: 'Companion packages',
+      },
+      {
+        port: 'lua',
+        path: 'lua/latest/',
+        target: 'lua/latest/guides/runtime/',
+        label: 'luv and Neovim',
+        group: 'Runtime adapters',
+      },
     ]
     for (const domain of domains) {
       await inspect(domain.path, (document) => {
-        const link = [...document.querySelectorAll('main a[href]')]
-          .find((entry) => new URL(entry.getAttribute('href')!, urlFor(domain.path)).pathname === urlFor(domain.target).pathname)
+        const link = [...document.querySelectorAll('main a[href]')].find(
+          (entry) =>
+            new URL(entry.getAttribute('href')!, urlFor(domain.path)).pathname === urlFor(domain.target).pathname,
+        )
         expect(link, `${domain.path} ${domain.label} card`).toBeDefined()
         expect(link!.textContent, `${domain.path} ${domain.label} card label`).toContain(domain.label)
       })
       await inspect(domain.target, (document) => {
         const navigation = document.querySelector('[data-section-navigation] nav')
         expect(navigation, `${domain.target} port navigation`).toBeDefined()
-        const links = [...navigation!.querySelectorAll('a[href]')]
-          .filter((entry) => new URL(entry.getAttribute('href')!, urlFor(domain.target)).pathname === urlFor(domain.target).pathname)
+        const links = [...navigation!.querySelectorAll('a[href]')].filter(
+          (entry) =>
+            new URL(entry.getAttribute('href')!, urlFor(domain.target)).pathname === urlFor(domain.target).pathname,
+        )
         expect(links, `${domain.target} one visible domain destination`).toHaveLength(1)
         expect(links[0].textContent.trim()).toBe(domain.label)
         expect(links[0].getAttribute('aria-current')).toBe('page')
@@ -267,8 +352,10 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
     }
     await inspect('lua/latest/', (document) => {
       for (const product of products) {
-        expect(document.querySelector(`main a[href="${urlFor(`lua/latest/${product}/`).pathname}"]`),
-          `Lua landing omits unavailable ${product}`).toBeNull()
+        expect(
+          document.querySelector(`main a[href="${urlFor(`lua/latest/${product}/`).pathname}"]`),
+          `Lua landing omits unavailable ${product}`,
+        ).toBeNull()
       }
     })
   })
@@ -280,12 +367,19 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
       expect(article, page.path).toBeDefined()
       const headings1 = [...article!.matchAll(/<h1\b[^>]*>([\s\S]*?)<\/h1>/gi)].map((match) => match[1]!)
       expect(headings1, page.path).toHaveLength(1)
-      const sharedBrowse = page.product === 'workspace' && !['py', 'ruby'].includes(page.port)
-        && ['guides', 'examples'].includes(page.section)
+      const sharedBrowse =
+        page.product === 'workspace' &&
+        !['py', 'ruby'].includes(page.port) &&
+        ['guides', 'examples'].includes(page.section)
       if (nativeProductDocs(page.port)) {
-        const nativeTitles = page.product === 'workspace'
-          ? { '': 'Workspace Manager', 'source-guide': 'Workspace guide', reference: `${page.port === 'julia' ? 'LibTmuxWorkspace' : 'LibTmux.Workspace'} API reference` }
-          : { '': 'MCP server', 'source-guide': 'MCP server guide', reference: 'LibTmuxMCP API reference' }
+        const nativeTitles =
+          page.product === 'workspace'
+            ? {
+                '': 'Workspace Manager',
+                'source-guide': 'Workspace guide',
+                reference: `${page.port === 'julia' ? 'LibTmuxWorkspace' : 'LibTmux.Workspace'} API reference`,
+              }
+            : { '': 'MCP server', 'source-guide': 'MCP server guide', reference: 'LibTmuxMCP API reference' }
         expect(text(headings1[0]!), page.path).toBe(nativeTitles[page.section as keyof typeof nativeTitles])
       } else if (sharedBrowse) {
         expect(text(headings1[0]!), page.path).toBe(page.section === 'guides' ? 'Guides' : 'Examples')
@@ -300,22 +394,33 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
         const language = attribute(tags(block, 'pre')[0] ?? '', 'data-language')?.toLowerCase()
         const owner = language && LANG_TO_PORT[language]
         const caption = block.match(/<figcaption\b[^>]*>([\s\S]*?)<\/figcaption>/i)?.[1] ?? ''
-        const buildScript = page.port === 'java' && language === 'kotlin'
-          && ['settings.gradle.kts', 'build.gradle.kts'].includes(text(caption))
+        const buildScript =
+          page.port === 'java' &&
+          language === 'kotlin' &&
+          ['settings.gradle.kts', 'build.gradle.kts'].includes(text(caption))
         if (owner && !buildScript) expect(owner, `${page.path} foreign language example`).toBe(page.port)
       }
       const headings = [...article!.matchAll(/<h[23]\b[^>]*>([\s\S]*?)<\/h[23]>/gi)].map((match) => text(match[1]!))
       for (const other of PORTS.filter((port) => port.slug !== page.port)) {
         expect(headings, `${page.path} leaked ${other.name} section`).not.toContain(other.name)
       }
-      const hrefs = tags(html, 'a').map((tag) => attribute(tag, 'href')).filter((href): href is string => Boolean(href))
-      expect(hrefs.filter((href) => new URL(href, urlFor(page.path)).origin === 'https://libtmux.org'
-        && /\/ports\/(?:py|ruby|lua|ts|rs|go|java|csharp|cxx|swift)\//.test(href)),
-        `${page.path} storage identities in public links`).toEqual([])
+      const hrefs = tags(html, 'a')
+        .map((tag) => attribute(tag, 'href'))
+        .filter((href): href is string => Boolean(href))
+      expect(
+        hrefs.filter(
+          (href) =>
+            new URL(href, urlFor(page.path)).origin === 'https://libtmux.org' &&
+            /\/ports\/(?:py|ruby|lua|ts|rs|go|java|csharp|cxx|swift)\//.test(href),
+        ),
+        `${page.path} storage identities in public links`,
+      ).toEqual([])
       if (!page.section && page.version !== 'latest') {
         const home = pageHtml(`${page.port}/${page.version}/`)
         const main = home.match(/<main\b[^>]*>([\s\S]*?)<\/main>/i)?.[1] ?? ''
-        const entryPoints = tags(main, 'a').map((tag) => attribute(tag, 'href')).filter((href): href is string => Boolean(href))
+        const entryPoints = tags(main, 'a')
+          .map((tag) => attribute(tag, 'href'))
+          .filter((href): href is string => Boolean(href))
           .map((href) => new URL(href, urlFor(page.path)).pathname)
         expect(entryPoints, `${page.path} port-home entry point`).toContain(urlFor(page.path).pathname)
       }
@@ -344,119 +449,202 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
 
   it('opens a product overview with its install picker, then its section cards', async () => {
     let checked = 0
-    for (const page of pages().filter((entry) => entry.section === '')) await inspect(page.path, (document) => {
-      const install = document.querySelector('article h2#install')
-      if (!install) return
-      checked++
-      expect(document.querySelector('article h2')?.id, `${page.path} install is the first section`).toBe('install')
-      for (const card of document.querySelectorAll('article .doc-card')) {
-        expect(install.compareDocumentPosition(card) & 4, `${page.path} cards follow install`).toBeTruthy()
-      }
-    })
+    for (const page of pages().filter((entry) => entry.section === ''))
+      await inspect(page.path, (document) => {
+        const install = document.querySelector('article h2#install')
+        if (!install) return
+        checked++
+        expect(document.querySelector('article h2')?.id, `${page.path} install is the first section`).toBe('install')
+        for (const card of document.querySelectorAll('article .doc-card')) {
+          expect(install.compareDocumentPosition(card) & 4, `${page.path} cards follow install`).toBeTruthy()
+        }
+      })
     expect(checked, 'overviews with an install picker').toBeGreaterThan(0)
   })
 
-  it.each(PORTS.filter((port) => !port.parentLibrary))('$name distinguishes unfinished products and groups workspace internals', async (port) => {
-    for (const page of pages().filter((entry) => entry.port === port.slug)) await inspect(page.path, (document) => {
-      if (productInDevelopment(port, page.product)) developmentStatus(document, page.path)
-      const picker = document.querySelector('[data-surface-picker]')
-      if (!productAvailable(port, page.product)) {
-        expect(document.querySelector('article')!.textContent, `${page.path} availability`).toMatch(/not published|no published/i)
-        expect(picker?.querySelector('.surface-current strong')?.textContent, `${page.path} available app`).toBe('Core Library')
-        expect(picker?.querySelector('.surface-current small')?.textContent, `${page.path} available section`).toBe('Home')
-        const current = picker?.querySelectorAll('[aria-current="location"]')
-        expect(current, `${page.path} one available destination`).toHaveLength(1)
-        expect(current![0].getAttribute('href'), `${page.path} core overview`).toBe(urlFor(`${page.port}/${page.version}/`).pathname)
-        expect(resolves(current![0].getAttribute('href')!), `${page.path} core overview exists`).toBe(true)
-        const unavailable = urlFor(`${page.port}/${page.version}/${page.product}/`).pathname
-        const navigation = document.querySelectorAll('[data-surface-picker] a[href], [data-section-navigation] a[href], .doc-card[href]')
-        expect([...navigation].some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname.startsWith(unavailable)),
-          `${page.path} unavailable product omitted from navigation`).toBe(false)
-        return
-      }
-      const surface = page.product === 'mcp' ? 'MCP' : 'Workspace Manager'
-      const section = page.section === 'source-guide' ? 'guides' : page.section.split('/')[0] || 'home'
-      const sectionLabel = section === 'reference' ? 'API Reference' : section[0].toUpperCase() + section.slice(1)
-      expect(picker?.querySelector('.surface-current strong')?.textContent, `${page.path} current app`).toBe(surface)
-      expect(picker?.querySelector('.surface-current small')?.textContent, `${page.path} current section`).toBe(sectionLabel)
-      const current = picker?.querySelectorAll('[aria-current="location"]')
-      expect(current, `${page.path} one current section`).toHaveLength(1)
-      const sectionPath = `${page.port}/${page.version}/${page.product}/${page.section === 'source-guide' ? 'source-guide/' : section === 'home' ? '' : `${section}/`}`
-      expect(current![0].getAttribute('href'), `${page.path} current destination`).toBe(urlFor(sectionPath).pathname)
-      expect(resolves(current![0].getAttribute('href')!), `${page.path} current destination exists`).toBe(true)
-      const navigation = document.querySelectorAll('[data-section-navigation] nav')
-      expect(navigation.length, `${page.path} documentation navigation`).toBeGreaterThan(0)
-      for (const nav of navigation) {
-        expect(nav.getAttribute('aria-label'), page.path).toBe(`${surface}: ${sectionLabel}`)
-        const links = [...nav.querySelectorAll('a[href]')]
-        expect(links.length, `${page.path} current section pages`).toBeGreaterThan(0)
-        const sourceGuidePath = port.slug === 'ruby' && section === 'guides'
-          ? urlFor(`${page.port}/${page.version}/${page.product}/source-guide/`).pathname : undefined
-        if (sourceGuidePath) {
-          const guides = links.filter((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === sourceGuidePath)
-          expect(guides, `${page.path} native guide`).toHaveLength(1)
-          expect(guides[0].textContent.trim()).toBe(page.product === 'mcp' ? 'MCP server guide' : 'Workspace guide')
-        }
-        for (const link of links) {
-          const href = link.getAttribute('href')!
-          const path = new URL(href, urlFor(page.path)).pathname
-          if (section === 'reference') {
-            const prefix = urlFor(`${page.port}/${page.version}/${page.product}/`).pathname
-            expect(path.startsWith(prefix), `${page.path} reference stays in its app`).toBe(true)
-            expect(page.product === 'mcp' ? ['reference'] : ['reference', 'cli'], `${page.path} reference kinds`)
-              .toContain(path.slice(prefix.length).split('/')[0])
-          } else if (path !== sourceGuidePath) expect(path, `${page.path} scoped sidebar`).toContain(urlFor(sectionPath).pathname)
-          expect(resolves(href, urlFor(page.path).href), `${page.path} sidebar destination ${href}`).toBe(true)
-        }
-        if (page.product === 'mcp' && page.section === 'reference' && productAvailable(port, 'mcp')) {
-          for (const section of Object.keys(MCP_SECTIONS)) {
-            const target = urlFor(`${page.port}/${page.version}/mcp/${section}/`).pathname
-            const count = mcpObjects(page.port).filter((object) => object.section === section).length
-            expect([...picker!.querySelectorAll('a[href]')].some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === target),
-              `${page.path} ${section} picker destination`).toBe(count > 0)
-            if (!count) expect([...picker!.querySelectorAll('[aria-disabled="true"]')].some((entry) => entry.textContent.includes(MCP_SECTIONS[section as keyof typeof MCP_SECTIONS])),
-              `${page.path} empty ${section} disabled`).toBe(true)
-            expect(resolves(target, urlFor(page.path).href), target).toBe(true)
+  it.each(PORTS.filter((port) => !port.parentLibrary))(
+    '$name distinguishes unfinished products and groups workspace internals',
+    async (port) => {
+      for (const page of pages().filter((entry) => entry.port === port.slug))
+        await inspect(page.path, (document) => {
+          if (productInDevelopment(port, page.product)) developmentStatus(document, page.path)
+          const picker = document.querySelector('[data-surface-picker]')
+          if (!productAvailable(port, page.product)) {
+            expect(document.querySelector('article')!.textContent, `${page.path} availability`).toMatch(
+              /not published|no published/i,
+            )
+            expect(picker?.querySelector('.surface-current strong')?.textContent, `${page.path} available app`).toBe(
+              'Core Library',
+            )
+            expect(picker?.querySelector('.surface-current small')?.textContent, `${page.path} available section`).toBe(
+              'Home',
+            )
+            const current = picker?.querySelectorAll('[aria-current="location"]')
+            expect(current, `${page.path} one available destination`).toHaveLength(1)
+            expect(current![0].getAttribute('href'), `${page.path} core overview`).toBe(
+              urlFor(`${page.port}/${page.version}/`).pathname,
+            )
+            expect(resolves(current![0].getAttribute('href')!), `${page.path} core overview exists`).toBe(true)
+            const unavailable = urlFor(`${page.port}/${page.version}/${page.product}/`).pathname
+            const navigation = document.querySelectorAll(
+              '[data-surface-picker] a[href], [data-section-navigation] a[href], .doc-card[href]',
+            )
+            expect(
+              [...navigation].some((link) =>
+                new URL(link.getAttribute('href')!, urlFor(page.path)).pathname.startsWith(unavailable),
+              ),
+              `${page.path} unavailable product omitted from navigation`,
+            ).toBe(false)
+            return
           }
-        } else if (page.product === 'workspace' && section === 'internals' && productAvailable(port, 'workspace')) {
-          const hrefs = links
-            .map((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname)
-          for (const section of sectionsFor(page.port, 'workspace').filter((entry) => entry.startsWith('internals'))) {
-            expect(hrefs, `${page.path} ${section} navigation`).toContain(urlFor(`${page.port}/${page.version}/workspace/${section}/`).pathname)
+          const surface = page.product === 'mcp' ? 'MCP' : 'Workspace Manager'
+          const section = page.section === 'source-guide' ? 'guides' : page.section.split('/')[0] || 'home'
+          const sectionLabel = section === 'reference' ? 'API Reference' : section[0].toUpperCase() + section.slice(1)
+          expect(picker?.querySelector('.surface-current strong')?.textContent, `${page.path} current app`).toBe(
+            surface,
+          )
+          expect(picker?.querySelector('.surface-current small')?.textContent, `${page.path} current section`).toBe(
+            sectionLabel,
+          )
+          const current = picker?.querySelectorAll('[aria-current="location"]')
+          expect(current, `${page.path} one current section`).toHaveLength(1)
+          const sectionPath = `${page.port}/${page.version}/${page.product}/${page.section === 'source-guide' ? 'source-guide/' : section === 'home' ? '' : `${section}/`}`
+          expect(current![0].getAttribute('href'), `${page.path} current destination`).toBe(
+            urlFor(sectionPath).pathname,
+          )
+          expect(resolves(current![0].getAttribute('href')!), `${page.path} current destination exists`).toBe(true)
+          const navigation = document.querySelectorAll('[data-section-navigation] nav')
+          expect(navigation.length, `${page.path} documentation navigation`).toBeGreaterThan(0)
+          for (const nav of navigation) {
+            expect(nav.getAttribute('aria-label'), page.path).toBe(`${surface}: ${sectionLabel}`)
+            const links = [...nav.querySelectorAll('a[href]')]
+            expect(links.length, `${page.path} current section pages`).toBeGreaterThan(0)
+            const sourceGuidePath =
+              port.slug === 'ruby' && section === 'guides'
+                ? urlFor(`${page.port}/${page.version}/${page.product}/source-guide/`).pathname
+                : undefined
+            if (sourceGuidePath) {
+              const guides = links.filter(
+                (link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === sourceGuidePath,
+              )
+              expect(guides, `${page.path} native guide`).toHaveLength(1)
+              expect(guides[0].textContent.trim()).toBe(page.product === 'mcp' ? 'MCP server guide' : 'Workspace guide')
+            }
+            for (const link of links) {
+              const href = link.getAttribute('href')!
+              const path = new URL(href, urlFor(page.path)).pathname
+              if (section === 'reference') {
+                const prefix = urlFor(`${page.port}/${page.version}/${page.product}/`).pathname
+                expect(path.startsWith(prefix), `${page.path} reference stays in its app`).toBe(true)
+                expect(
+                  page.product === 'mcp' ? ['reference'] : ['reference', 'cli'],
+                  `${page.path} reference kinds`,
+                ).toContain(path.slice(prefix.length).split('/')[0])
+              } else if (path !== sourceGuidePath)
+                expect(path, `${page.path} scoped sidebar`).toContain(urlFor(sectionPath).pathname)
+              expect(resolves(href, urlFor(page.path).href), `${page.path} sidebar destination ${href}`).toBe(true)
+            }
+            if (page.product === 'mcp' && page.section === 'reference' && productAvailable(port, 'mcp')) {
+              for (const section of Object.keys(MCP_SECTIONS)) {
+                const target = urlFor(`${page.port}/${page.version}/mcp/${section}/`).pathname
+                const count = mcpObjects(page.port).filter((object) => object.section === section).length
+                expect(
+                  [...picker!.querySelectorAll('a[href]')].some(
+                    (link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === target,
+                  ),
+                  `${page.path} ${section} picker destination`,
+                ).toBe(count > 0)
+                if (!count)
+                  expect(
+                    [...picker!.querySelectorAll('[aria-disabled="true"]')].some((entry) =>
+                      entry.textContent.includes(MCP_SECTIONS[section as keyof typeof MCP_SECTIONS]),
+                    ),
+                    `${page.path} empty ${section} disabled`,
+                  ).toBe(true)
+                expect(resolves(target, urlFor(page.path).href), target).toBe(true)
+              }
+            } else if (page.product === 'workspace' && section === 'internals' && productAvailable(port, 'workspace')) {
+              const hrefs = links.map((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname)
+              for (const section of sectionsFor(page.port, 'workspace').filter((entry) =>
+                entry.startsWith('internals'),
+              )) {
+                expect(hrefs, `${page.path} ${section} navigation`).toContain(
+                  urlFor(`${page.port}/${page.version}/workspace/${section}/`).pathname,
+                )
+              }
+            }
           }
-        }
-      }
-      if (page.product === 'workspace' && page.port !== 'ruby' && !nativeProductDocs(page.port) && productAvailable(port, 'workspace')) {
-        expect([...picker!.querySelectorAll('a[href]')].some((link) => link.getAttribute('href') === urlFor(`${page.port}/${page.version}/workspace/internals/`).pathname),
-          `${page.path} Internals remains reachable in the picker`).toBe(true)
-      }
-      if (page.product === 'workspace' && port.workspaceCli && productInDevelopment(port, 'workspace') && !page.section) {
-        const status = [...document.querySelectorAll('[role="note"]')]
-          .map((note) => note.textContent ?? '')
-          .find((text) => /in development/i.test(text))
-        expect(status, `${page.path} development status`).toBeDefined()
-        const article = document.querySelector('article')!.textContent
-        if (port.workspaceCliAvailability === 'local') expect(article, `${page.path} source installation`).toContain('from the source revision in the installation guide')
-        expect(article, `${page.path} native CLI`).toContain(port.workspaceCli.split(/\s+/)[0])
-        expect(article.match(/is in development/gi), `${page.path} states maturity once`).toHaveLength(1)
-        const links = [...document.querySelectorAll('article a[href]')]
-        const installation = nativeProductDocs(page.port) ? 'source-guide' : 'guides/installation'
-        expect(links.some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === urlFor(`${page.port}/${page.version}/workspace/${installation}/`).pathname), `${page.path} native installation`).toBe(true)
-        expect(links.some((link) => link.getAttribute('href') === 'https://tmuxp.git-pull.com/'), `${page.path} foreign installation`).toBe(false)
-      }
-    })
-  })
+          if (
+            page.product === 'workspace' &&
+            page.port !== 'ruby' &&
+            !nativeProductDocs(page.port) &&
+            productAvailable(port, 'workspace')
+          ) {
+            expect(
+              [...picker!.querySelectorAll('a[href]')].some(
+                (link) =>
+                  link.getAttribute('href') === urlFor(`${page.port}/${page.version}/workspace/internals/`).pathname,
+              ),
+              `${page.path} Internals remains reachable in the picker`,
+            ).toBe(true)
+          }
+          if (
+            page.product === 'workspace' &&
+            port.workspaceCli &&
+            productInDevelopment(port, 'workspace') &&
+            !page.section
+          ) {
+            const status = [...document.querySelectorAll('[role="note"]')]
+              .map((note) => note.textContent ?? '')
+              .find((text) => /in development/i.test(text))
+            expect(status, `${page.path} development status`).toBeDefined()
+            const article = document.querySelector('article')!.textContent
+            if (port.workspaceCliAvailability === 'local')
+              expect(article, `${page.path} source installation`).toContain(
+                'from the source revision in the installation guide',
+              )
+            expect(article, `${page.path} native CLI`).toContain(port.workspaceCli.split(/\s+/)[0])
+            expect(article.match(/is in development/gi), `${page.path} states maturity once`).toHaveLength(1)
+            const links = [...document.querySelectorAll('article a[href]')]
+            const installation = nativeProductDocs(page.port) ? 'source-guide' : 'guides/installation'
+            expect(
+              links.some(
+                (link) =>
+                  new URL(link.getAttribute('href')!, urlFor(page.path)).pathname ===
+                  urlFor(`${page.port}/${page.version}/workspace/${installation}/`).pathname,
+              ),
+              `${page.path} native installation`,
+            ).toBe(true)
+            expect(
+              links.some((link) => link.getAttribute('href') === 'https://tmuxp.git-pull.com/'),
+              `${page.path} foreign installation`,
+            ).toBe(false)
+          }
+        })
+    },
+  )
 
   it('links generated declarations and schema-bearing tools inside their product', async () => {
-    for (const page of pages().filter((entry) => entry.section === 'reference'
-      && productAvailable(PORTS.find((port) => port.slug === entry.port)!, entry.product))) {
+    for (const page of pages().filter(
+      (entry) =>
+        entry.section === 'reference' &&
+        productAvailable(
+          PORTS.find((port) => port.slug === entry.port)!,
+          entry.product,
+        ),
+    )) {
       const prefix = `${page.port}/${page.version}/${page.product}/${page.section}/`
       const declarations = await inspect(page.path, (document) =>
-        [...document.querySelectorAll('[aria-labelledby="generated-api"] a[href]')]
-          .map((link) => ({ href: link.getAttribute('href')!, title: link.textContent.trim() })))
+        [...document.querySelectorAll('[aria-labelledby="generated-api"] a[href]')].map((link) => ({
+          href: link.getAttribute('href')!,
+          title: link.textContent.trim(),
+        })),
+      )
       expect(declarations.length, `${page.path} generated declarations`).toBeGreaterThan(0)
       for (const declaration of declarations) {
-        expect(new URL(declaration.href, urlFor(page.path)).pathname).toMatch(new RegExp(`^/${SITE_PREFIX}${prefix}[^/]+/$`))
+        expect(new URL(declaration.href, urlFor(page.path)).pathname).toMatch(
+          new RegExp(`^/${SITE_PREFIX}${prefix}[^/]+/$`),
+        )
         expect(resolves(declaration.href, urlFor(page.path).href), declaration.href).toBe(true)
       }
       const sample = declarations[0]
@@ -465,20 +653,29 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
         expect(document.querySelector('article h1')?.textContent).toBe(sample.title)
         expect(graph(document).some((entry) => entry['@type'] === 'APIReference')).toBe(true)
         if (page.product === 'workspace') {
-          const labels = [...document.querySelectorAll('nav[aria-label="Breadcrumb"] a, nav[aria-label="Breadcrumb"] [aria-current="page"]')]
-            .map((item) => item.textContent.trim())
+          const labels = [
+            ...document.querySelectorAll(
+              'nav[aria-label="Breadcrumb"] a, nav[aria-label="Breadcrumb"] [aria-current="page"]',
+            ),
+          ].map((item) => item.textContent.trim())
           // The reference is a section of the product, so its pages hang
           // directly off it: no Internals level in between any more.
           expect(labels.slice(0, 2)).toEqual([page.name, 'Workspace Manager'])
           expect(labels.at(-1)).toBe(sample.title)
-          expect(graph(document).find((entry) => entry['@type'] === 'BreadcrumbList')?.itemListElement?.map((item) => item.name)).toEqual(labels)
+          expect(
+            graph(document)
+              .find((entry) => entry['@type'] === 'BreadcrumbList')
+              ?.itemListElement?.map((item) => item.name),
+          ).toEqual(labels)
         } else developmentStatus(document, samplePath)
       })
       if (page.product !== 'mcp') continue
       const toolsPath = `${page.port}/${page.version}/mcp/tools/`
       const tools = await inspect(toolsPath, (document) => {
         developmentStatus(document, toolsPath)
-        return [...document.querySelectorAll('.api-index-card[id] > .api-index-card__link[href]')].map((link) => link.getAttribute('href')!)
+        return [...document.querySelectorAll('.api-index-card[id] > .api-index-card__link[href]')].map((link) =>
+          link.getAttribute('href')!,
+        )
       })
       expect(tools.length, `${toolsPath} protocol tools`).toBeGreaterThan(0)
       for (const href of tools) {
@@ -488,8 +685,9 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
       const toolPath = new URL(tools[0], urlFor(toolsPath)).pathname.slice(SITE_PREFIX.length + 1)
       await inspect(toolPath, (document) => {
         developmentStatus(document, toolPath)
-        const input = [...document.querySelectorAll('details')]
-          .find((detail) => detail.querySelector('summary')?.textContent === 'Input schema')
+        const input = [...document.querySelectorAll('details')].find(
+          (detail) => detail.querySelector('summary')?.textContent === 'Input schema',
+        )
         expect(input, `${toolPath} input schema`).toBeDefined()
         expect(() => JSON.parse(input!.querySelector('code')!.textContent)).not.toThrow()
         expect(document.querySelector('.api-reference-content h1 code')?.textContent).toBe(toolPath.split('/').at(-2))
@@ -497,101 +695,156 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
     }
   })
 
-  it.each(Object.keys(MCP_REFERENCE))('%s uses the shared reference browser for all advertised protocol objects', async (port) => {
-    const version = manifest().defaultVersion[port]
-    expect(version, `${port} default version`).toBeDefined()
-    for (const [section, label] of Object.entries(MCP_SECTIONS)) {
-      const index = `${port}/${version}/mcp/${section}/`
-      const objects = mcpObjects(port).filter((object) => object.section === section)
-      await inspect(index, (document) => {
-        expect(document.querySelector('main.api-reference-layout'), `${index} shared layout`).not.toBeNull()
-        expect(document.querySelector('#api-nav #api-symbol-search'), `${index} searchable tree`).not.toBeNull()
-        expect(document.querySelector('.api-reference-content h1')?.textContent).toBe(label)
-        const links = [...document.querySelectorAll('.api-index-card[id] > .api-index-card__link[href]')]
-        expect(links.map((link) => new URL(link.getAttribute('href')!, urlFor(index)).pathname).sort())
-          .toEqual(objects.map((object) => urlFor(`${port}/${version}/${object.path}/`).pathname).sort())
-        if (!objects.length) expect(document.querySelector('.api-reference-content')?.textContent).toContain(`does not advertise ${section}`)
-      })
-      for (const object of objects) await inspect(`${port}/${version}/${object.path}/`, (document) => {
-        expect(document.querySelector('main.api-reference-layout--symbol'), object.id).not.toBeNull()
-        expect(document.querySelector('.api-reference-content h1 code')?.textContent).toBe(object.name)
-        const declaration = document.getElementById(object.id)
-        expect(declaration?.getAttribute('data-domain')).toBe('mcp')
-        expect(declaration?.getAttribute('data-objtype')).toBe(object.kind)
-        expect(document.querySelector('nav.api-section-links'), `${object.id} section navigation`).not.toBeNull()
-        for (const suffix of ['parameters', 'result', 'schemas']) expect(document.getElementById(`${object.id}.${suffix}`), `${object.id}.${suffix}`).not.toBeNull()
-        const contract = [...document.querySelectorAll('details')].find((detail) => detail.querySelector('summary')?.textContent === (object.tool ? 'Input schema' : 'Registration'))!
-        expect(JSON.parse(contract.querySelector('code')!.textContent)).toEqual(object.tool?.inputSchema ?? object.item)
-      })
-    }
-  })
+  it.each(Object.keys(MCP_REFERENCE))(
+    '%s uses the shared reference browser for all advertised protocol objects',
+    async (port) => {
+      const version = manifest().defaultVersion[port]
+      expect(version, `${port} default version`).toBeDefined()
+      for (const [section, label] of Object.entries(MCP_SECTIONS)) {
+        const index = `${port}/${version}/mcp/${section}/`
+        const objects = mcpObjects(port).filter((object) => object.section === section)
+        await inspect(index, (document) => {
+          expect(document.querySelector('main.api-reference-layout'), `${index} shared layout`).not.toBeNull()
+          expect(document.querySelector('#api-nav #api-symbol-search'), `${index} searchable tree`).not.toBeNull()
+          expect(document.querySelector('.api-reference-content h1')?.textContent).toBe(label)
+          const links = [...document.querySelectorAll('.api-index-card[id] > .api-index-card__link[href]')]
+          expect(links.map((link) => new URL(link.getAttribute('href')!, urlFor(index)).pathname).sort()).toEqual(
+            objects.map((object) => urlFor(`${port}/${version}/${object.path}/`).pathname).sort(),
+          )
+          if (!objects.length)
+            expect(document.querySelector('.api-reference-content')?.textContent).toContain(
+              `does not advertise ${section}`,
+            )
+        })
+        for (const object of objects)
+          await inspect(`${port}/${version}/${object.path}/`, (document) => {
+            expect(document.querySelector('main.api-reference-layout--symbol'), object.id).not.toBeNull()
+            expect(document.querySelector('.api-reference-content h1 code')?.textContent).toBe(object.name)
+            const declaration = document.getElementById(object.id)
+            expect(declaration?.getAttribute('data-domain')).toBe('mcp')
+            expect(declaration?.getAttribute('data-objtype')).toBe(object.kind)
+            expect(document.querySelector('nav.api-section-links'), `${object.id} section navigation`).not.toBeNull()
+            for (const suffix of ['parameters', 'result', 'schemas'])
+              expect(document.getElementById(`${object.id}.${suffix}`), `${object.id}.${suffix}`).not.toBeNull()
+            const contract = [...document.querySelectorAll('details')].find(
+              (detail) =>
+                detail.querySelector('summary')?.textContent === (object.tool ? 'Input schema' : 'Registration'),
+            )!
+            expect(JSON.parse(contract.querySelector('code')!.textContent)).toEqual(
+              object.tool?.inputSchema ?? object.item,
+            )
+          })
+      }
+    },
+  )
 
-  it.each(primaryPorts.map((port) => port.slug))('switches to equivalent sections and the tmux documentation for %s', async (slug) => {
-    const defaults = manifest().defaultVersion
-    for (const page of pages().filter((entry) => entry.port === slug && entry.section !== 'source-guide')) await inspect(page.path, (document) => {
-      const links = [...document.querySelectorAll('[data-page-port-switcher] a[data-port][href]')]
-      const tmux = document.querySelector('[data-page-port-switcher] .tmux-area a[href]')
-      expect(tmux?.getAttribute('href'), `${page.path} tmux destination`).toBe(urlFor('tmux/').pathname)
-      const clientSetup = page.product === 'mcp' && page.section === 'guides'
-        && ['py', 'ts', 'java', 'cxx', 'swift'].includes(page.port)
-      const counterparts = clientSetup ? new Map(Object.entries(mcpClientSetupRoutes).map(([port, routes]) => [port,
-        routes.map((route) => urlFor(`${port}/${port === page.port ? page.version : defaults[port]}/${route}/`).pathname),
-      ])) : new Map(PORTS.flatMap((port) => {
-        const section = page.section
-        if (port.slug === 'powershell' && page.product === 'mcp' && !section) {
-          return [[port.slug, [urlFor(`${port.slug}/${defaults[port.slug]}/mcp/`).pathname]]]
-        }
-        if (port.parentLibrary || !sectionsFor(port.slug, page.product).includes(section)) return []
-        const version = port.slug === page.port ? page.version : defaults[port.slug]
-        return [[port.slug, [urlFor(`${port.slug}/${version}/${page.product}/${section ? `${section}/` : ''}`).pathname]]]
-      }))
-      expect(links.length, `${page.path} port counterparts`).toBe([...counterparts.values()].flat().length)
-      for (const port of PORTS) {
-        const expected = counterparts.get(port.slug)
-        if (expected) {
-          for (const href of expected) {
-            expect(links.some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === href),
-              `${page.path} counterpart ${href}`).toBe(true)
-            expect(resolves(href), `${page.path} counterpart exists at ${href}`).toBe(true)
+  it.each(primaryPorts.map((port) => port.slug))(
+    'switches to equivalent sections and the tmux documentation for %s',
+    async (slug) => {
+      const defaults = manifest().defaultVersion
+      for (const page of pages().filter((entry) => entry.port === slug && entry.section !== 'source-guide'))
+        await inspect(page.path, (document) => {
+          const links = [...document.querySelectorAll('[data-page-port-switcher] a[data-port][href]')]
+          const tmux = document.querySelector('[data-page-port-switcher] .tmux-area a[href]')
+          expect(tmux?.getAttribute('href'), `${page.path} tmux destination`).toBe(urlFor('tmux/').pathname)
+          const clientSetup =
+            page.product === 'mcp' &&
+            page.section === 'guides' &&
+            ['py', 'ts', 'java', 'cxx', 'swift'].includes(page.port)
+          const counterparts = clientSetup
+            ? new Map(
+                Object.entries(mcpClientSetupRoutes).map(([port, routes]) => [
+                  port,
+                  routes.map(
+                    (route) =>
+                      urlFor(`${port}/${port === page.port ? page.version : defaults[port]}/${route}/`).pathname,
+                  ),
+                ]),
+              )
+            : new Map(
+                PORTS.flatMap((port) => {
+                  const section = page.section
+                  if (port.slug === 'powershell' && page.product === 'mcp' && !section) {
+                    return [[port.slug, [urlFor(`${port.slug}/${defaults[port.slug]}/mcp/`).pathname]]]
+                  }
+                  if (port.parentLibrary || !sectionsFor(port.slug, page.product).includes(section)) return []
+                  const version = port.slug === page.port ? page.version : defaults[port.slug]
+                  return [
+                    [
+                      port.slug,
+                      [urlFor(`${port.slug}/${version}/${page.product}/${section ? `${section}/` : ''}`).pathname],
+                    ],
+                  ]
+                }),
+              )
+          expect(links.length, `${page.path} port counterparts`).toBe([...counterparts.values()].flat().length)
+          for (const port of PORTS) {
+            const expected = counterparts.get(port.slug)
+            if (expected) {
+              for (const href of expected) {
+                expect(
+                  links.some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname === href),
+                  `${page.path} counterpart ${href}`,
+                ).toBe(true)
+                expect(resolves(href), `${page.path} counterpart exists at ${href}`).toBe(true)
+              }
+            } else {
+              const unavailable = document.querySelector(
+                `[data-page-port-switcher] .doc-picker-option--unmatched[data-port="${port.slug}"]`,
+              )
+              expect(unavailable?.textContent, `${page.path} unavailable ${port.name}`).toContain('No matching page')
+              const home = unavailable?.querySelector('a[data-picker-home]')?.getAttribute('href')
+              expect(home, `${page.path} ${port.name} home exit`).toBeDefined()
+              expect(resolves(home!, urlFor(page.path).href), `${page.path} ${port.name} home exists`).toBe(true)
+            }
           }
-        } else {
-          const unavailable = document.querySelector(`[data-page-port-switcher] .doc-picker-option--unmatched[data-port="${port.slug}"]`)
-          expect(unavailable?.textContent, `${page.path} unavailable ${port.name}`).toContain('No matching page')
-          const home = unavailable?.querySelector('a[data-picker-home]')?.getAttribute('href')
-          expect(home, `${page.path} ${port.name} home exit`).toBeDefined()
-          expect(resolves(home!, urlFor(page.path).href), `${page.path} ${port.name} home exists`).toBe(true)
-        }
-      }
-    })
-  })
+        })
+    },
+  )
 
-  it.each(primaryPorts.map((port) => port.slug))('matches visible breadcrumbs to structured data for %s', async (slug) => {
-    for (const page of pages().filter((entry) => entry.port === slug)) await inspect(page.path, (document) => {
-      const crumb = document.querySelector('nav[aria-label="Breadcrumb"]')!
-      expect(crumb, page.path).not.toBeNull()
-      const labels = [...crumb.querySelectorAll('a, [aria-current="page"]')].map((item) => item.textContent.trim())
-      const structured = graph(document).find((entry) => entry['@type'] === 'BreadcrumbList')
-      expect(structured?.itemListElement?.map((item) => item.name), page.path).toEqual(labels)
-      expect(labels[0]).toBe(page.name)
-      expect(labels[1]).toBe(page.product === 'mcp' ? 'MCP' : 'Workspace Manager')
-      if (page.section.startsWith('internals/')) expect(labels[2]).toBe('Internals')
-      for (const item of structured!.itemListElement!) expect(resolves(item.item), item.item).toBe(true)
-      expect(new URL(structured!.itemListElement!.at(-1)!.item).pathname).toBe(urlFor(page.path).pathname)
-    })
-  })
+  it.each(primaryPorts.map((port) => port.slug))(
+    'matches visible breadcrumbs to structured data for %s',
+    async (slug) => {
+      for (const page of pages().filter((entry) => entry.port === slug))
+        await inspect(page.path, (document) => {
+          const crumb = document.querySelector('nav[aria-label="Breadcrumb"]')!
+          expect(crumb, page.path).not.toBeNull()
+          const labels = [...crumb.querySelectorAll('a, [aria-current="page"]')].map((item) => item.textContent.trim())
+          const structured = graph(document).find((entry) => entry['@type'] === 'BreadcrumbList')
+          expect(
+            structured?.itemListElement?.map((item) => item.name),
+            page.path,
+          ).toEqual(labels)
+          expect(labels[0]).toBe(page.name)
+          expect(labels[1]).toBe(page.product === 'mcp' ? 'MCP' : 'Workspace Manager')
+          if (page.section.startsWith('internals/')) expect(labels[2]).toBe('Internals')
+          for (const item of structured!.itemListElement!) expect(resolves(item.item), item.item).toBe(true)
+          expect(new URL(structured!.itemListElement!.at(-1)!.item).pathname).toBe(urlFor(page.path).pathname)
+        })
+    },
+  )
 
   it.each([
-    ['powershell', 'workspace'], ['julia', 'workspace'], ['julia', 'mcp'],
+    ['powershell', 'workspace'],
+    ['julia', 'workspace'],
+    ['julia', 'mcp'],
   ])('switches from the native %s %s source guide to verified task counterparts', async (port, product) => {
     const defaults = manifest().defaultVersion
-    const routes: Record<string, string[]> = product === 'workspace' ? {
-      ruby: ['workspace/source-guide'], powershell: ['workspace/source-guide'], julia: ['workspace/source-guide'],
-    } : mcpClientSetupRoutes
+    const routes: Record<string, string[]> =
+      product === 'workspace'
+        ? {
+            ruby: ['workspace/source-guide'],
+            powershell: ['workspace/source-guide'],
+            julia: ['workspace/source-guide'],
+          }
+        : mcpClientSetupRoutes
     const path = `${port}/${defaults[port]}/${product}/source-guide/`
     await inspect(path, (document) => {
       const links = [...document.querySelectorAll('[data-page-port-switcher] a[data-port][href]')]
       expect(links.map((link) => new URL(link.getAttribute('href')!, urlFor(path)).pathname).sort()).toEqual(
-        Object.entries(routes).flatMap(([slug, paths]) => paths.map((route) => urlFor(`${slug}/${defaults[slug]}/${route}/`).pathname)).sort(),
+        Object.entries(routes)
+          .flatMap(([slug, paths]) => paths.map((route) => urlFor(`${slug}/${defaults[slug]}/${route}/`).pathname))
+          .sort(),
       )
       for (const link of links) expect(resolves(link.getAttribute('href')!, urlFor(path).href)).toBe(true)
     })
@@ -600,35 +853,54 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
   it('redirects legacy workspace Topics without replacing Python CLI docs', async () => {
     // Guides and Examples now browse the native CLI documentation. The old
     // Topics route still redirects to the builder's internal topics.
-    for (const page of pages().filter((entry) => entry.product === 'workspace'
-      && entry.port !== 'py' && entry.section === 'internals/topics')) {
+    for (const page of pages().filter(
+      (entry) => entry.product === 'workspace' && entry.port !== 'py' && entry.section === 'internals/topics',
+    )) {
       await redirectsTo(page.path.replace('/internals/', '/'), page.path)
     }
-    for (const page of pages().filter((entry) => entry.port === 'py' && entry.product === 'workspace'
-      && ['guides', 'examples'].includes(entry.section))) await inspect(page.path, (document) => {
-      expect(document.querySelector('meta[http-equiv="refresh"]'), `${page.path} remains a user guide`).toBeNull()
-      expect(document.querySelector('article')!.textContent, `${page.path} CLI usage`).toContain('tmuxp load')
-    })
+    for (const page of pages().filter(
+      (entry) => entry.port === 'py' && entry.product === 'workspace' && ['guides', 'examples'].includes(entry.section),
+    ))
+      await inspect(page.path, (document) => {
+        expect(document.querySelector('meta[http-equiv="refresh"]'), `${page.path} remains a user guide`).toBeNull()
+        expect(document.querySelector('article')!.textContent, `${page.path} CLI usage`).toContain('tmuxp load')
+      })
   })
 
-  it.each(PORTS.filter((port) => !port.parentLibrary && !['py', 'ruby', 'lua', 'powershell', 'julia'].includes(port.slug)))
-    ('$name publishes workspace Guides and Examples browse pages', async (port) => {
-    for (const page of pages().filter((entry) => entry.product === 'workspace'
-      && entry.port === port.slug && ['guides', 'examples'].includes(entry.section))) await inspect(page.path, (document) => {
-      expect(document.querySelector('meta[http-equiv="refresh"]'), `${page.path} is a browse page`).toBeNull()
-      expect(document.querySelector('[data-pagefind-body]'), `${page.path} is searchable`).not.toBeNull()
-      expect(document.querySelector('h1')?.textContent?.trim(), page.path).toBe(page.section === 'guides' ? 'Guides' : 'Examples')
-      expect(document.querySelector('.surface-picker-footer')?.textContent?.trim(), page.path).toBe(`${page.name} · ${page.version} · en`)
-      const cards = [...document.querySelectorAll('article .doc-card[href]')]
-      expect(cards.length, `${page.path} published tasks`).toBeGreaterThan(0)
-      for (const card of cards) {
-        const href = card.getAttribute('href')!
-        expect(resolves(href, urlFor(page.path).href), `${page.path} task ${href}`).toBe(true)
-        expect(new URL(href, urlFor(page.path)).pathname).toContain(urlFor(`${page.port}/${page.version}/workspace/`).pathname)
-      }
-      expect([...document.querySelectorAll('article a[href]')].some((link) => new URL(link.getAttribute('href')!, urlFor(page.path)).pathname.startsWith(urlFor(`${page.port}/${page.version}/workspace/internals/`).pathname)),
-        `${page.path} keeps builder documentation reachable`).toBe(true)
-    })
+  it.each(
+    PORTS.filter((port) => !port.parentLibrary && !['py', 'ruby', 'lua', 'powershell', 'julia'].includes(port.slug)),
+  )('$name publishes workspace Guides and Examples browse pages', async (port) => {
+    for (const page of pages().filter(
+      (entry) =>
+        entry.product === 'workspace' && entry.port === port.slug && ['guides', 'examples'].includes(entry.section),
+    ))
+      await inspect(page.path, (document) => {
+        expect(document.querySelector('meta[http-equiv="refresh"]'), `${page.path} is a browse page`).toBeNull()
+        expect(document.querySelector('[data-pagefind-body]'), `${page.path} is searchable`).not.toBeNull()
+        expect(document.querySelector('h1')?.textContent?.trim(), page.path).toBe(
+          page.section === 'guides' ? 'Guides' : 'Examples',
+        )
+        expect(document.querySelector('.surface-picker-footer')?.textContent?.trim(), page.path).toBe(
+          `${page.name} · ${page.version} · en`,
+        )
+        const cards = [...document.querySelectorAll('article .doc-card[href]')]
+        expect(cards.length, `${page.path} published tasks`).toBeGreaterThan(0)
+        for (const card of cards) {
+          const href = card.getAttribute('href')!
+          expect(resolves(href, urlFor(page.path).href), `${page.path} task ${href}`).toBe(true)
+          expect(new URL(href, urlFor(page.path)).pathname).toContain(
+            urlFor(`${page.port}/${page.version}/workspace/`).pathname,
+          )
+        }
+        expect(
+          [...document.querySelectorAll('article a[href]')].some((link) =>
+            new URL(link.getAttribute('href')!, urlFor(page.path)).pathname.startsWith(
+              urlFor(`${page.port}/${page.version}/workspace/internals/`).pathname,
+            ),
+          ),
+          `${page.path} keeps builder documentation reachable`,
+        ).toBe(true)
+      })
   })
 
   it('canonicalizes each version and loads nested search from the locale index', async () => {
@@ -641,15 +913,26 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
       expect(canonical && attribute(canonical, 'href'), page.path).toBe(urlFor(expected).href)
       const robotsTag = tags(html, 'meta').find((tag) => attribute(tag, 'name') === 'robots')
       const robots = robotsTag && attribute(robotsTag, 'content')
-      expect(robots, page.path).toBe(PREVIEW_PREFIX ? 'noindex, nofollow' : page.version === defaults[page.port] ? 'index, follow' : 'noindex, follow')
+      expect(robots, page.path).toBe(
+        PREVIEW_PREFIX
+          ? 'noindex, nofollow'
+          : page.version === defaults[page.port]
+            ? 'index, follow'
+            : 'noindex, follow',
+      )
       if (PREVIEW_PREFIX && page.version === defaults[page.port]) {
         const production = readFileSync(productionPath('en', page.path, 'index.html'), 'utf8')
         const meta = tags(production, 'meta').find((tag) => attribute(tag, 'name') === 'robots')
         expect(meta && attribute(meta, 'content'), `${page.path} production indexing`).toBe('index, follow')
         const canonical = tags(production, 'link').find((tag) => attribute(tag, 'rel') === 'canonical')
-        expect(canonical && attribute(canonical, 'href'), `${page.path} production canonical`).toBe(`https://libtmux.org/en/${page.path}`)
+        expect(canonical && attribute(canonical, 'href'), `${page.path} production canonical`).toBe(
+          `https://libtmux.org/en/${page.path}`,
+        )
       }
-      expect(links.filter((tag) => attribute(tag, 'hreflang')), `${page.path} no invented translations`).toHaveLength(0)
+      expect(
+        links.filter((tag) => attribute(tag, 'hreflang')),
+        `${page.path} no invented translations`,
+      ).toHaveLength(0)
       const bundles = [...html.matchAll(/\bdata-search-bundle="([^"]+)"/g)].map((match) => match[1])
       expect(bundles.length, `${page.path} search`).toBeGreaterThan(0)
       for (const bundle of bundles) {
@@ -662,8 +945,10 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
   it('keeps product storage paths out of shared translation coverage', () => {
     for (const locale of ['en', 'ja']) {
       const coverage = readFileSync(publishedPath(`${PREVIEW_PREFIX}/${locale}/translations/index.html`), 'utf8')
-      expect(coverage.match(/href="\/(?:pr-\d+\/)?(?:en|ja)\/(?:ports|_staged)\/[^"]*"/g),
-        `${locale} coverage links to published shared pages`).toBeNull()
+      expect(
+        coverage.match(/href="\/(?:pr-\d+\/)?(?:en|ja)\/(?:ports|_staged)\/[^"]*"/g),
+        `${locale} coverage links to published shared pages`,
+      ).toBeNull()
     }
   })
 
@@ -671,11 +956,16 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
     const defaults = manifest().defaultVersion
     const index = JSON.parse(read('docs.json')) as DocsManifest
     const llms = read('llms.txt')
-    const sitemapFiles = [...readFileSync(productionPath('en/sitemap-index.xml'), 'utf8').matchAll(/<loc>([^<]+)<\/loc>/g)].map((match) => new URL(match[1]).pathname)
+    const sitemapFiles = [
+      ...readFileSync(productionPath('en/sitemap-index.xml'), 'utf8').matchAll(/<loc>([^<]+)<\/loc>/g),
+    ].map((match) => new URL(match[1]).pathname)
     const sitemap = sitemapFiles.map((path) => readFileSync(productionPath(path), 'utf8')).join('\n')
     for (const page of pages().filter((entry) => entry.version === defaults[entry.port])) {
       const url = urlFor(page.path).href
-      expect(index.pages.some((entry) => entry.url === url), `${url} in docs.json`).toBe(true)
+      expect(
+        index.pages.some((entry) => entry.url === url),
+        `${url} in docs.json`,
+      ).toBe(true)
       expect(llms, `${url} in llms.txt`).toContain(`](${url})`)
       const productionUrl = `https://libtmux.org/en/${page.path}`
       expect(sitemap, `${productionUrl} in sitemap`).toContain(`<loc>${productionUrl}</loc>`)
@@ -691,7 +981,10 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
       const exported = JSON.parse(read(`${root}docs.json`)) as DocsManifest
       const [rootPort, rootVersion] = root.split('/')
       const visiblePorts = PORTS.filter((port) => !rootPort || port.slug === rootPort)
-      expect(exported.ports.map((port) => port.slug), `${root} port scope`).toEqual(visiblePorts.map((port) => port.slug))
+      expect(
+        exported.ports.map((port) => port.slug),
+        `${root} port scope`,
+      ).toEqual(visiblePorts.map((port) => port.slug))
       for (const port of visiblePorts) {
         const advertised = exported.ports.find((entry) => entry.slug === port.slug)!
         if (port.parentLibrary) {
@@ -700,29 +993,49 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
         }
         for (const product of products) {
           const metadata = advertised.products.find((entry) => entry.slug === product)!
-          expect(metadata.availability, `${root}${port.slug} ${product} availability`).toBe(productAvailable(port, product) ? 'available' : 'unpublished')
-          expect(metadata.inDevelopment, `${root}${port.slug} ${product} development status`).toBe(productInDevelopment(port, product))
+          expect(metadata.availability, `${root}${port.slug} ${product} availability`).toBe(
+            productAvailable(port, product) ? 'available' : 'unpublished',
+          )
+          expect(metadata.inDevelopment, `${root}${port.slug} ${product} development status`).toBe(
+            productInDevelopment(port, product),
+          )
           const section = 'reference'
           if (productAvailable(port, product)) {
-            expect(new URL(metadata.reference!, urlFor(root)).pathname).toBe(urlFor(`${port.slug}/${rootVersion || defaults[port.slug]}/${product}/${section}/`).pathname)
+            expect(new URL(metadata.reference!, urlFor(root)).pathname).toBe(
+              urlFor(`${port.slug}/${rootVersion || defaults[port.slug]}/${product}/${section}/`).pathname,
+            )
           } else expect(metadata.reference).toBeNull()
           if (product === 'workspace') {
             expect(metadata.cli, `${root}${port.slug} user CLI`).toBe(port.workspaceCli ?? null)
-            expect(metadata.cliAvailability, `${root}${port.slug} CLI availability`).toBe(port.workspaceCliAvailability ?? null)
-          } else if (productAvailable(port, 'mcp')) expect(resolves(metadata.protocol!, urlFor(root).href), `${root}${port.slug} MCP protocol`).toBe(true)
+            expect(metadata.cliAvailability, `${root}${port.slug} CLI availability`).toBe(
+              port.workspaceCliAvailability ?? null,
+            )
+          } else if (productAvailable(port, 'mcp'))
+            expect(resolves(metadata.protocol!, urlFor(root).href), `${root}${port.slug} MCP protocol`).toBe(true)
           else expect(metadata.protocol).toBeNull()
         }
       }
       const ruby = exported.ports.find((entry) => entry.slug === 'ruby')
-      if (ruby) expect(ruby.documentation).toEqual(expect.arrayContaining([
-        expect.objectContaining({ id: 'async', kind: 'companion-package', availability: 'available', package: 'libtmux-async' }),
-      ]))
+      if (ruby)
+        expect(ruby.documentation).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({
+              id: 'async',
+              kind: 'companion-package',
+              availability: 'available',
+              package: 'libtmux-async',
+            }),
+          ]),
+        )
       const lua = exported.ports.find((entry) => entry.slug === 'lua')
-      if (lua) expect(lua.documentation).toEqual(expect.arrayContaining([
-        expect.objectContaining({ id: 'runtime', kind: 'runtime', availability: 'available' }),
-        expect.objectContaining({ id: 'mcp', kind: 'unavailable', availability: 'unpublished' }),
-        expect.objectContaining({ id: 'workspace', kind: 'unavailable', availability: 'unpublished' }),
-      ]))
+      if (lua)
+        expect(lua.documentation).toEqual(
+          expect.arrayContaining([
+            expect.objectContaining({ id: 'runtime', kind: 'runtime', availability: 'available' }),
+            expect.objectContaining({ id: 'mcp', kind: 'unavailable', availability: 'unpublished' }),
+            expect.objectContaining({ id: 'workspace', kind: 'unavailable', availability: 'unpublished' }),
+          ]),
+        )
       for (const area of exported.ports.flatMap((port) => port.documentation)) {
         expect(resolves(area.url, urlFor(root).href), `${root}${area.url} documentation area`).toBe(true)
       }
@@ -730,18 +1043,25 @@ describe.skipIf(!SITE_BUILT)('assembled MCP and Workspace Manager docs', () => {
         expect(resolves(entry.url), entry.url).toBe(true)
         expect(resolves(entry.markdownUrl), entry.markdownUrl).toBe(true)
         expect(entry.url, `${root} canonical workspace API exports`).not.toMatch(/\/workspace\/api(?:\/|$)/)
-        expect(entry.url, `${root} legacy workspace Topics redirect excluded`).not.toMatch(/\/(?:lua|ts|rs|go|java|csharp|cxx|swift)\/[^/]+\/workspace\/topics\/?$/)
+        expect(entry.url, `${root} legacy workspace Topics redirect excluded`).not.toMatch(
+          /\/(?:lua|ts|rs|go|java|csharp|cxx|swift)\/[^/]+\/workspace\/topics\/?$/,
+        )
         if (root) expect(new URL(entry.url).pathname).toContain(`/${SITE_PREFIX}${root}`)
       }
     }
     const japanese = publishedPath(`${PREVIEW_PREFIX}/ja/docs.json`)
     expect(existsSync(japanese), 'Japanese assembled manifest').toBe(true)
     const translated = JSON.parse(readFileSync(japanese, 'utf8')) as { pages: { url: string }[] }
-    expect(translated.pages.map((entry) => new URL(entry.url).pathname)
-      .filter((path) => /^\/ja\/(?:py|ruby|lua|ts|rs|go|java|csharp|cxx|swift)\//.test(path)),
-    'Japanese manifest does not invent localized port guides').toEqual([])
+    expect(
+      translated.pages
+        .map((entry) => new URL(entry.url).pathname)
+        .filter((path) => /^\/ja\/(?:py|ruby|lua|ts|rs|go|java|csharp|cxx|swift)\//.test(path)),
+      'Japanese manifest does not invent localized port guides',
+    ).toEqual([])
     for (const entry of translated.pages.filter((entry) => productUrl.test(entry.url))) {
-      expect(new URL(entry.url).pathname, entry.url).not.toMatch(/^\/ja\/(?:py|ruby|lua|ts|rs|go|java|csharp|cxx|swift)\//)
+      expect(new URL(entry.url).pathname, entry.url).not.toMatch(
+        /^\/ja\/(?:py|ruby|lua|ts|rs|go|java|csharp|cxx|swift)\//,
+      )
       expect(resolves(entry.url), entry.url).toBe(true)
     }
   })
diff --git a/site/test/product-reference.test.ts b/site/test/product-reference.test.ts
index 4ce8d7b36..3c17b336c 100644
--- a/site/test/product-reference.test.ts
+++ b/site/test/product-reference.test.ts
@@ -5,7 +5,13 @@ import { pathToFileURL } from 'node:url'
 import { experimental_AstroContainer } from 'astro/container'
 import { Window } from 'happy-dom'
 import { API_MODELS, createApiIndex, referenceAlternatives, topLevelTypesOf } from '../src/lib/api-models'
-import { productApiAlternatives, productApiHref, productApiNavigation, productApiRedirects, productApiRoutes } from '../src/lib/product-api'
+import {
+  productApiAlternatives,
+  productApiHref,
+  productApiNavigation,
+  productApiRedirects,
+  productApiRoutes,
+} from '../src/lib/product-api'
 import { symbolMarkdown } from '../src/lib/symbol-markdown'
 import { PORT_BY_SLUG, productAvailable } from '../src/lib/ports'
 import { getResolver } from '../src/lib/prose-resolver'
@@ -15,33 +21,49 @@ import mentionIndex from '../src/data/mentions.json'
 import { apiCommandRelatedLinks } from '../src/lib/api-sections'
 import { productApiIndex } from '../src/lib/product-api'
 
-const navigationLinks = (items: SidebarItem[]): string[] => items.flatMap((item) => [
-  ...(item.href ? [item.href] : []), ...(item.type === 'group' ? navigationLinks(item.items) : []),
-])
+const navigationLinks = (items: SidebarItem[]): string[] =>
+  items.flatMap((item) => [
+    ...(item.href ? [item.href] : []),
+    ...(item.type === 'group' ? navigationLinks(item.items) : []),
+  ])
 
 describe('product declaration trees', () => {
   it('resolves native PowerShell related help to local core and workspace APIs', () => {
     const model = API_MODELS.powershell
     const symbol = model.symbols.find((entry) => entry.id === 'LibTmux.Workspace\\ConvertTo-TmuxWorkspace')!
     const related = apiCommandRelatedLinks(symbol, productApiIndex(model, 'v1.2.3'))
-    expect(related.map((link) => link.text)).toEqual(['Get-TmuxSnapshot', 'Resolve-TmuxWorkspace', 'ConvertTo-TmuxWorkspaceYaml', 'ConvertTo-TmuxWorkspaceJson'])
+    expect(related.map((link) => link.text)).toEqual([
+      'Get-TmuxSnapshot',
+      'Resolve-TmuxWorkspace',
+      'ConvertTo-TmuxWorkspaceYaml',
+      'ConvertTo-TmuxWorkspaceJson',
+    ])
     expect(related[0].href).toBe('/powershell/v1.2.3/reference/libtmux-get-tmuxsnapshot/')
     expect(related.slice(1).every((link) => link.href.startsWith('/powershell/v1.2.3/workspace/reference/'))).toBe(true)
     expect(related.every((link) => link.symbol?.command?.kind === 'cmdlet')).toBe(true)
-    const external = { ...symbol, command: { ...symbol.command!, relatedLinks: [
-      { text: 'External help', href: 'https://example.com/Get-TmuxSnapshot' },
-    ] } }
+    const external = {
+      ...symbol,
+      command: {
+        ...symbol.command!,
+        relatedLinks: [{ text: 'External help', href: 'https://example.com/Get-TmuxSnapshot' }],
+      },
+    }
     expect(apiCommandRelatedLinks(external, productApiIndex(model, 'latest'))[0]).toMatchObject({
-      text: 'External help', href: 'https://example.com/Get-TmuxSnapshot', symbol: undefined,
+      text: 'External help',
+      href: 'https://example.com/Get-TmuxSnapshot',
+      symbol: undefined,
     })
   })
   it('includes each public product declaration once, including deeply nested members', () => {
-    for (const model of Object.values(API_MODELS)) for (const product of ['workspace', 'mcp'] as const) {
-      const expected = symbolsForProduct(model, product).map((symbol) => productApiHref(model, symbol, 'v1.2.3')).sort()
-      const actual = navigationLinks(productApiNavigation(model, product, 'v1.2.3')).sort()
-      expect(actual, `${model.port} ${product}`).toEqual(expected)
-      expect(new Set(actual).size).toBe(actual.length)
-    }
+    for (const model of Object.values(API_MODELS))
+      for (const product of ['workspace', 'mcp'] as const) {
+        const expected = symbolsForProduct(model, product)
+          .map((symbol) => productApiHref(model, symbol, 'v1.2.3'))
+          .sort()
+        const actual = navigationLinks(productApiNavigation(model, product, 'v1.2.3')).sort()
+        expect(actual, `${model.port} ${product}`).toEqual(expected)
+        expect(new Set(actual).size).toBe(actual.length)
+      }
   })
 
   it('opens the PowerShell workspace module into all nine cmdlets', () => {
@@ -49,14 +71,20 @@ describe('product declaration trees', () => {
     expect(module).toMatchObject({ type: 'group', label: 'LibTmux.Workspace', kind: 'module' })
     if (module.type !== 'group') throw new Error('Workspace module must have children')
     expect(module.items).toHaveLength(9)
-    expect(module.items).toContainEqual({ type: 'link', label: 'ConvertTo-TmuxWorkspace', kind: 'cmdlet',
-      href: '/powershell/latest/workspace/reference/libtmux-workspace-convertto-tmuxworkspace/' })
+    expect(module.items).toContainEqual({
+      type: 'link',
+      label: 'ConvertTo-TmuxWorkspace',
+      kind: 'cmdlet',
+      href: '/powershell/latest/workspace/reference/libtmux-workspace-convertto-tmuxworkspace/',
+    })
   })
 
   it('groups Julia extension functions by their declaring module without inventing module pages', () => {
     const tree = productApiNavigation(API_MODELS.julia, 'mcp', 'latest')
-    for (const [name, functions] of [['Base', ['close', 'isopen', 'show', 'showerror']],
-      ['ModelContextProtocol', ['close', 'is_connected', 'read_message', 'write_message']]] as const) {
+    for (const [name, functions] of [
+      ['Base', ['close', 'isopen', 'show', 'showerror']],
+      ['ModelContextProtocol', ['close', 'is_connected', 'read_message', 'write_message']],
+    ] as const) {
       const group = tree.find((item) => item.label === name)
       expect(group?.type).toBe('group')
       expect(group?.kind).toBe('module')
@@ -73,27 +101,45 @@ describe('product declaration trees', () => {
     async function compile(relative: string, imports: Record<string, string> = {}) {
       const file = new URL(relative, import.meta.url)
       const source = readFileSync(file, 'utf8').replace(/<style[\s\S]*?<\/style>/g, '')
-      const result = await transform(source, { filename: file.pathname, internalURL: 'astro/compiler-runtime',
-        resultScopedSlot: true, resolvePath: (specifier: string) => specifier })
+      const result = await transform(source, {
+        filename: file.pathname,
+        internalURL: 'astro/compiler-runtime',
+        resultScopedSlot: true,
+        resolvePath: (specifier: string) => specifier,
+      })
       expect(result.diagnostics.filter((item: { severity: string }) => item.severity === 'error')).toEqual([])
-      let code = result.code.replaceAll('"astro/compiler-runtime"', JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href))
-      for (const [specifier, url] of Object.entries(imports)) code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(url))
+      let code = result.code.replaceAll(
+        '"astro/compiler-runtime"',
+        JSON.stringify(pathToFileURL(astroRequire.resolve('astro/compiler-runtime')).href),
+      )
+      for (const [specifier, url] of Object.entries(imports))
+        code = code.replaceAll(JSON.stringify(specifier), JSON.stringify(url))
       return `data:text/javascript;base64,${Buffer.from(code).toString('base64')}`
     }
-    const badge = await compile('../src/components/api/ApiBadge.astro', Object.fromEntries(
-      ['api-labels', 'api-glossary'].map((name) => [`../../lib/${name}`, new URL(`../src/lib/${name}.ts`, import.meta.url).href])))
+    const badge = await compile(
+      '../src/components/api/ApiBadge.astro',
+      Object.fromEntries(
+        ['api-labels', 'api-glossary'].map((name) => [
+          `../../lib/${name}`,
+          new URL(`../src/lib/${name}.ts`, import.meta.url).href,
+        ]),
+      ),
+    )
     const link = await compile('../src/components/docs/SidebarLink.astro', { '../api/ApiBadge.astro': badge })
     const section = await compile('../src/components/docs/SidebarSection.astro', {
-      './SidebarLink.astro': link, '../api/ApiBadge.astro': badge,
+      './SidebarLink.astro': link,
+      '../api/ApiBadge.astro': badge,
       // Isolate collection loading; these fixture paths already use one canonical spelling.
-      '../../lib/sidebar': 'data:text/javascript,export const isActivePath = (href, currentPath) => href === currentPath',
+      '../../lib/sidebar':
+        'data:text/javascript,export const isActivePath = (href, currentPath) => href === currentPath',
     })
     const component = (await import(/* @vite-ignore */ section)).default
     const container = await experimental_AstroContainer.create()
     const win = new Window()
     try {
-      const scopes = productApiNavigation(API_MODELS.julia, 'mcp', 'latest')
-        .filter((item) => ['Base', 'ModelContextProtocol'].includes(item.label))
+      const scopes = productApiNavigation(API_MODELS.julia, 'mcp', 'latest').filter((item) =>
+        ['Base', 'ModelContextProtocol'].includes(item.label),
+      )
       scopes.push(productApiNavigation(API_MODELS.powershell, 'workspace', 'latest')[0])
       for (const group of scopes) {
         if (group.type !== 'group') throw new Error(`Missing group ${group.label}`)
@@ -108,8 +154,11 @@ describe('product declaration trees', () => {
         expect(summary.querySelector('a')?.getAttribute('href')).toBe(group.href)
         expect(win.document.querySelector('details')?.hasAttribute('open')).toBe(true)
         expect(win.document.querySelector('a[aria-current="page"]')?.getAttribute('href')).toBe(currentPath)
-        expect(Array.from(win.document.querySelectorAll('.sidebar-section__children a')).map((entry) => entry.getAttribute('href')))
-          .toEqual(navigationLinks(group.items))
+        expect(
+          Array.from(win.document.querySelectorAll('.sidebar-section__children a')).map((entry) =>
+            entry.getAttribute('href'),
+          ),
+        ).toEqual(navigationLinks(group.items))
       }
     } finally {
       await win.happyDOM.abort()
@@ -183,9 +232,10 @@ it('gives Kotlin, Scala and F# native references with parent type links', () =>
     const index = createApiIndex(model, (symbol) => `/reference/${symbol.slug}/`)
     if (port === 'fsharp') {
       const capture = model.symbols.find((symbol) => symbol.id === 'LibTmux.FSharp.Pane.capture')!
-      expect(index.linkType(capture.signatures[0].raw!, capture)
-        .find((span) => span.text === 'CapturePaneRequest')?.link?.href)
-        .toBe('/csharp/latest/reference/libtmux-capturepanerequest/')
+      expect(
+        index.linkType(capture.signatures[0].raw!, capture).find((span) => span.text === 'CapturePaneRequest')?.link
+          ?.href,
+      ).toBe('/csharp/latest/reference/libtmux-capturepanerequest/')
     } else {
       const parent = index.resolve('io.github.libtmux.Server')
       expect(parent?.href).toBe('/java/latest/reference/io-github-libtmux-server-server/')
@@ -201,17 +251,29 @@ describe('product reference equivalents', () => {
     expect(model.symbols.some((symbol) => symbol.id === 'WorkspaceBuilderError.!=(_:_:)')).toBe(false)
     const routes = productApiRedirects({ swift: model }, 'swift', {}, 'latest')
     expect(routes).toHaveLength(1)
-    expect(routes[0]).toMatchObject({ path: 'workspace/reference/workspacebuildererror-(_-_-)',
-      target: 'workspace/reference/workspacebuildererror', symbol: { id: 'WorkspaceBuilderError' } })
-    expect(productApiRoutes({ swift: model }, 'swift', {}, 'latest')
-      .some((route) => route.path === routes[0].path)).toBe(false)
-    expect(productApiRedirects({ swift: model }, undefined, { swift: 'stable' }, 'latest')[0].path)
-      .toBe(`swift/stable/${routes[0].path}`)
+    expect(routes[0]).toMatchObject({
+      path: 'workspace/reference/workspacebuildererror-(_-_-)',
+      target: 'workspace/reference/workspacebuildererror',
+      symbol: { id: 'WorkspaceBuilderError' },
+    })
+    expect(
+      productApiRoutes({ swift: model }, 'swift', {}, 'latest').some((route) => route.path === routes[0].path),
+    ).toBe(false)
+    expect(productApiRedirects({ swift: model }, undefined, { swift: 'stable' }, 'latest')[0].path).toBe(
+      `swift/stable/${routes[0].path}`,
+    )
     expect(productApiRedirects({ swift: model }, 'go', {}, 'latest')).toEqual([])
     expect(productApiRedirects({}, 'swift', {}, 'latest')).toEqual([])
-    const oldModel = { ...model, symbols: [...model.symbols, {
-      ...routes[0].symbol, id: 'WorkspaceBuilderError.!=(_:_:)',
-    }] }
+    const oldModel = {
+      ...model,
+      symbols: [
+        ...model.symbols,
+        {
+          ...routes[0].symbol,
+          id: 'WorkspaceBuilderError.!=(_:_:)',
+        },
+      ],
+    }
     expect(productApiRedirects({ swift: oldModel }, 'swift', {}, 'v0.1.0')).toEqual([])
   })
 
@@ -219,10 +281,18 @@ describe('product reference equivalents', () => {
     const model = API_MODELS.go
     const symbol = model.symbols.find((entry) => entry.id === 'workspace.Build')!
     const group = productApiAlternatives(model, symbol, 'v1.2.3', { ts: 'stable' })[0]
-    expect(group.ports.find((entry) => entry.port === 'go')?.href).toBe('/go/v1.2.3/workspace/reference/workspace-build/')
-    expect(group.ports.find((entry) => entry.port === 'ts')?.href).toBe('/ts/stable/workspace/reference/builder-applyworkspace/')
-    expect(group.ports.find((entry) => entry.port === 'rs')?.href).toBe('/rs/latest/workspace/reference/src-workspacebuilder-build/')
-    expect(referenceAlternatives('go', symbol.id)[0].ports.find((entry) => entry.port === 'ts')?.href).toBe('/ts/latest/workspace/reference/builder-applyworkspace/')
+    expect(group.ports.find((entry) => entry.port === 'go')?.href).toBe(
+      '/go/v1.2.3/workspace/reference/workspace-build/',
+    )
+    expect(group.ports.find((entry) => entry.port === 'ts')?.href).toBe(
+      '/ts/stable/workspace/reference/builder-applyworkspace/',
+    )
+    expect(group.ports.find((entry) => entry.port === 'rs')?.href).toBe(
+      '/rs/latest/workspace/reference/src-workspacebuilder-build/',
+    )
+    expect(referenceAlternatives('go', symbol.id)[0].ports.find((entry) => entry.port === 'ts')?.href).toBe(
+      '/ts/latest/workspace/reference/builder-applyworkspace/',
+    )
   })
 
   it('publishes every product declaration in its own reference', () => {
diff --git a/site/test/prompts.test.ts b/site/test/prompts.test.ts
index 7b0d0844f..1ec429b3e 100644
--- a/site/test/prompts.test.ts
+++ b/site/test/prompts.test.ts
@@ -104,7 +104,7 @@ describe('prompt composition', () => {
     expect(text, 'docs.json').toContain(`${DOCS_BASE}/${port.slug}/latest/docs.json`)
     expect(text, 'reference').toContain(`${DOCS_BASE}/${port.slug}/latest/reference/`)
     expect(text, 'repository').toContain(`https://github.com/${port.repo}`)
-    expect(text, 'registry page').toContain((port.registry?.url ?? `https://github.com/${port.repo}`))
+    expect(text, 'registry page').toContain(port.registry?.url ?? `https://github.com/${port.repo}`)
   })
 
   it.each([DOCS_BASE, 'https://libtmux.org/pr-42/ja'])('cites shared tmux guides beneath %s', (docsBase) => {
@@ -220,7 +220,12 @@ describe('prompt legibility', () => {
   })
 
   it('indents continuation lines it is given an indent for', () => {
-    expect(wrap('alpha beta gamma delta', 12, '  ').split('\n').slice(1).every((l) => l.startsWith('  '))).toBe(true)
+    expect(
+      wrap('alpha beta gamma delta', 12, '  ')
+        .split('\n')
+        .slice(1)
+        .every((l) => l.startsWith('  ')),
+    ).toBe(true)
   })
 })
 
@@ -392,7 +397,11 @@ describe.skipIf(!SITE_BUILT)(`cited URLs resolve in the assembled tree${SITE_BUI
   }
 
   it.each(MATRIX)('$port.slug/$topic.id cites only published URLs', ({ port, topic }) => {
-    const urls = [...promptFor(port, topic.id, ctx.version, `https://libtmux.org/${SITE_PREFIX.replace(/\/$/, '')}`).matchAll(/https:\/\/libtmux\.org\/\S*[^\s.,)]/g)].map((m) => m[0])
+    const urls = [
+      ...promptFor(port, topic.id, ctx.version, `https://libtmux.org/${SITE_PREFIX.replace(/\/$/, '')}`).matchAll(
+        /https:\/\/libtmux\.org\/\S*[^\s.,)]/g,
+      ),
+    ].map((m) => m[0])
     expect(urls.length).toBeGreaterThan(0)
     const dead = urls.filter((url) => !resolves(url))
     expect(dead, `not published: ${dead.join(', ')}`).toEqual([])
@@ -412,9 +421,9 @@ describe.skipIf(!SITE_BUILT)(`published prompt routes${SITE_BUILT ? '' : ` (${SK
   const manifest = () => JSON.parse(readFileSync(published('prompts.json'), 'utf8'))
 
   it('writes a text file for every port and topic', () => {
-    const missing = PROMPT_PAIRS
-      .map(({ port, topic }) => textPath(port.slug, topic.id))
-      .filter((path) => !existsSync(published(path)))
+    const missing = PROMPT_PAIRS.map(({ port, topic }) => textPath(port.slug, topic.id)).filter(
+      (path) => !existsSync(published(path)),
+    )
     expect(missing, `absent: ${missing.join(', ')}`).toEqual([])
   })
 
@@ -456,7 +465,9 @@ describe.skipIf(!SITE_BUILT)(`published prompt routes${SITE_BUILT ? '' : ` (${SK
       const version = versions.get(key)
       expect(version, `${key} is absent from prompts.json`).toBeTruthy()
       const file = readFileSync(published(textPath(port.slug, topic.id)), 'utf8')
-      expect(file, key).toBe(`${promptFor(port, topic.id, version, `https://libtmux.org/${SITE_PREFIX.replace(/\/$/, '')}`)}\n`)
+      expect(file, key).toBe(
+        `${promptFor(port, topic.id, version, `https://libtmux.org/${SITE_PREFIX.replace(/\/$/, '')}`)}\n`,
+      )
     }
   })
 
@@ -472,9 +483,9 @@ describe.skipIf(!SITE_BUILT)(`published prompt routes${SITE_BUILT ? '' : ` (${SK
    * carries its own copy under a prefix nothing links to.
    */
   it('does not repeat itself under a port and version prefix', () => {
-    const strays = PORTS
-      .map((port) => join(SITE_PREFIX, port.slug, 'latest', 'prompts'))
-      .filter((path) => existsSync(join(BUCKET_ROOT, path)))
+    const strays = PORTS.map((port) => join(SITE_PREFIX, port.slug, 'latest', 'prompts')).filter((path) =>
+      existsSync(join(BUCKET_ROOT, path)),
+    )
     expect(strays, `prompts published under a port prefix: ${strays.join(', ')}`).toEqual([])
   })
 })
diff --git a/site/test/prose-markdown.test.ts b/site/test/prose-markdown.test.ts
index 3b69d4a9f..c3f190b91 100644
--- a/site/test/prose-markdown.test.ts
+++ b/site/test/prose-markdown.test.ts
@@ -19,7 +19,9 @@ afterEach(() => vi.unstubAllEnvs())
 
 function urls(markdown: string): string[] {
   const links: string[] = []
-  visit(fromMarkdown(markdown), 'link', (node) => { links.push(node.url) })
+  visit(fromMarkdown(markdown), 'link', (node) => {
+    links.push(node.url)
+  })
   return links
 }
 
@@ -35,19 +37,37 @@ describe('prose Markdown links', () => {
   it('uses the native Concepts page in routes, exports, sidebar and breadcrumbs', async () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'ruby')
     vi.stubEnv('LIBTMUX_DOCS_LOCALE', 'en')
-    const shared = { id: 'concepts', body: 'Shared concepts.', data: { title: 'Concepts', sidebar: { group: 'Concepts' } } }
-    const native = { id: '_staged/ruby/concepts', body: 'Ruby concepts.', data: { title: 'Ruby concepts', port: 'ruby', route: 'concepts', sidebar: { group: 'Concepts' } } }
+    const shared = {
+      id: 'concepts',
+      body: 'Shared concepts.',
+      data: { title: 'Concepts', sidebar: { group: 'Concepts' } },
+    }
+    const native = {
+      id: '_staged/ruby/concepts',
+      body: 'Ruby concepts.',
+      data: { title: 'Ruby concepts', port: 'ruby', route: 'concepts', sidebar: { group: 'Concepts' } },
+    }
     const entries = [shared, native] as CollectionEntry<'docs'>[]
-    vi.mocked(getCollection<'docs'>).mockImplementation(async (_collection, filter) => entries.filter((entry) => !filter || filter(entry)))
+    vi.mocked(getCollection<'docs'>).mockImplementation(async (_collection, filter) =>
+      entries.filter((entry) => !filter || filter(entry)),
+    )
     try {
       expect(localeProse(entries, 'en', 'ruby')).toEqual([{ entry: native, route: 'concepts' }])
       const exported = await llmsPages('https://libtmux.org', '/en/ruby/latest/')
       expect(exported).toHaveLength(1)
-      expect(exported[0]).toMatchObject({ title: 'Ruby concepts', body: 'Ruby concepts.', url: 'https://libtmux.org/en/ruby/latest/concepts/' })
+      expect(exported[0]).toMatchObject({
+        title: 'Ruby concepts',
+        body: 'Ruby concepts.',
+        url: 'https://libtmux.org/en/ruby/latest/concepts/',
+      })
       const sidebar = await getSidebar('ruby', 'latest')
       const concepts = sidebar.find((entry) => entry.type === 'group' && entry.label === 'Concepts')
       expect(concepts).toMatchObject({ href: expect.stringContaining('/ruby/latest/concepts/'), items: [] })
-      expect((await pageBreadcrumbs('Model', 'concepts/model', 'latest', 'ruby')).map((entry) => entry.name)).toEqual(['Ruby', 'Ruby concepts', 'Model'])
+      expect((await pageBreadcrumbs('Model', 'concepts/model', 'latest', 'ruby')).map((entry) => entry.name)).toEqual([
+        'Ruby',
+        'Ruby concepts',
+        'Model',
+      ])
     } finally {
       vi.mocked(getCollection).mockResolvedValue([])
     }
@@ -64,62 +84,99 @@ describe('prose Markdown links', () => {
       '[parameter](../../reference/libtmux-new-tmuxsession/#parameter.Name)',
       '```powershell\nNew-TmuxSession\n```',
     ].join('\n\n')
-    const rendered = await renderer.render(content, { frontmatter: { port: 'powershell', route: 'examples/create-layout' } })
+    const rendered = await renderer.render(content, {
+      frontmatter: { port: 'powershell', route: 'examples/create-layout' },
+    })
     expect(rendered.code.match(/data-api-kind="function"/g)).toHaveLength(2)
     expect(rendered.code.match(/data-api-kind="class"/g)).toHaveLength(1)
     expect(rendered.code.match(/data-api-kind="struct"/g)).toHaveLength(1)
-    expect(rendered.code).toContain('aria-hidden="true" title="cmdlet"><span class="api-badge__label">f</span></span><code>New-TmuxSession</code>')
+    expect(rendered.code).toContain(
+      'aria-hidden="true" title="cmdlet"><span class="api-badge__label">f</span></span><code>New-TmuxSession</code>',
+    )
     expect(rendered.code).toContain('<pre><code class="language-powershell">New-TmuxSession\n</code></pre>')
     expect(linkProseMarkdown(content, 'powershell')).not.toContain('data-api-kind')
-    const repeated = await createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks, rehypeApiLinks], syntaxHighlight: false })
-    expect((await repeated.render(content, { frontmatter: { port: 'powershell', route: 'examples/create-layout' } })).code).toBe(rendered.code)
+    const repeated = await createMarkdownProcessor({
+      rehypePlugins: [rehypeApiLinks, rehypeApiLinks],
+      syntaxHighlight: false,
+    })
+    expect(
+      (await repeated.render(content, { frontmatter: { port: 'powershell', route: 'examples/create-layout' } })).code,
+    ).toBe(rendered.code)
   })
 
   it.each([
-    ['ports/cxx/workspace/internals/examples', 'cxx', 'workspace', '[`Server`](../../../reference/libtmux-server/)', 'class'],
-    ['ports/go/mcp/examples/run-command', 'go', 'mcp', '[`Session.ResolveActivePane`](../../../reference/tmux-session-resolveactivepane/)', 'method'],
-    ['ports/rs/workspace/internals/examples', 'rs', 'workspace', '[`Server`](../../../reference/server-server/)', 'struct'],
+    [
+      'ports/cxx/workspace/internals/examples',
+      'cxx',
+      'workspace',
+      '[`Server`](../../../reference/libtmux-server/)',
+      'class',
+    ],
+    [
+      'ports/go/mcp/examples/run-command',
+      'go',
+      'mcp',
+      '[`Session.ResolveActivePane`](../../../reference/tmux-session-resolveactivepane/)',
+      'method',
+    ],
+    [
+      'ports/rs/workspace/internals/examples',
+      'rs',
+      'workspace',
+      '[`Server`](../../../reference/server-server/)',
+      'struct',
+    ],
   ])('resolves badge destinations using the actual source route of %s', async (id, port, product, content, kind) => {
     const renderer = await createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
     const rendered = await renderer.render(content, {
-      fileURL: new URL(`../src/content/docs/${id}.md`, import.meta.url), frontmatter: { port, product },
+      fileURL: new URL(`../src/content/docs/${id}.md`, import.meta.url),
+      frontmatter: { port, product },
     })
     expect(rendered.code).toContain(`data-api-kind="${kind}"`)
   })
 
   it.each([
-    ['powershell', 'Use `Get-TmuxSnapshot` with `LibTmux.Server` and `Server`. Read `src/LibTmux.PowerShell/ConnectTmuxServerCommand.cs`.', [
-      '/powershell/latest/reference/libtmux-get-tmuxsnapshot/', '/csharp/latest/reference/libtmux-server/',
-    ], '/src/LibTmux.PowerShell/ConnectTmuxServerCommand.cs'],
-    ['julia', 'Use `Base.strip` on captured output. Read `src/server.jl`.', [
-      'https://docs.julialang.org/en/v1/base/strings/#Base.strip',
-    ], '/src/server.jl'],
-  ])('links %s prose in HTML and Markdown with its API and source inventories', async (port, content, targets, sourcePath) => {
-    vi.stubEnv('LIBTMUX_DOCS_PORT', port)
-    vi.stubEnv('LIBTMUX_DOCS_VERSION', 'latest')
-    vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{"csharp":"latest"}')
-    const renderer = await createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
-    const html = (await renderer.render(content)).code
-    const markdown = linkProseMarkdown(content, port)
-    for (const target of targets) {
-      expect(html).toContain(`href="${target}"`)
-      expect(urls(markdown)).toContain(target)
-    }
-    const source = urls(markdown).find((href) => href.endsWith(sourcePath))!
-    expect(source).toMatch(new RegExp(`^https://github.com/libtmux/libtmux-${port}/blob/[a-f0-9]{40}/`))
-    expect(html).toContain(`href="${source}"`)
-  })
+    [
+      'powershell',
+      'Use `Get-TmuxSnapshot` with `LibTmux.Server` and `Server`. Read `src/LibTmux.PowerShell/ConnectTmuxServerCommand.cs`.',
+      ['/powershell/latest/reference/libtmux-get-tmuxsnapshot/', '/csharp/latest/reference/libtmux-server/'],
+      '/src/LibTmux.PowerShell/ConnectTmuxServerCommand.cs',
+    ],
+    [
+      'julia',
+      'Use `Base.strip` on captured output. Read `src/server.jl`.',
+      ['https://docs.julialang.org/en/v1/base/strings/#Base.strip'],
+      '/src/server.jl',
+    ],
+  ])(
+    'links %s prose in HTML and Markdown with its API and source inventories',
+    async (port, content, targets, sourcePath) => {
+      vi.stubEnv('LIBTMUX_DOCS_PORT', port)
+      vi.stubEnv('LIBTMUX_DOCS_VERSION', 'latest')
+      vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{"csharp":"latest"}')
+      const renderer = await createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
+      const html = (await renderer.render(content)).code
+      const markdown = linkProseMarkdown(content, port)
+      for (const target of targets) {
+        expect(html).toContain(`href="${target}"`)
+        expect(urls(markdown)).toContain(target)
+      }
+      const source = urls(markdown).find((href) => href.endsWith(sourcePath))!
+      expect(source).toMatch(new RegExp(`^https://github.com/libtmux/libtmux-${port}/blob/[a-f0-9]{40}/`))
+      expect(html).toContain(`href="${source}"`)
+    },
+  )
 
   it('does not borrow PowerShell dependencies in Julia prose or resolve an invented cmdlet', () => {
-    expect(urls(linkProseMarkdown('Use `LibTmux.Server` and `Server`.', 'julia')))
-      .not.toContain('/csharp/latest/reference/libtmux-server/')
+    expect(urls(linkProseMarkdown('Use `LibTmux.Server` and `Server`.', 'julia'))).not.toContain(
+      '/csharp/latest/reference/libtmux-server/',
+    )
     expect(urls(linkProseMarkdown('Use `Invent-TmuxServer`.', 'powershell'))).toEqual([])
   })
 
   it('uses the same standard PowerShell destinations in prose HTML and Markdown', async () => {
     const names = ['Where-Object', 'Get-Member', 'Invoke-WebRequest', 'Start-ThreadJob', 'Receive-Job', 'Set-Content']
-    const content = names.map(name => `Use \`${name}\`.`).join('\n\n')
-      + '\n\n```powershell\nGet-Member\n```\n'
+    const content = names.map((name) => `Use \`${name}\`.`).join('\n\n') + '\n\n```powershell\nGet-Member\n```\n'
     const renderer = await createMarkdownProcessor({ rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
     const html = (await renderer.render(content, { frontmatter: { port: 'powershell' } })).code
     const markdown = linkProseMarkdown(content, 'powershell')
@@ -133,38 +190,52 @@ describe('prose Markdown links', () => {
     expect(html).toContain('<pre><code class="language-powershell">Get-Member\n</code></pre>')
   })
 
-  it.each(['', '/pr-42'])('keeps explicit library and manual links consistent in Japanese HTML and exports under %s', async (prefix) => {
-    vi.stubEnv('LIBTMUX_DOCS_ROOT', `${prefix}/ja`)
-    vi.stubEnv('LIBTMUX_DOCS_PORT_ROOT', `${prefix}/en`)
-    vi.stubEnv('LIBTMUX_DOCS_PORT', '')
-    vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{}')
-    vi.resetModules()
-    const { llmsPage: deployedPage } = await import('../src/lib/llms')
-    const { rehypeSiteRoot } = await import('../src/plugins/rehype-site-root.mjs')
-    const { remarkPortCode: deployedPortCode } = await import('../src/plugins/remark-port-code.mjs')
-    const renderer = await createMarkdownProcessor({
-      remarkPlugins: [deployedPortCode], rehypePlugins: [rehypeSiteRoot], syntaxHighlight: false,
-    })
-    for (const id of ['examples/capture-pane-output', 'guides/attaching-to-tmux', 'examples/workspace-from-file', 'concepts/queries']) {
-      const { content, frontmatter } = parseFrontmatter(readFileSync(new URL(`../src/content/docs/${id}.md`, import.meta.url), 'utf8'))
-      const entry = { id, body: content, data: frontmatter } as CollectionEntry<'docs'>
-      const exported = deployedPage(entry, 'https://libtmux.org', `${prefix}/ja/`)
-      const html = (await renderer.render(content)).code
-      const htmlLinks = [...html.matchAll(/<a\b[^>]*href="([^"]+)"/g)].map((match) => new URL(match[1], 'https://libtmux.org').href)
-      const owned = urls(content).filter((href) => {
-        const owner = href.split('/')[1]
-        return Object.hasOwn(PORT_BY_SLUG, owner) || href.startsWith('/tmux/latest/manual/')
+  it.each(['', '/pr-42'])(
+    'keeps explicit library and manual links consistent in Japanese HTML and exports under %s',
+    async (prefix) => {
+      vi.stubEnv('LIBTMUX_DOCS_ROOT', `${prefix}/ja`)
+      vi.stubEnv('LIBTMUX_DOCS_PORT_ROOT', `${prefix}/en`)
+      vi.stubEnv('LIBTMUX_DOCS_PORT', '')
+      vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{}')
+      vi.resetModules()
+      const { llmsPage: deployedPage } = await import('../src/lib/llms')
+      const { rehypeSiteRoot } = await import('../src/plugins/rehype-site-root.mjs')
+      const { remarkPortCode: deployedPortCode } = await import('../src/plugins/remark-port-code.mjs')
+      const renderer = await createMarkdownProcessor({
+        remarkPlugins: [deployedPortCode],
+        rehypePlugins: [rehypeSiteRoot],
+        syntaxHighlight: false,
       })
-      expect(owned.length, id).toBeGreaterThan(0)
-      for (const href of owned) {
-        const target = `https://libtmux.org${prefix}/en${href}`
-        expect(htmlLinks, `${id} HTML`).toContain(target)
-        expect(urls(exported.body), `${id} Markdown`).toContain(target)
-        expect(urls(exported.body)).not.toContain(`https://libtmux.org${prefix}/ja${href}`)
+      for (const id of [
+        'examples/capture-pane-output',
+        'guides/attaching-to-tmux',
+        'examples/workspace-from-file',
+        'concepts/queries',
+      ]) {
+        const { content, frontmatter } = parseFrontmatter(
+          readFileSync(new URL(`../src/content/docs/${id}.md`, import.meta.url), 'utf8'),
+        )
+        const entry = { id, body: content, data: frontmatter } as CollectionEntry<'docs'>
+        const exported = deployedPage(entry, 'https://libtmux.org', `${prefix}/ja/`)
+        const html = (await renderer.render(content)).code
+        const htmlLinks = [...html.matchAll(/<a\b[^>]*href="([^"]+)"/g)].map(
+          (match) => new URL(match[1], 'https://libtmux.org').href,
+        )
+        const owned = urls(content).filter((href) => {
+          const owner = href.split('/')[1]
+          return Object.hasOwn(PORT_BY_SLUG, owner) || href.startsWith('/tmux/latest/manual/')
+        })
+        expect(owned.length, id).toBeGreaterThan(0)
+        for (const href of owned) {
+          const target = `https://libtmux.org${prefix}/en${href}`
+          expect(htmlLinks, `${id} HTML`).toContain(target)
+          expect(urls(exported.body), `${id} Markdown`).toContain(target)
+          expect(urls(exported.body)).not.toContain(`https://libtmux.org${prefix}/ja${href}`)
+        }
+        expect(exampleBytes(exported.body)).toEqual(exampleBytes(resolvePortCode(content)))
       }
-      expect(exampleBytes(exported.body)).toEqual(exampleBytes(resolvePortCode(content)))
-    }
-  })
+    },
+  )
 
   it.each(['', '/pr-42'])('links owned tasks from Japanese exports to their English port under %s', async (prefix) => {
     vi.stubEnv('LIBTMUX_DOCS_ROOT', `${prefix}/ja`)
@@ -179,7 +250,9 @@ describe('prose Markdown links', () => {
       ['topics/waiting-and-retry', ['ts/next/concepts/transports']],
     ] as const
     for (const [id, targets] of pages) {
-      const { content, frontmatter } = parseFrontmatter(readFileSync(new URL(`../src/content/docs/${id}.md`, import.meta.url), 'utf8'))
+      const { content, frontmatter } = parseFrontmatter(
+        readFileSync(new URL(`../src/content/docs/${id}.md`, import.meta.url), 'utf8'),
+      )
       const entry = { id, body: content, data: frontmatter } as CollectionEntry<'docs'>
       const exported = deployedPage(entry, 'https://libtmux.org', `${prefix}/ja/`)
       for (const target of targets) {
@@ -205,7 +278,9 @@ describe('prose Markdown links', () => {
     const { rehypeApiLinks: deployedApiLinks } = await import('../src/plugins/rehype-api-links')
     const { rehypeSiteRoot } = await import('../src/plugins/rehype-site-root.mjs')
     const { remarkPortCode: deployedPortCode } = await import('../src/plugins/remark-port-code.mjs')
-    const { content, frontmatter } = parseFrontmatter(readFileSync(new URL('../src/content/docs/concepts/workspaces.md', import.meta.url), 'utf8'))
+    const { content, frontmatter } = parseFrontmatter(
+      readFileSync(new URL('../src/content/docs/concepts/workspaces.md', import.meta.url), 'utf8'),
+    )
     const entry = { id: 'concepts/workspaces', body: content, data: frontmatter } as CollectionEntry<'docs'>
 
     for (const port of ['go', 'py', 'rs', 'java', 'csharp', '']) {
@@ -213,14 +288,18 @@ describe('prose Markdown links', () => {
       const base = port ? `${root}/${port}/next/` : `${root}/`
       const exported = deployedPage(entry, 'https://libtmux.org', base)
       const renderer = await createMarkdownProcessor({
-        remarkPlugins: [deployedPortCode], rehypePlugins: [rehypeSiteRoot, deployedApiLinks], syntaxHighlight: false,
+        remarkPlugins: [deployedPortCode],
+        rehypePlugins: [rehypeSiteRoot, deployedApiLinks],
+        syntaxHighlight: false,
       })
       const html = (await renderer.render(content)).code
-      const htmlLinks = [...html.matchAll(/<a\b[^>]*href="([^"]+)"/g)].map((match) => new URL(match[1], 'https://libtmux.org').href)
+      const htmlLinks = [...html.matchAll(/<a\b[^>]*href="([^"]+)"/g)].map(
+        (match) => new URL(match[1], 'https://libtmux.org').href,
+      )
       const expectedOwners = port ? [port] : ['py', 'go', 'rs', 'java', 'csharp']
       const defaults: Record<string, string> = { py: 'stable', rs: 'v0.1' }
       for (const owner of expectedOwners) {
-        const version = owner === port ? 'next' : defaults[owner] ?? 'latest'
+        const version = owner === port ? 'next' : (defaults[owner] ?? 'latest')
         const target = `https://libtmux.org${ports}/${owner}/${version}/workspace/`
         expect(htmlLinks, `${port || 'shared'} HTML`).toContain(target)
         expect(urls(exported.body), `${port || 'shared'} Markdown`).toContain(target)
@@ -261,19 +340,25 @@ describe('prose Markdown links', () => {
   it('preserves explicit ownership in shared prose and avoids ambiguous file links', () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', '')
     vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{"go":"next","py":"stable"}')
-    const source = '<!-- port:go -->Use `Session.Panes`.<!-- /port -->\n\n<!-- port:py -->Use `Session.panes` and `list`.<!-- /port -->'
+    const source =
+      '<!-- port:go -->Use `Session.Panes`.<!-- /port -->\n\n<!-- port:py -->Use `Session.panes` and `list`.<!-- /port -->'
     expect(urls(linkProseMarkdown(source))).toEqual([
-      '/go/next/reference/tmux-session-panes/', '/py/stable/reference/libtmux-session-panes/',
+      '/go/next/reference/tmux-session-panes/',
+      '/py/stable/reference/libtmux-session-panes/',
       'https://docs.python.org/3/library/stdtypes.html#list',
     ])
-    expect(linkProseMarkdown('A `settings.rs` file and `missing-rust-file.rs`.', 'rs')).toBe('A `settings.rs` file and `missing-rust-file.rs`.')
+    expect(linkProseMarkdown('A `settings.rs` file and `missing-rust-file.rs`.', 'rs')).toBe(
+      'A `settings.rs` file and `missing-rust-file.rs`.',
+    )
     expect(urls(linkProseMarkdown('Read `src/libtmux/pane.py`.', 'rs'))).toEqual([])
   })
 
   it.each(Object.keys(PORT_BY_SLUG))('links a real %s declaration in its selected version', (port) => {
     const model = API_MODELS[port]
     const name = port === 'powershell' ? 'New-TmuxServer' : 'Server'
-    const symbol = model.symbols.find((entry) => entry.name === name && (port === 'powershell' ? entry.command : !entry.parent))!
+    const symbol = model.symbols.find(
+      (entry) => entry.name === name && (port === 'powershell' ? entry.command : !entry.parent),
+    )!
     expect(symbol, `${port} ${name} declaration`).toBeDefined()
     vi.stubEnv('LIBTMUX_DOCS_PORT', port)
     vi.stubEnv('LIBTMUX_DOCS_VERSION', 'next')
@@ -285,32 +370,47 @@ describe('prose Markdown links', () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'go')
     vi.stubEnv('LIBTMUX_DOCS_VERSION', 'next')
     expect(urls(linkProseMarkdown('Use `workspace.Parse` and `tmux.Server`.', 'go', 'workspace'))).toEqual([
-      '/go/next/workspace/reference/workspace-parse/', '/go/next/reference/tmux-server/',
+      '/go/next/workspace/reference/workspace-parse/',
+      '/go/next/reference/tmux-server/',
     ])
   })
 
   it('exports the architecture links that HTML renders, without changing programs or anchors', async () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'rs')
     vi.stubEnv('LIBTMUX_DOCS_VERSION', 'next')
-    const { content, frontmatter } = parseFrontmatter(readFileSync(new URL('../src/content/docs/topics/architecture.md', import.meta.url), 'utf8'))
+    const { content, frontmatter } = parseFrontmatter(
+      readFileSync(new URL('../src/content/docs/topics/architecture.md', import.meta.url), 'utf8'),
+    )
     const entry = { id: 'topics/architecture', body: content, data: frontmatter } as CollectionEntry<'docs'>
     const exported = llmsPage(entry, 'https://libtmux.org', '/en/rs/next/')
-    const renderer = await createMarkdownProcessor({ remarkPlugins: [remarkPortCode], rehypePlugins: [rehypeApiLinks], syntaxHighlight: false })
+    const renderer = await createMarkdownProcessor({
+      remarkPlugins: [remarkPortCode],
+      rehypePlugins: [rehypeApiLinks],
+      syntaxHighlight: false,
+    })
     const html = (await renderer.render(content)).code
-    const expected = [...html.matchAll(/<a\b[^>]*href="([^"]+)"[^>]*class="api-mention(?: api-mention--file)?"/g)]
-      .map((match) => new URL(match[1], 'https://libtmux.org').href)
+    const expected = [...html.matchAll(/<a\b[^>]*href="([^"]+)"[^>]*class="api-mention(?: api-mention--file)?"/g)].map(
+      (match) => new URL(match[1], 'https://libtmux.org').href,
+    )
     expect(expected.length).toBeGreaterThan(20)
     for (const href of expected) expect(urls(exported.body)).toContain(href)
     expect(exampleBytes(exported.body)).toEqual(exampleBytes(resolvePortCode(content, 'rs')))
     expect(exported.body).toContain('id="a-generated-data-table-under-a-hand-written-surface"')
     expect(exported.body).not.toMatch(/\| Port \||\*\*Rust\*\*|<!-- port:/)
     const inventory = JSON.parse(readFileSync(new URL('../src/data/api/rs.paths.json', import.meta.url), 'utf8'))
-    expect(urls(exported.body)).toContain(`https://github.com/${inventory.repo}/blob/${inventory.revision}/crates/libtmux/src/formats.rs`)
+    expect(urls(exported.body)).toContain(
+      `https://github.com/${inventory.repo}/blob/${inventory.revision}/crates/libtmux/src/formats.rs`,
+    )
   })
 
   it('rewrites angle destinations without corrupting parentheses or literal code', () => {
     const body = '[member](</reference/member(_:_:)>)\n\n`[literal](</other/>)`\n\n[ref]: </reference/member(_:_:)>'
-    const output = resolvePortCode(body, undefined, undefined, (href: string) => new URL(href, 'https://libtmux.org').href)
+    const output = resolvePortCode(
+      body,
+      undefined,
+      undefined,
+      (href: string) => new URL(href, 'https://libtmux.org').href,
+    )
     expect(urls(output)).toEqual(['https://libtmux.org/reference/member(_:_:)'])
     expect(output).toContain('`[literal](</other/>)`')
     expect(output).toContain('[ref]: <https://libtmux.org/reference/member(_:_:)>')
diff --git a/site/test/prose-port-sections.test.ts b/site/test/prose-port-sections.test.ts
index 991b5aaf9..5ef82814d 100644
--- a/site/test/prose-port-sections.test.ts
+++ b/site/test/prose-port-sections.test.ts
@@ -1,7 +1,13 @@
 import { afterEach, describe, expect, it, vi } from 'vitest'
 import { rehypeApiLinks } from '../src/plugins/rehype-api-links'
 
-type Element = { type: string; tagName?: string; value?: string; properties?: Record<string, unknown>; children?: Element[] }
+type Element = {
+  type: string
+  tagName?: string
+  value?: string
+  properties?: Record<string, unknown>
+  children?: Element[]
+}
 const text = (value: string): Element => ({ type: 'text', value })
 const element = (tagName: string, ...children: Element[]): Element => ({ type: 'element', tagName, children })
 
@@ -12,7 +18,10 @@ describe('API links in port sections', () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', '')
     vi.stubEnv('LIBTMUX_DOCS_PORT_DEFAULTS', '{"go":"stable"}')
     const paragraph = element('p', element('code', text('workspace.Parse')))
-    rehypeApiLinks()({ type: 'root', children: [paragraph] }, { data: { astro: { frontmatter: { port: 'go', product: 'workspace' } } } })
+    rehypeApiLinks()(
+      { type: 'root', children: [paragraph] },
+      { data: { astro: { frontmatter: { port: 'go', product: 'workspace' } } } },
+    )
     expect(paragraph.children?.[0].properties?.href).toBe('/go/stable/workspace/reference/workspace-parse/')
   })
 
@@ -21,7 +30,10 @@ describe('API links in port sections', () => {
     vi.stubEnv('LIBTMUX_DOCS_VERSION', 'v0.1')
     const product = element('p', element('code', text('workspace.Parse')))
     const core = element('p', element('code', text('tmux.Server')))
-    rehypeApiLinks()({ type: 'root', children: [product, core] }, { data: { astro: { frontmatter: { port: 'go', product: 'workspace' } } } })
+    rehypeApiLinks()(
+      { type: 'root', children: [product, core] },
+      { data: { astro: { frontmatter: { port: 'go', product: 'workspace' } } } },
+    )
     expect(product.children?.[0].properties?.href).toBe('/go/v0.1/workspace/reference/workspace-parse/')
     expect(core.children?.[0].properties?.href).toBe('/go/v0.1/reference/tmux-server/')
   })
@@ -34,10 +46,14 @@ describe('API links in port sections', () => {
     const tree = {
       type: 'root',
       children: [
-        element('h3', text('Python')), first,
-        element('h4', text('Implementation')), nested,
-        element('h3', text('Go')), other,
-        element('h3', text('Shared concepts')), shared,
+        element('h3', text('Python')),
+        first,
+        element('h4', text('Implementation')),
+        nested,
+        element('h3', text('Go')),
+        other,
+        element('h3', text('Shared concepts')),
+        shared,
       ],
     }
     rehypeApiLinks()(tree)
diff --git a/site/test/prune-versions.test.ts b/site/test/prune-versions.test.ts
index 343d68dee..4ce7c773c 100644
--- a/site/test/prune-versions.test.ts
+++ b/site/test/prune-versions.test.ts
@@ -27,7 +27,11 @@ describe('deployed version pruning', () => {
   }
 
   it('reads the directory prefixes out of an s3 listing', () => {
-    const listing = ['                           PRE latest/', '                           PRE v0.9/', '2026-01-01 12:00:00  1024 index.html'].join('\n')
+    const listing = [
+      '                           PRE latest/',
+      '                           PRE v0.9/',
+      '2026-01-01 12:00:00  1024 index.html',
+    ].join('\n')
     expect(prefixesFrom(listing)).toEqual(['latest', 'v0.9'])
   })
 
diff --git a/site/test/publication-provenance.test.ts b/site/test/publication-provenance.test.ts
index e128f0a08..4b7f24d2c 100644
--- a/site/test/publication-provenance.test.ts
+++ b/site/test/publication-provenance.test.ts
@@ -4,8 +4,18 @@ import { mkdtempSync, mkdirSync, readFileSync, rmSync, symlinkSync, writeFileSyn
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import {
-  RECORD, checkoutIdentity, digest, inventory, normalize, recordBuild, snapshot, unpackArchive,
-  validateDescriptor, verifyBuild, workflowIdentity, receipt,
+  RECORD,
+  checkoutIdentity,
+  digest,
+  inventory,
+  normalize,
+  recordBuild,
+  snapshot,
+  unpackArchive,
+  validateDescriptor,
+  verifyBuild,
+  workflowIdentity,
+  receipt,
 } from '../../scripts/publication-provenance.mjs'
 
 const directories: string[] = []
@@ -14,25 +24,45 @@ const temporary = () => {
   directories.push(directory)
   return directory
 }
-afterEach(() => { for (const directory of directories.splice(0)) rmSync(directory, { recursive: true, force: true }) })
+afterEach(() => {
+  for (const directory of directories.splice(0)) rmSync(directory, { recursive: true, force: true })
+})
 const sourceSha = 'a'.repeat(40)
 const publisherSha = 'b'.repeat(40)
-const inputs = () => ({ schema: 1, port: 'go', version: 'v1', locale: 'en',
+const inputs = () => ({
+  schema: 1,
+  port: 'go',
+  version: 'v1',
+  locale: 'en',
   docs: { repository: 'libtmux/docs', sha: publisherSha, dirty: false },
   sources: [{ product: 'core', repository: 'libtmux/libtmux-go', sha: sourceSha, dirty: false }],
 })
-const expected = () => ({ port: 'go', version: 'v1', locale: 'en', prefix: 'en/go/v1',
-  publisherRepository: 'libtmux/docs', publisherSha, sourceSha, repository: 'libtmux/libtmux-go',
-  name: 'docs-go-v1', runId: '42', attempt: 2,
+const expected = () => ({
+  port: 'go',
+  version: 'v1',
+  locale: 'en',
+  prefix: 'en/go/v1',
+  publisherRepository: 'libtmux/docs',
+  publisherSha,
+  sourceSha,
+  repository: 'libtmux/libtmux-go',
+  name: 'docs-go-v1',
+  runId: '42',
+  attempt: 2,
 })
-const descriptor = () => ({ schema: 1, sourceSha,
+const descriptor = () => ({
+  schema: 1,
+  sourceSha,
   artifact: { id: 17, name: 'docs-go-v1', sha256: 'c'.repeat(64) },
   run: { repository: 'libtmux/libtmux-go', id: '42', attempt: 1 },
 })
 function tree() {
   const root = temporary()
   mkdirSync(join(root, 'api'))
-  writeFileSync(join(root, 'index.html'), '<html><head><script src="/_shell/shell.js"></script></head><body>Go</body></html>')
+  writeFileSync(
+    join(root, 'index.html'),
+    '<html><head><script src="/_shell/shell.js"></script></head><body>Go</body></html>',
+  )
   writeFileSync(join(root, 'api', 'index.html'), '<!doctype html><meta http-equiv="refresh" content="0;url=../">')
   writeFileSync(join(root, '.build-data'), 'hidden files are covered too')
   recordBuild(root, inputs())
@@ -45,7 +75,8 @@ function rewrite(root: string, change: (value: ReturnType<typeof inputs> & { fil
 }
 function repository(name: string, source = 'committed input') {
   const directory = temporary()
-  const git = (...args: string[]) => execFileSync('git', ['-C', directory, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
+  const git = (...args: string[]) =>
+    execFileSync('git', ['-C', directory, ...args], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] }).trim()
   git('init')
   git('remote', 'add', 'origin', `https://github.com/${name}.git`)
   writeFileSync(join(directory, 'source.txt'), source)
@@ -56,17 +87,25 @@ function repository(name: string, source = 'committed input') {
 
 describe('deterministic build provenance', () => {
   it.each([
-    'https://github.com/libtmux/docs.git', 'git@github.com:libtmux/docs.git',
-    'ssh://git@github.com/libtmux/docs.git', 'git+ssh://git@github.com/libtmux/docs',
+    'https://github.com/libtmux/docs.git',
+    'git@github.com:libtmux/docs.git',
+    'ssh://git@github.com/libtmux/docs.git',
+    'git+ssh://git@github.com/libtmux/docs',
   ])('resolves a local GitHub origin %s', (origin) => {
     const checkout = repository('libtmux/docs')
     execFileSync('git', ['-C', checkout.directory, 'remote', 'set-url', 'origin', origin])
-    expect(checkoutIdentity(checkout.directory)).toEqual({ repository: 'libtmux/docs', sha: checkout.sha, dirty: false })
+    expect(checkoutIdentity(checkout.directory)).toEqual({
+      repository: 'libtmux/docs',
+      sha: checkout.sha,
+      dirty: false,
+    })
   })
 
   it.each([
-    'https://github.com.attacker.invalid/libtmux/docs.git', 'git+ssh://git@elsewhere/libtmux/docs.git',
-    'https://github.com/libtmux/docs/extra', 'https://github.com@elsewhere/libtmux/docs.git',
+    'https://github.com.attacker.invalid/libtmux/docs.git',
+    'git+ssh://git@elsewhere/libtmux/docs.git',
+    'https://github.com/libtmux/docs/extra',
+    'https://github.com@elsewhere/libtmux/docs.git',
   ])('rejects a non-GitHub or malformed origin %s', (origin) => {
     const checkout = repository('libtmux/docs')
     execFileSync('git', ['-C', checkout.directory, 'remote', 'set-url', 'origin', origin])
@@ -78,7 +117,11 @@ describe('deterministic build provenance', () => {
     const first = readFileSync(join(root, RECORD), 'utf8')
     recordBuild(root, inputs())
     expect(readFileSync(join(root, RECORD), 'utf8')).toBe(first)
-    expect(verifyBuild(root, expected()).files.map((file: { path: string }) => file.path)).toEqual(['.build-data', 'api/index.html', 'index.html'])
+    expect(verifyBuild(root, expected()).files.map((file: { path: string }) => file.path)).toEqual([
+      '.build-data',
+      'api/index.html',
+      'index.html',
+    ])
     for (const path of ['index.html', 'api/index.html']) {
       expect(readFileSync(join(root, path), 'utf8').match(/data-libtmux-provenance/g)).toHaveLength(1)
       expect(readFileSync(join(root, path), 'utf8')).toContain('/en/go/v1/build-provenance.json')
@@ -88,23 +131,31 @@ describe('deterministic build provenance', () => {
     expect(receipt(root, descriptor(), expected()).build.sha256).toBe(digest(readFileSync(join(root, RECORD))))
   })
 
-  it.each(['changed', 'missing', 'extra', 'duplicate', 'traversal', 'symlink', 'missing-record'])('rejects %s content', (mutation) => {
-    const root = tree()
-    if (mutation === 'changed') writeFileSync(join(root, 'index.html'), 'other bytes')
-    if (mutation === 'missing') rmSync(join(root, 'index.html'))
-    if (mutation === 'extra') writeFileSync(join(root, 'extra.html'), 'extra')
-    if (mutation === 'duplicate') rewrite(root, (value) => value.files.push(value.files[0]))
-    if (mutation === 'traversal') rewrite(root, (value) => { value.files[0] = { path: '../outside', size: 0, sha256: 'c'.repeat(64) } })
-    if (mutation === 'symlink') symlinkSync('/etc/passwd', join(root, 'outside'))
-    if (mutation === 'missing-record') rmSync(join(root, RECORD))
-    expect(() => verifyBuild(root, expected())).toThrow()
-  })
+  it.each(['changed', 'missing', 'extra', 'duplicate', 'traversal', 'symlink', 'missing-record'])(
+    'rejects %s content',
+    (mutation) => {
+      const root = tree()
+      if (mutation === 'changed') writeFileSync(join(root, 'index.html'), 'other bytes')
+      if (mutation === 'missing') rmSync(join(root, 'index.html'))
+      if (mutation === 'extra') writeFileSync(join(root, 'extra.html'), 'extra')
+      if (mutation === 'duplicate') rewrite(root, (value) => value.files.push(value.files[0]))
+      if (mutation === 'traversal')
+        rewrite(root, (value) => {
+          value.files[0] = { path: '../outside', size: 0, sha256: 'c'.repeat(64) }
+        })
+      if (mutation === 'symlink') symlinkSync('/etc/passwd', join(root, 'outside'))
+      if (mutation === 'missing-record') rmSync(join(root, RECORD))
+      expect(() => verifyBuild(root, expected())).toThrow()
+    },
+  )
 
   it('rejects a pre-normalization inventory even when it honestly hashes those old bytes', () => {
     const root = tree()
     const path = join(root, 'index.html')
     writeFileSync(path, readFileSync(path, 'utf8').replace('/en/_shell/', '/_shell/'))
-    rewrite(root, (value) => { value.files = inventory(root) })
+    rewrite(root, (value) => {
+      value.files = inventory(root)
+    })
     expect(() => verifyBuild(root, expected())).toThrow('content inventory differs')
   })
 
@@ -119,29 +170,41 @@ describe('deterministic build provenance', () => {
     expect(readFileSync(join(root, 'native.css'), 'utf8')).toBe('url(/en/_shell/a.css) url(/en/_shell/b.css)')
   })
 
-  it.each(['docs-dirty', 'source-dirty', 'docs-sha', 'source-sha', 'source-repository', 'missing-product'])('rejects %s input claims', (mutation) => {
-    const root = tree()
-    rewrite(root, (value) => {
-      if (mutation === 'docs-dirty') value.docs.dirty = true
-      if (mutation === 'source-dirty') value.sources[0].dirty = true
-      if (mutation === 'docs-sha') value.docs.sha = 'd'.repeat(40)
-      if (mutation === 'source-sha') value.sources[0].sha = 'd'.repeat(40)
-      if (mutation === 'source-repository') value.sources[0].repository = 'libtmux/libtmux-rs'
-      if (mutation === 'missing-product') value.sources = []
-    })
-    expect(() => verifyBuild(root, expected())).toThrow()
-  })
+  it.each(['docs-dirty', 'source-dirty', 'docs-sha', 'source-sha', 'source-repository', 'missing-product'])(
+    'rejects %s input claims',
+    (mutation) => {
+      const root = tree()
+      rewrite(root, (value) => {
+        if (mutation === 'docs-dirty') value.docs.dirty = true
+        if (mutation === 'source-dirty') value.sources[0].dirty = true
+        if (mutation === 'docs-sha') value.docs.sha = 'd'.repeat(40)
+        if (mutation === 'source-sha') value.sources[0].sha = 'd'.repeat(40)
+        if (mutation === 'source-repository') value.sources[0].repository = 'libtmux/libtmux-rs'
+        if (mutation === 'missing-product') value.sources = []
+      })
+      expect(() => verifyBuild(root, expected())).toThrow()
+    },
+  )
 
   it.each([
-    { port: 'rs' }, { version: 'v2' }, { repository: 'libtmux/libtmux-java' },
-    { prefix: 'en/rs/v1' }, { publisherSha: '' }, { publisherRepository: 'attacker/docs' },
+    { port: 'rs' },
+    { version: 'v2' },
+    { repository: 'libtmux/libtmux-java' },
+    { prefix: 'en/rs/v1' },
+    { publisherSha: '' },
+    { publisherRepository: 'attacker/docs' },
   ])('rejects wrong publisher/destination %j', (changed) => {
     expect(() => verifyBuild(tree(), { ...expected(), ...changed })).toThrow()
   })
 
   it.each([
-    { version: 'v1\nPROVENANCE_REVIEW_MARKER=1' }, { version: 'v1\n' }, { version: 'v1/other' }, { version: 'v1..2' },
-    { locale: 'en\nPROVENANCE_REVIEW_MARKER=1' }, { locale: 'en\n' }, { locale: '../en' },
+    { version: 'v1\nPROVENANCE_REVIEW_MARKER=1' },
+    { version: 'v1\n' },
+    { version: 'v1/other' },
+    { version: 'v1..2' },
+    { locale: 'en\nPROVENANCE_REVIEW_MARKER=1' },
+    { locale: 'en\n' },
+    { locale: '../en' },
   ])('rejects matching malformed build and destination metadata %j', (changed) => {
     const root = tree()
     rewrite(root, (value) => Object.assign(value, changed))
@@ -153,17 +216,29 @@ describe('deterministic build provenance', () => {
   it('gets actual Git HEADs and records dirty local inputs before generation', () => {
     const docs = repository('libtmux/docs')
     const source = repository('libtmux/libtmux-go')
-    const env = { LIBTMUX_DOCS_PORT: 'go', LIBTMUX_DOCS_VERSION: 'v1', LIBTMUX_DOCS_SOURCE_SHA: source.sha, LIBTMUX_DOCS_CHECKOUT_GO: source.directory }
+    const env = {
+      LIBTMUX_DOCS_PORT: 'go',
+      LIBTMUX_DOCS_VERSION: 'v1',
+      LIBTMUX_DOCS_SOURCE_SHA: source.sha,
+      LIBTMUX_DOCS_CHECKOUT_GO: source.directory,
+    }
     const clean = snapshot(docs.directory, env)
     expect(clean.docs).toEqual({ repository: 'libtmux/docs', sha: docs.sha, dirty: false })
-    expect(clean.sources[0]).toEqual({ product: 'core', repository: 'libtmux/libtmux-go', sha: source.sha, dirty: false })
+    expect(clean.sources[0]).toEqual({
+      product: 'core',
+      repository: 'libtmux/libtmux-go',
+      sha: source.sha,
+      dirty: false,
+    })
     writeFileSync(join(docs.directory, 'source.txt'), 'locally changed API model')
     writeFileSync(join(source.directory, 'new-input.txt'), 'untracked source')
     const dirty = snapshot(docs.directory, env)
     expect(dirty.docs.dirty).toBe(true)
     expect(dirty.sources[0].dirty).toBe(true)
     expect(clean.docs.dirty).toBe(false)
-    expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_SOURCE_SHA: 'f'.repeat(40) })).toThrow('actual checkout HEAD')
+    expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_SOURCE_SHA: 'f'.repeat(40) })).toThrow(
+      'actual checkout HEAD',
+    )
   })
 
   it('records all three Python checkouts at their actual revisions', () => {
@@ -173,8 +248,12 @@ describe('deterministic build provenance', () => {
     const mcp = repository('tmux-python/libtmux-mcp')
     writeFileSync(join(mcp.directory, 'source.txt'), 'local companion edit')
     const captured = snapshot(docs.directory, {
-      LIBTMUX_DOCS_PORT: 'py', LIBTMUX_DOCS_VERSION: 'latest', LIBTMUX_DOCS_SOURCE_SHA: core.sha,
-      LIBTMUX_DOCS_CHECKOUT_PY: core.directory, LIBTMUX_DOCS_WORKSPACE_PY: workspace.directory, LIBTMUX_DOCS_MCP_PY: mcp.directory,
+      LIBTMUX_DOCS_PORT: 'py',
+      LIBTMUX_DOCS_VERSION: 'latest',
+      LIBTMUX_DOCS_SOURCE_SHA: core.sha,
+      LIBTMUX_DOCS_CHECKOUT_PY: core.directory,
+      LIBTMUX_DOCS_WORKSPACE_PY: workspace.directory,
+      LIBTMUX_DOCS_MCP_PY: mcp.directory,
     })
     expect(captured.sources).toEqual([
       { product: 'core', repository: 'tmux-python/libtmux', sha: core.sha, dirty: false },
@@ -183,93 +262,174 @@ describe('deterministic build provenance', () => {
     ])
   })
 
-  it.each(['ruby', 'lua', 'powershell', 'julia'])('records %s source and native exporter as separate clean inputs', (port) => {
-    const docs = repository('libtmux/docs')
-    const name = `libtmux/libtmux-${port}`
-    const source = repository(name)
-    const generator = repository(name, 'exporter from another revision')
-    const env = { LIBTMUX_DOCS_PORT: port, LIBTMUX_DOCS_VERSION: 'v1', LIBTMUX_DOCS_SOURCE_SHA: source.sha,
-      [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: source.directory, LIBTMUX_DOCS_GENERATOR_CHECKOUT: generator.directory }
-    const captured = snapshot(docs.directory, env)
-    expect(captured.sources).toEqual([{ product: 'core', repository: name, sha: source.sha, dirty: false }])
-    expect(captured.nativeGenerator).toEqual({ repository: name, sha: generator.sha, dirty: false })
-    expect(generator.sha).not.toBe(source.sha)
-    const root = tree()
-    recordBuild(root, captured)
-    const destination = { ...expected(), port, prefix: `en/${port}/v1`, repository: name, sourceSha: source.sha, publisherSha: docs.sha }
-    expect(verifyBuild(root, destination).nativeGenerator.sha).toBe(generator.sha)
-    writeFileSync(join(generator.directory, 'source.txt'), 'local exporter edit')
-    recordBuild(root, snapshot(docs.directory, env))
-    expect(() => verifyBuild(root, destination)).toThrow('native generator inputs are dirty')
-    expect(snapshot(docs.directory, { ...env, LIBTMUX_DOCS_GENERATOR_CHECKOUT: source.directory }).nativeGenerator?.sha).toBe(source.sha)
-  })
+  it.each(['ruby', 'lua', 'powershell', 'julia'])(
+    'records %s source and native exporter as separate clean inputs',
+    (port) => {
+      const docs = repository('libtmux/docs')
+      const name = `libtmux/libtmux-${port}`
+      const source = repository(name)
+      const generator = repository(name, 'exporter from another revision')
+      const env = {
+        LIBTMUX_DOCS_PORT: port,
+        LIBTMUX_DOCS_VERSION: 'v1',
+        LIBTMUX_DOCS_SOURCE_SHA: source.sha,
+        [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: source.directory,
+        LIBTMUX_DOCS_GENERATOR_CHECKOUT: generator.directory,
+      }
+      const captured = snapshot(docs.directory, env)
+      expect(captured.sources).toEqual([{ product: 'core', repository: name, sha: source.sha, dirty: false }])
+      expect(captured.nativeGenerator).toEqual({ repository: name, sha: generator.sha, dirty: false })
+      expect(generator.sha).not.toBe(source.sha)
+      const root = tree()
+      recordBuild(root, captured)
+      const destination = {
+        ...expected(),
+        port,
+        prefix: `en/${port}/v1`,
+        repository: name,
+        sourceSha: source.sha,
+        publisherSha: docs.sha,
+      }
+      expect(verifyBuild(root, destination).nativeGenerator.sha).toBe(generator.sha)
+      writeFileSync(join(generator.directory, 'source.txt'), 'local exporter edit')
+      recordBuild(root, snapshot(docs.directory, env))
+      expect(() => verifyBuild(root, destination)).toThrow('native generator inputs are dirty')
+      expect(
+        snapshot(docs.directory, { ...env, LIBTMUX_DOCS_GENERATOR_CHECKOUT: source.directory }).nativeGenerator?.sha,
+      ).toBe(source.sha)
+    },
+  )
 
-  it.each(['ruby', 'lua', 'powershell', 'julia'].flatMap((port) =>
-    ['missing', 'repository', 'sha', 'dirty', 'missing-dirty'].map((mutation) => [port, mutation]),
-  ))('rejects %s native exporter metadata with %s', (port, mutation) => {
+  it.each(
+    ['ruby', 'lua', 'powershell', 'julia'].flatMap((port) =>
+      ['missing', 'repository', 'sha', 'dirty', 'missing-dirty'].map((mutation) => [port, mutation]),
+    ),
+  )('rejects %s native exporter metadata with %s', (port, mutation) => {
     const root = tree()
     const repository = `libtmux/libtmux-${port}`
-    const record = { ...inputs(), port, sources: [{ product: 'core', repository, sha: sourceSha, dirty: false }],
-      nativeGenerator: { repository, sha: 'e'.repeat(40), dirty: false } }
+    const record = {
+      ...inputs(),
+      port,
+      sources: [{ product: 'core', repository, sha: sourceSha, dirty: false }],
+      nativeGenerator: { repository, sha: 'e'.repeat(40), dirty: false },
+    }
     if (mutation === 'repository') record.nativeGenerator.repository = 'someone/other-exporter'
     if (mutation === 'sha') record.nativeGenerator.sha = 'master'
     if (mutation === 'dirty') record.nativeGenerator.dirty = true
     if (mutation === 'missing-dirty') Reflect.deleteProperty(record.nativeGenerator, 'dirty')
     if (mutation === 'missing') Reflect.deleteProperty(record, 'nativeGenerator')
     recordBuild(root, record)
-    expect(() => verifyBuild(root, { ...expected(), port, prefix: `en/${port}/v1`, repository })).toThrow(/native generator/)
+    expect(() => verifyBuild(root, { ...expected(), port, prefix: `en/${port}/v1`, repository })).toThrow(
+      /native generator/,
+    )
   })
 
   it('rejects a native exporter claim on a shared-generator port', () => {
     const root = tree()
-    recordBuild(root, { ...inputs(), nativeGenerator: { repository: 'libtmux/libtmux-go', sha: sourceSha, dirty: false } })
+    recordBuild(root, {
+      ...inputs(),
+      nativeGenerator: { repository: 'libtmux/libtmux-go', sha: sourceSha, dirty: false },
+    })
     expect(() => verifyBuild(root, expected())).toThrow('unexpected native generator')
   })
 
-  it.each(['ruby', 'lua', 'powershell', 'julia'])('rechecks the %s exporter HEAD when consuming the captured inputs', (port) => {
-    const docs = repository('libtmux/docs')
-    const source = repository(`libtmux/libtmux-${port}`)
-    const generator = repository(`libtmux/libtmux-${port}`, 'separate native exporter')
-    const env = { LIBTMUX_DOCS_PORT: port, LIBTMUX_DOCS_VERSION: 'v1', LIBTMUX_DOCS_SOURCE_SHA: source.sha,
-      [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: source.directory, LIBTMUX_DOCS_GENERATOR_CHECKOUT: generator.directory }
-    const file = join(temporary(), 'before-native-generator.json')
-    writeFileSync(file, JSON.stringify(snapshot(docs.directory, env)))
-    writeFileSync(join(generator.directory, 'generated-output.json'), '{}')
-    expect(snapshot(docs.directory, { ...env, LIBTMUX_DOCS_INPUT_SNAPSHOT: file }).nativeGenerator?.dirty).toBe(false)
-    writeFileSync(join(generator.directory, 'source.txt'), 'new committed native exporter')
-    execFileSync('git', ['-C', generator.directory, '-c', 'user.name=Test', '-c', 'user.email=test@example.org', 'commit', '-am', 'change exporter'])
-    expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_INPUT_SNAPSHOT: file })).toThrow('no longer matches checkout revisions')
-    expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_GENERATOR_CHECKOUT: docs.directory })).toThrow('native generator repository')
-  })
+  it.each(['ruby', 'lua', 'powershell', 'julia'])(
+    'rechecks the %s exporter HEAD when consuming the captured inputs',
+    (port) => {
+      const docs = repository('libtmux/docs')
+      const source = repository(`libtmux/libtmux-${port}`)
+      const generator = repository(`libtmux/libtmux-${port}`, 'separate native exporter')
+      const env = {
+        LIBTMUX_DOCS_PORT: port,
+        LIBTMUX_DOCS_VERSION: 'v1',
+        LIBTMUX_DOCS_SOURCE_SHA: source.sha,
+        [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: source.directory,
+        LIBTMUX_DOCS_GENERATOR_CHECKOUT: generator.directory,
+      }
+      const file = join(temporary(), 'before-native-generator.json')
+      writeFileSync(file, JSON.stringify(snapshot(docs.directory, env)))
+      writeFileSync(join(generator.directory, 'generated-output.json'), '{}')
+      expect(snapshot(docs.directory, { ...env, LIBTMUX_DOCS_INPUT_SNAPSHOT: file }).nativeGenerator?.dirty).toBe(false)
+      writeFileSync(join(generator.directory, 'source.txt'), 'new committed native exporter')
+      execFileSync('git', [
+        '-C',
+        generator.directory,
+        '-c',
+        'user.name=Test',
+        '-c',
+        'user.email=test@example.org',
+        'commit',
+        '-am',
+        'change exporter',
+      ])
+      expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_INPUT_SNAPSHOT: file })).toThrow(
+        'no longer matches checkout revisions',
+      )
+      expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_GENERATOR_CHECKOUT: docs.directory })).toThrow(
+        'native generator repository',
+      )
+    },
+  )
 
-  it.each(['ruby', 'lua', 'powershell', 'julia'])('can build an explicitly selected %s fork but rejects its publication', (port) => {
-    const docs = repository('libtmux/docs')
-    const source = repository(`contributor/libtmux-${port}`)
-    const generator = repository(`libtmux/libtmux-${port}`)
-    const env = { LIBTMUX_DOCS_PORT: port, LIBTMUX_DOCS_VERSION: 'v1', LIBTMUX_DOCS_SOURCE_SHA: source.sha,
-      [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: source.directory, LIBTMUX_DOCS_GENERATOR_CHECKOUT: generator.directory }
-    expect(() => snapshot(docs.directory, env)).toThrow('source repository must be libtmux/')
-    const captured = snapshot(docs.directory, { ...env, LIBTMUX_DOCS_SOURCE_REPOSITORY: `contributor/libtmux-${port}` })
-    const root = tree()
-    recordBuild(root, captured)
-    const destination = { ...expected(), port, prefix: `en/${port}/v1`, repository: `libtmux/libtmux-${port}`, publisherSha: docs.sha, sourceSha: source.sha }
-    expect(() => verifyBuild(root, destination)).toThrow('invalid source repository/SHA')
-    expect(() => verifyBuild(root, { ...destination, repository: `contributor/libtmux-${port}` })).toThrow('does not own this port')
-  })
+  it.each(['ruby', 'lua', 'powershell', 'julia'])(
+    'can build an explicitly selected %s fork but rejects its publication',
+    (port) => {
+      const docs = repository('libtmux/docs')
+      const source = repository(`contributor/libtmux-${port}`)
+      const generator = repository(`libtmux/libtmux-${port}`)
+      const env = {
+        LIBTMUX_DOCS_PORT: port,
+        LIBTMUX_DOCS_VERSION: 'v1',
+        LIBTMUX_DOCS_SOURCE_SHA: source.sha,
+        [`LIBTMUX_DOCS_CHECKOUT_${port.toUpperCase()}`]: source.directory,
+        LIBTMUX_DOCS_GENERATOR_CHECKOUT: generator.directory,
+      }
+      expect(() => snapshot(docs.directory, env)).toThrow('source repository must be libtmux/')
+      const captured = snapshot(docs.directory, {
+        ...env,
+        LIBTMUX_DOCS_SOURCE_REPOSITORY: `contributor/libtmux-${port}`,
+      })
+      const root = tree()
+      recordBuild(root, captured)
+      const destination = {
+        ...expected(),
+        port,
+        prefix: `en/${port}/v1`,
+        repository: `libtmux/libtmux-${port}`,
+        publisherSha: docs.sha,
+        sourceSha: source.sha,
+      }
+      expect(() => verifyBuild(root, destination)).toThrow('invalid source repository/SHA')
+      expect(() => verifyBuild(root, { ...destination, repository: `contributor/libtmux-${port}` })).toThrow(
+        'does not own this port',
+      )
+    },
+  )
 
   it('allows a wrapper only through its owning library repository', () => {
     const root = tree()
-    const wrapper = { ...inputs(), port: 'kotlin', sources: [{ product: 'core', repository: 'libtmux/libtmux-java', sha: sourceSha, dirty: false }] }
+    const wrapper = {
+      ...inputs(),
+      port: 'kotlin',
+      sources: [{ product: 'core', repository: 'libtmux/libtmux-java', sha: sourceSha, dirty: false }],
+    }
     recordBuild(root, wrapper)
     const destination = { ...expected(), port: 'kotlin', prefix: 'en/kotlin/v1', repository: 'libtmux/libtmux-java' }
     expect(verifyBuild(root, destination).port).toBe('kotlin')
-    expect(() => verifyBuild(root, { ...destination, repository: 'libtmux/libtmux-go' })).toThrow('does not own this port')
+    expect(() => verifyBuild(root, { ...destination, repository: 'libtmux/libtmux-go' })).toThrow(
+      'does not own this port',
+    )
   })
 
   it('rechecks every HEAD when consuming a snapshot taken before native generation', () => {
     const docs = repository('libtmux/docs')
     const source = repository('libtmux/libtmux-go')
-    const env = { LIBTMUX_DOCS_PORT: 'go', LIBTMUX_DOCS_VERSION: 'v1', LIBTMUX_DOCS_SOURCE_SHA: source.sha, LIBTMUX_DOCS_CHECKOUT_GO: source.directory }
+    const env = {
+      LIBTMUX_DOCS_PORT: 'go',
+      LIBTMUX_DOCS_VERSION: 'v1',
+      LIBTMUX_DOCS_SOURCE_SHA: source.sha,
+      LIBTMUX_DOCS_CHECKOUT_GO: source.directory,
+    }
     const file = join(temporary(), 'before-generators.json')
     writeFileSync(file, JSON.stringify(snapshot(docs.directory, env)))
     writeFileSync(join(source.directory, 'generated.json'), 'native output')
@@ -277,7 +437,9 @@ describe('deterministic build provenance', () => {
     const captured = JSON.parse(readFileSync(file, 'utf8'))
     captured.sources[0].sha = 'd'.repeat(40)
     writeFileSync(file, JSON.stringify(captured))
-    expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_INPUT_SNAPSHOT: file })).toThrow('no longer matches checkout revisions')
+    expect(() => snapshot(docs.directory, { ...env, LIBTMUX_DOCS_INPUT_SNAPSHOT: file })).toThrow(
+      'no longer matches checkout revisions',
+    )
   })
 
   it('fails clearly when reusable workflow identity contexts are unavailable', () => {
@@ -290,29 +452,45 @@ describe('artifact identity and safe archive extraction', () => {
   it('accepts a completed builder attempt when only publishing is rerun', () => {
     expect(validateDescriptor(descriptor(), expected()).run.attempt).toBe(1)
   })
-  it.each(['name', 'id', 'digest', 'repository', 'run', 'future-attempt', 'source', 'schema'])('rejects a wrong %s descriptor', (mutation) => {
-    const value = descriptor()
-    if (mutation === 'name') value.artifact.name = 'docs-rs-v1'
-    if (mutation === 'id') value.artifact.id = 0
-    if (mutation === 'digest') value.artifact.sha256 = 'bad'
-    if (mutation === 'repository') value.run.repository = 'libtmux/libtmux-rs'
-    if (mutation === 'run') value.run.id = '43'
-    if (mutation === 'future-attempt') value.run.attempt = 3
-    if (mutation === 'source') value.sourceSha = 'main'
-    if (mutation === 'schema') value.schema = 2
-    expect(() => validateDescriptor(value, expected())).toThrow()
-  })
+  it.each(['name', 'id', 'digest', 'repository', 'run', 'future-attempt', 'source', 'schema'])(
+    'rejects a wrong %s descriptor',
+    (mutation) => {
+      const value = descriptor()
+      if (mutation === 'name') value.artifact.name = 'docs-rs-v1'
+      if (mutation === 'id') value.artifact.id = 0
+      if (mutation === 'digest') value.artifact.sha256 = 'bad'
+      if (mutation === 'repository') value.run.repository = 'libtmux/libtmux-rs'
+      if (mutation === 'run') value.run.id = '43'
+      if (mutation === 'future-attempt') value.run.attempt = 3
+      if (mutation === 'source') value.sourceSha = 'main'
+      if (mutation === 'schema') value.schema = 2
+      expect(() => validateDescriptor(value, expected())).toThrow()
+    },
+  )
   function archive(entry = 'index.html', mode = 'file') {
     const directory = temporary()
     const file = join(directory, 'download.zip')
-    execFileSync('python3', ['-c', `import sys, zipfile
+    execFileSync(
+      'python3',
+      [
+        '-c',
+        `import sys, zipfile
 with zipfile.ZipFile(sys.argv[1], 'w') as archive:
     info = zipfile.ZipInfo(sys.argv[2])
     if sys.argv[3] == 'symlink': info.external_attr = 0o120777 << 16
     archive.writestr(info, 'hello')
     if sys.argv[3] == 'duplicate': archive.writestr(info, 'other')
-`, file, entry, mode], { stdio: 'pipe' })
-    return { directory, value: { ...descriptor(), artifact: { ...descriptor().artifact, sha256: digest(readFileSync(file)) } } }
+`,
+        file,
+        entry,
+        mode,
+      ],
+      { stdio: 'pipe' },
+    )
+    return {
+      directory,
+      value: { ...descriptor(), artifact: { ...descriptor().artifact, sha256: digest(readFileSync(file)) } },
+    }
   }
   it('checks the actual ZIP digest against the upload output before extraction', () => {
     const { directory, value } = archive()
@@ -321,7 +499,12 @@ with zipfile.ZipFile(sys.argv[1], 'w') as archive:
     expect(readFileSync(join(out, 'index.html'), 'utf8')).toBe('hello')
     expect(() => unpackArchive(directory, descriptor(), join(temporary(), 'bad'))).toThrow('archive SHA256 differs')
   })
-  it.each([['../outside', 'file'], ['/absolute', 'file'], ['link', 'symlink'], ['same', 'duplicate']])('rejects unsafe archive %s (%s)', (entry, mode) => {
+  it.each([
+    ['../outside', 'file'],
+    ['/absolute', 'file'],
+    ['link', 'symlink'],
+    ['same', 'duplicate'],
+  ])('rejects unsafe archive %s (%s)', (entry, mode) => {
     const { directory, value } = archive(entry, mode)
     expect(() => unpackArchive(directory, value, join(temporary(), 'dist'))).toThrow()
   })
diff --git a/site/test/publish-default-versions.test.ts b/site/test/publish-default-versions.test.ts
index ed48a28e3..ec0ea61d3 100644
--- a/site/test/publish-default-versions.test.ts
+++ b/site/test/publish-default-versions.test.ts
@@ -24,31 +24,43 @@ function fixture(defaultVersion: Record<string, string>, storeItems: { Key: stri
   writeFileSync(join(directory, 'store.json'), JSON.stringify({ Items: storeItems }))
   const executable = join(directory, 'bin/aws')
   mkdirSync(dirname(executable), { recursive: true })
-  writeFileSync(executable, [
-    '#!/bin/bash',
-    'printf \'%s\\t\' "$@" >> "$AWS_RECORD"; echo >> "$AWS_RECORD"',
-    'if [[ "$2" == "${FAIL:-}" ]]; then echo "An error occurred (AccessDenied)" >&2; exit 254; fi',
-    'if [[ "$2" == describe-key-value-store ]]; then echo \'{"ETag":"etag-1"}\'',
-    'elif [[ "$2" == list-keys ]]; then cat "$STORE_FILE"; fi',
-  ].join('\n') + '\n', { mode: 0o755 })
+  writeFileSync(
+    executable,
+    [
+      '#!/bin/bash',
+      'printf \'%s\\t\' "$@" >> "$AWS_RECORD"; echo >> "$AWS_RECORD"',
+      'if [[ "$2" == "${FAIL:-}" ]]; then echo "An error occurred (AccessDenied)" >&2; exit 254; fi',
+      'if [[ "$2" == describe-key-value-store ]]; then echo \'{"ETag":"etag-1"}\'',
+      'elif [[ "$2" == list-keys ]]; then cat "$STORE_FILE"; fi',
+    ].join('\n') + '\n',
+    { mode: 0o755 },
+  )
   return directory
 }
 
 function publish(directory: string, env: Record<string, string> = {}) {
   const record = join(directory, 'aws.tsv')
   const result = spawnSync('bash', [script], {
-    cwd: directory, encoding: 'utf8', timeout: 10000,
+    cwd: directory,
+    encoding: 'utf8',
+    timeout: 10000,
     env: {
-      ...process.env, PATH: `${join(directory, 'bin')}:${process.env.PATH}`,
-      KVS_ARN, AWS_RECORD: record, STORE_FILE: join(directory, 'store.json'), ...env,
+      ...process.env,
+      PATH: `${join(directory, 'bin')}:${process.env.PATH}`,
+      KVS_ARN,
+      AWS_RECORD: record,
+      STORE_FILE: join(directory, 'store.json'),
+      ...env,
     },
   })
   expect(result.error, result.stderr).toBeUndefined()
   // Split without trimming: the recorder ends each line with a tab, and a
   // whole-file trim would drop the last call's final argument.
   const commands = existsSync(record)
-    ? readFileSync(record, 'utf8').split('\n').filter((line) => line.length > 0)
-      .map((line) => line.split('\t').slice(0, -1))
+    ? readFileSync(record, 'utf8')
+        .split('\n')
+        .filter((line) => line.length > 0)
+        .map((line) => line.split('\t').slice(0, -1))
     : []
   return { ...result, commands }
 }
diff --git a/site/test/publish-plan.test.ts b/site/test/publish-plan.test.ts
index d53038741..364e6ad69 100644
--- a/site/test/publish-plan.test.ts
+++ b/site/test/publish-plan.test.ts
@@ -10,8 +10,19 @@ import { PORTS } from '../src/lib/ports'
 const workflow = readFileSync(new URL('../../.github/workflows/publish.yml', import.meta.url), 'utf8')
 
 const catalog = [
-  { slug: 'py', repo: 'tmux-python/libtmux', tagGrammar: 'pep440', docsDispatch: { workflow: 'docs.yml', ref: 'docs-site-deploy' } },
-  { slug: 'rs', repo: 'libtmux/libtmux-rs', tagPrefix: 'libtmux@', tagGrammar: 'semver', docsDispatch: { workflow: 'docs.yml' } },
+  {
+    slug: 'py',
+    repo: 'tmux-python/libtmux',
+    tagGrammar: 'pep440',
+    docsDispatch: { workflow: 'docs.yml', ref: 'docs-site-deploy' },
+  },
+  {
+    slug: 'rs',
+    repo: 'libtmux/libtmux-rs',
+    tagPrefix: 'libtmux@',
+    tagGrammar: 'semver',
+    docsDispatch: { workflow: 'docs.yml' },
+  },
   { slug: 'go', repo: 'libtmux/libtmux-go', tagGrammar: 'semver', docsDispatch: { workflow: 'docs.yml' } },
   { slug: 'swift', repo: 'libtmux/libtmux-swift', tagGrammar: 'semver', docsDispatch: { workflow: 'docs.yml' } },
 ]
@@ -52,44 +63,106 @@ describe('publish plan', () => {
     expect(rows(run({ ports: 'go', ref: 'v1.9.0', version: 'v1.9.0', versionKind: 'tag' }))).toEqual([
       ['go', 'v1.9.0', 'v1.9.0', 'tag', false, ''],
     ])
-    expect(rows(run({ ports: 'go', ref: 'v1.9.0', version: 'stable', versionKind: 'alias', resolvesTo: 'v1.9.0', isDefault: true })))
-      .toEqual([['go', 'v1.9.0', 'stable', 'alias', true, 'v1.9.0']])
+    expect(
+      rows(
+        run({
+          ports: 'go',
+          ref: 'v1.9.0',
+          version: 'stable',
+          versionKind: 'alias',
+          resolvesTo: 'v1.9.0',
+          isDefault: true,
+        }),
+      ),
+    ).toEqual([['go', 'v1.9.0', 'stable', 'alias', true, 'v1.9.0']])
   })
 
   it('selects each parent and wrapper once through its owning repository', () => {
     const family = [
-      { slug: 'java', repo: 'libtmux/libtmux-java', tagGrammar: 'semver', docsDispatch: { workflow: 'docs.yml', language: 'java' } },
-      { slug: 'kotlin', repo: 'libtmux/libtmux-java', tagGrammar: 'semver', parentLibrary: { slug: 'java' }, docsDispatch: { workflow: 'docs.yml', language: 'kotlin' } },
-      { slug: 'scala', repo: 'libtmux/libtmux-java', tagGrammar: 'semver', parentLibrary: { slug: 'java' }, docsDispatch: { workflow: 'docs.yml', language: 'scala' } },
-      { slug: 'csharp', repo: 'libtmux/libtmux-dotnet', tagGrammar: 'semver', docsDispatch: { workflow: 'docs.yml', language: 'csharp' } },
-      { slug: 'fsharp', repo: 'libtmux/libtmux-dotnet', tagGrammar: 'semver', parentLibrary: { slug: 'csharp' }, docsDispatch: { workflow: 'docs.yml', language: 'fsharp' } },
+      {
+        slug: 'java',
+        repo: 'libtmux/libtmux-java',
+        tagGrammar: 'semver',
+        docsDispatch: { workflow: 'docs.yml', language: 'java' },
+      },
+      {
+        slug: 'kotlin',
+        repo: 'libtmux/libtmux-java',
+        tagGrammar: 'semver',
+        parentLibrary: { slug: 'java' },
+        docsDispatch: { workflow: 'docs.yml', language: 'kotlin' },
+      },
+      {
+        slug: 'scala',
+        repo: 'libtmux/libtmux-java',
+        tagGrammar: 'semver',
+        parentLibrary: { slug: 'java' },
+        docsDispatch: { workflow: 'docs.yml', language: 'scala' },
+      },
+      {
+        slug: 'csharp',
+        repo: 'libtmux/libtmux-dotnet',
+        tagGrammar: 'semver',
+        docsDispatch: { workflow: 'docs.yml', language: 'csharp' },
+      },
+      {
+        slug: 'fsharp',
+        repo: 'libtmux/libtmux-dotnet',
+        tagGrammar: 'semver',
+        parentLibrary: { slug: 'csharp' },
+        docsDispatch: { workflow: 'docs.yml', language: 'fsharp' },
+      },
     ]
     const lookups: string[] = []
-    const entries = plan({ ports: 'all', ref: 'latest' }, [...catalog, ...family], (repo) => {
-      lookups.push(repo)
-      return lookup(repo)
-    }, versions)
+    const entries = plan(
+      { ports: 'all', ref: 'latest' },
+      [...catalog, ...family],
+      (repo) => {
+        lookups.push(repo)
+        return lookup(repo)
+      },
+      versions,
+    )
     expect(lookups).toHaveLength(6)
     expect(new Set(lookups).size).toBe(6)
     expect(entries.map((entry) => [entry.port, entry.language])).toEqual([
-      ['py', ''], ['rs', ''], ['go', ''], ['swift', ''],
-      ['java', 'java'], ['kotlin', 'kotlin'], ['scala', 'scala'], ['csharp', 'csharp'], ['fsharp', 'fsharp'],
+      ['py', ''],
+      ['rs', ''],
+      ['go', ''],
+      ['swift', ''],
+      ['java', 'java'],
+      ['kotlin', 'kotlin'],
+      ['scala', 'scala'],
+      ['csharp', 'csharp'],
+      ['fsharp', 'fsharp'],
     ])
     expect(plan({ ports: 'kotlin,fsharp', ref: 'latest' }, family, lookup, versions)).toMatchObject([
       { port: 'kotlin', repo: 'libtmux/libtmux-java', language: 'kotlin' },
       { port: 'fsharp', repo: 'libtmux/libtmux-dotnet', language: 'fsharp' },
     ])
-    expect(plan({ ports: 'scala', ref: 'v0.1.0', version: 'v0.1.0', versionKind: 'tag' }, family, lookup, versions))
-      .toMatchObject([{ language: 'scala', sourceRef: 'v0.1.0' }])
+    expect(
+      plan({ ports: 'scala', ref: 'v0.1.0', version: 'v0.1.0', versionKind: 'tag' }, family, lookup, versions),
+    ).toMatchObject([{ language: 'scala', sourceRef: 'v0.1.0' }])
   })
 
-  it.each(['master', 'feature/docs', 'abc1234567890123456789012345678901234567'])('keeps Python source %s separate from its reviewed caller', (ref) => {
-    expect(run({ ports: 'py', ref, version: 'review', versionKind: 'trunk' })).toMatchObject([{
-      port: 'py', repo: 'tmux-python/libtmux', repoOwner: 'tmux-python', repoName: 'libtmux',
-      workflow: 'docs.yml', dispatchRef: 'docs-site-deploy', sourceRef: ref, language: '',
-    }])
-    expect(run({ ports: 'py' })).toMatchObject([{ dispatchRef: 'docs-site-deploy', sourceRef: 'master' }])
-  })
+  it.each(['master', 'feature/docs', 'abc1234567890123456789012345678901234567'])(
+    'keeps Python source %s separate from its reviewed caller',
+    (ref) => {
+      expect(run({ ports: 'py', ref, version: 'review', versionKind: 'trunk' })).toMatchObject([
+        {
+          port: 'py',
+          repo: 'tmux-python/libtmux',
+          repoOwner: 'tmux-python',
+          repoName: 'libtmux',
+          workflow: 'docs.yml',
+          dispatchRef: 'docs-site-deploy',
+          sourceRef: ref,
+          language: '',
+        },
+      ])
+      expect(run({ ports: 'py' })).toMatchObject([{ dispatchRef: 'docs-site-deploy', sourceRef: 'master' }])
+    },
+  )
 
   it('shows the reviewed caller independently from the source in its dry-run summary', () => {
     const text = summary(run({ ports: 'py', ref: 'feature/docs', version: 'review', versionKind: 'trunk' }), true)
@@ -106,24 +179,42 @@ describe('publish plan', () => {
       expect(entry).toMatchObject({
         workflow: port.docsDispatch!.workflow,
         dispatchRef: port.docsDispatch!.ref ?? 'master',
-        repoOwner: port.repo.split('/')[0], repoName: port.repo.split('/')[1], sourceRef: 'master',
+        repoOwner: port.repo.split('/')[0],
+        repoName: port.repo.split('/')[1],
+        sourceRef: 'master',
       })
     }
   })
 
   it('requires explicit dispatch metadata even for a repository in the libtmux organization', () => {
     const unsupported = [{ slug: 'unconfigured', repo: 'libtmux/new-port', tagGrammar: 'semver' }]
-    expect(() => plan({ ports: 'unconfigured', ref: 'latest' }, unsupported, lookup, versions))
-      .toThrow('unconfigured has no dispatchable docs workflow')
+    expect(() => plan({ ports: 'unconfigured', ref: 'latest' }, unsupported, lookup, versions)).toThrow(
+      'unconfigured has no dispatchable docs workflow',
+    )
   })
 
-  it.each(['powershell', 'julia'])('dispatches %s through its owning repository while keeping source selection separate', (slug) => {
-    expect(plan({ ports: slug, ref: 'reviewed-native-source', version: 'latest', versionKind: 'trunk' }, PORTS, lookup, versions))
-      .toMatchObject([{
-        port: slug, repo: `libtmux/libtmux-${slug}`, workflow: 'docs.yml',
-        dispatchRef: 'master', sourceRef: 'reviewed-native-source', language: '',
-      }])
-  })
+  it.each(['powershell', 'julia'])(
+    'dispatches %s through its owning repository while keeping source selection separate',
+    (slug) => {
+      expect(
+        plan(
+          { ports: slug, ref: 'reviewed-native-source', version: 'latest', versionKind: 'trunk' },
+          PORTS,
+          lookup,
+          versions,
+        ),
+      ).toMatchObject([
+        {
+          port: slug,
+          repo: `libtmux/libtmux-${slug}`,
+          workflow: 'docs.yml',
+          dispatchRef: 'master',
+          sourceRef: 'reviewed-native-source',
+          language: '',
+        },
+      ])
+    },
+  )
 
   it.each([
     { repo: 'libtmux/libtmux-go/other' },
@@ -132,8 +223,9 @@ describe('publish plan', () => {
     { docsDispatch: { workflow: 'docs.yml', ref: 'master\nother' } },
     { docsDispatch: { workflow: 'docs.yml', language: 'java' } },
   ])('rejects malformed or cross-language dispatch metadata %j', (change) => {
-    expect(() => plan({ ports: 'go', ref: 'latest' }, [{ ...catalog[2], ...change }], lookup, versions))
-      .toThrow(/invalid repository|invalid docs workflow|must select itself/)
+    expect(() => plan({ ports: 'go', ref: 'latest' }, [{ ...catalog[2], ...change }], lookup, versions)).toThrow(
+      /invalid repository|invalid docs workflow|must select itself/,
+    )
   })
 
   it('refuses what it cannot dispatch or publish', () => {
@@ -171,24 +263,43 @@ describe('publish workflow', () => {
   it.each([
     { repo: 'tmux-python/libtmux', dispatchRef: 'docs-site-deploy', language: '' },
     ...['', 'java', 'kotlin', 'scala', 'csharp', 'fsharp'].map((language) => ({
-      repo: 'libtmux/libtmux-java', dispatchRef: 'master', language,
+      repo: 'libtmux/libtmux-java',
+      dispatchRef: 'master',
+      language,
     })),
   ])('dispatches only the catalogued caller and selected language %j', ({ repo, dispatchRef, language }) => {
     const directory = mkdtempSync(join(tmpdir(), 'libtmux-publish-dispatch-'))
     try {
       const calls = join(directory, 'calls')
-      writeFileSync(join(directory, 'gh'), `#!/usr/bin/env bash
+      writeFileSync(
+        join(directory, 'gh'),
+        `#!/usr/bin/env bash
 printf '%s\\n' "$@" >> "$CALLS"
 if [[ "$1" == workflow ]]; then printf 'https://github.com/example/actions/runs/123\\n'; fi
-`, { mode: 0o755 })
-      const body = /- name: Publish[^\n]*\n[\s\S]*?        run: \|\n([\s\S]*?)(?=\n  # The shell)/.exec(workflow)![1]
+`,
+        { mode: 0o755 },
+      )
+      const body = /- name: Publish[^\n]*\n[\s\S]*?        run: \|\n([\s\S]*?)(?=\n  # The shell)/
+        .exec(workflow)![1]
         .replace(/^ {10}/gm, '')
-      execFileSync('bash', ['-c', body], { env: {
-        ...process.env, PATH: `${directory}:${process.env.PATH}`, CALLS: calls, GH_TOKEN: 'test',
-        GITHUB_STEP_SUMMARY: join(directory, 'summary'), REPO: repo, WORKFLOW: 'reviewed-docs.yml',
-        DISPATCH_REF: dispatchRef, SOURCE_REF: 'reviewed-ref', VERSION: 'latest', KIND: 'trunk',
-        IS_DEFAULT: 'true', RESOLVES_TO: '', LANGUAGE: language,
-      } })
+      execFileSync('bash', ['-c', body], {
+        env: {
+          ...process.env,
+          PATH: `${directory}:${process.env.PATH}`,
+          CALLS: calls,
+          GH_TOKEN: 'test',
+          GITHUB_STEP_SUMMARY: join(directory, 'summary'),
+          REPO: repo,
+          WORKFLOW: 'reviewed-docs.yml',
+          DISPATCH_REF: dispatchRef,
+          SOURCE_REF: 'reviewed-ref',
+          VERSION: 'latest',
+          KIND: 'trunk',
+          IS_DEFAULT: 'true',
+          RESOLVES_TO: '',
+          LANGUAGE: language,
+        },
+      })
       const args = readFileSync(calls, 'utf8').trim().split('\n')
       expect(args.slice(0, 7)).toEqual(['workflow', 'run', 'reviewed-docs.yml', '--repo', repo, '--ref', dispatchRef])
       expect(args.filter((arg) => arg.startsWith('language='))).toEqual(language ? [`language=${language}`] : [])
@@ -201,15 +312,23 @@ if [[ "$1" == workflow ]]; then printf 'https://github.com/example/actions/runs/
   })
 
   it.each(['dispatch', 'shell'])('propagates %s dispatch and child-run failures with visible diagnostics', (job) => {
-    const body = (job === 'dispatch'
-      ? /- name: Publish[^\n]*\n[\s\S]*?        run: \|\n([\s\S]*?)(?=\n  # The shell)/.exec(workflow)![1]
-      : /  shell:\n[\s\S]*?        run: \|\n([\s\S]*)$/.exec(workflow)![1])
-      .replace(/^ {10}/gm, '')
-    const cases = [['success', 0], ['dispatch-failure', 17], ['invalid-id', 1], ['child-failure', 23]] as const
+    const body = (
+      job === 'dispatch'
+        ? /- name: Publish[^\n]*\n[\s\S]*?        run: \|\n([\s\S]*?)(?=\n  # The shell)/.exec(workflow)![1]
+        : /  shell:\n[\s\S]*?        run: \|\n([\s\S]*)$/.exec(workflow)![1]
+    ).replace(/^ {10}/gm, '')
+    const cases = [
+      ['success', 0],
+      ['dispatch-failure', 17],
+      ['invalid-id', 1],
+      ['child-failure', 23],
+    ] as const
     for (const [mode, expected] of cases) {
       const directory = mkdtempSync(join(tmpdir(), 'libtmux-publish-failure-'))
       try {
-        writeFileSync(join(directory, 'gh'), `#!/usr/bin/env bash
+        writeFileSync(
+          join(directory, 'gh'),
+          `#!/usr/bin/env bash
 printf '%s\\n' "$*" >> "$CALLS"
 if [[ "$1" == workflow ]]; then
   if [[ "$MODE" == dispatch-failure ]]; then echo 'dispatch refused' >&2; exit 17; fi
@@ -221,13 +340,30 @@ elif [[ "$2" == watch ]]; then
 elif [[ "$2" == view ]]; then
   echo 'failed child step details'
 fi
-`, { mode: 0o755 })
-        const result = spawnSync('bash', ['-c', body], { encoding: 'utf8', env: {
-          ...process.env, PATH: `${directory}:${process.env.PATH}`, CALLS: join(directory, 'calls'),
-          MODE: mode, GH_TOKEN: 'test', GITHUB_STEP_SUMMARY: join(directory, 'summary'),
-          REPO: 'libtmux/docs', WORKFLOW: 'docs.yml', REF: 'main', DISPATCH_REF: 'main', SOURCE_REF: 'reviewed-ref',
-          VERSION: 'latest', KIND: 'trunk', IS_DEFAULT: 'true', RESOLVES_TO: '', LANGUAGE: '',
-        } })
+`,
+          { mode: 0o755 },
+        )
+        const result = spawnSync('bash', ['-c', body], {
+          encoding: 'utf8',
+          env: {
+            ...process.env,
+            PATH: `${directory}:${process.env.PATH}`,
+            CALLS: join(directory, 'calls'),
+            MODE: mode,
+            GH_TOKEN: 'test',
+            GITHUB_STEP_SUMMARY: join(directory, 'summary'),
+            REPO: 'libtmux/docs',
+            WORKFLOW: 'docs.yml',
+            REF: 'main',
+            DISPATCH_REF: 'main',
+            SOURCE_REF: 'reviewed-ref',
+            VERSION: 'latest',
+            KIND: 'trunk',
+            IS_DEFAULT: 'true',
+            RESOLVES_TO: '',
+            LANGUAGE: '',
+          },
+        })
         expect(result.status, `${job}: ${mode}: ${result.stderr}`).toBe(expected)
         const calls = readFileSync(join(directory, 'calls'), 'utf8')
         if (mode === 'dispatch-failure' || mode === 'invalid-id') {
diff --git a/site/test/publish-prefixes.test.ts b/site/test/publish-prefixes.test.ts
index 9355a956f..9dbc2a37e 100644
--- a/site/test/publish-prefixes.test.ts
+++ b/site/test/publish-prefixes.test.ts
@@ -1,5 +1,14 @@
 import { spawnSync } from 'node:child_process'
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, renameSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import {
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { fileURLToPath } from 'node:url'
@@ -21,8 +30,13 @@ const PORT_TREES = PORTS.filter((port) => port.publishesOwnTree).map((port) => p
 // that need one on disk. A port that publishes only its own `api/` still
 // has the rest of its tree published here.
 const SHELL_PORT = PORTS.find((port) => !port.publishesOwnTree)!.slug
-const sectionsFor = (slug: string): string[] =>
-  [...Object.keys(DOC_PRODUCTS), 'guides', 'topics', '_astro', ...(NATIVE_API.includes(slug) ? [] : ['api'])]
+const sectionsFor = (slug: string): string[] => [
+  ...Object.keys(DOC_PRODUCTS),
+  'guides',
+  'topics',
+  '_astro',
+  ...(NATIVE_API.includes(slug) ? [] : ['api']),
+]
 
 const scratch: string[] = []
 afterEach(() => scratch.splice(0).forEach((path) => rmSync(path, { recursive: true, force: true })))
@@ -58,9 +72,17 @@ function fixture(products = true): string {
       }
     }
   }
-  write(join(directory, 'shell-paths.json'), JSON.stringify({
-    schema: 1, locale: 'en', directories, files, nativeApi: NATIVE_API, portTrees: PORT_TREES,
-  }))
+  write(
+    join(directory, 'shell-paths.json'),
+    JSON.stringify({
+      schema: 1,
+      locale: 'en',
+      directories,
+      files,
+      nativeApi: NATIVE_API,
+      portTrees: PORT_TREES,
+    }),
+  )
   const executable = join(directory, 'bin/aws')
   mkdirSync(dirname(executable), { recursive: true })
   writeFileSync(executable, '#!/bin/bash\nprintf "%s\\0" "$#" "$@" >> "$AWS_RECORD"\n', { mode: 0o755 })
@@ -70,10 +92,16 @@ function fixture(products = true): string {
 function publish(directory: string, locale = 'en') {
   const record = join(directory, 'aws.args')
   const result = spawnSync('bash', [script], {
-    cwd: directory, encoding: 'utf8', timeout: 10000,
+    cwd: directory,
+    encoding: 'utf8',
+    timeout: 10000,
     env: {
-      ...process.env, PATH: `${join(directory, 'bin')}:${process.env.PATH}`, BUCKET: 'docs-test',
-      LOCALE: locale, RUNNER_TEMP: directory, AWS_RECORD: record,
+      ...process.env,
+      PATH: `${join(directory, 'bin')}:${process.env.PATH}`,
+      BUCKET: 'docs-test',
+      LOCALE: locale,
+      RUNNER_TEMP: directory,
+      AWS_RECORD: record,
     },
   })
   expect(result.error, result.stderr).toBeUndefined()
@@ -93,9 +121,14 @@ function assemblyFixture(): string {
   mkdirSync(join(directory, '_site'))
   renameSync(join(directory, 'dist'), join(directory, '_site', DEFAULT_LOCALE))
   for (const port of PORTS) write(join(directory, '_site', DEFAULT_LOCALE, port.slug, 'latest/api/index.html'))
-  write(join(directory, 'site/src/lib/ports.ts'),
-    `export const PORTS = ${JSON.stringify(PORTS.map(({ slug, publishesOwnApi, publishesOwnTree }) => ({ slug, publishesOwnApi, publishesOwnTree })))}; export const DOC_PRODUCTS = ${JSON.stringify(DOC_PRODUCTS)};\n`)
-  write(join(directory, 'site/src/i18n/locales.ts'), `export const DEFAULT_LOCALE = ${JSON.stringify(DEFAULT_LOCALE)};\n`)
+  write(
+    join(directory, 'site/src/lib/ports.ts'),
+    `export const PORTS = ${JSON.stringify(PORTS.map(({ slug, publishesOwnApi, publishesOwnTree }) => ({ slug, publishesOwnApi, publishesOwnTree })))}; export const DOC_PRODUCTS = ${JSON.stringify(DOC_PRODUCTS)};\n`,
+  )
+  write(
+    join(directory, 'site/src/i18n/locales.ts'),
+    `export const DEFAULT_LOCALE = ${JSON.stringify(DEFAULT_LOCALE)};\n`,
+  )
   return directory
 }
 
@@ -104,10 +137,16 @@ function assemblyFixture(): string {
 describe('production shell publication boundaries', { timeout: 30_000 }, () => {
   it('omits locally generated native APIs before declaring the assembled publication artifact', () => {
     const directory = assemblyFixture()
-    const expected = JSON.parse(readFileSync(join(directory, 'shell-paths.json'), 'utf8')) as { directories: string[]; files: string[] }
-    const preserved = [...expected.files, ...expected.directories.map((path) => `${path}/${path.endsWith('/_astro') ? 'shell.js' : 'index.html'}`)]
-      .map((path) => [path, readFileSync(join(directory, '_site', DEFAULT_LOCALE, path), 'utf8')] as const)
-    for (const file of ['shell-paths.json', 'reserved-prefixes.txt', 'reserved-products.txt']) rmSync(join(directory, file))
+    const expected = JSON.parse(readFileSync(join(directory, 'shell-paths.json'), 'utf8')) as {
+      directories: string[]
+      files: string[]
+    }
+    const preserved = [
+      ...expected.files,
+      ...expected.directories.map((path) => `${path}/${path.endsWith('/_astro') ? 'shell.js' : 'index.html'}`),
+    ].map((path) => [path, readFileSync(join(directory, '_site', DEFAULT_LOCALE, path), 'utf8')] as const)
+    for (const file of ['shell-paths.json', 'reserved-prefixes.txt', 'reserved-products.txt'])
+      rmSync(join(directory, file))
     const result = spawnSync(process.execPath, [metadataScript], { cwd: directory, encoding: 'utf8', timeout: 10000 })
     expect(result.error).toBeUndefined()
     expect(result.status, result.stderr).toBe(0)
@@ -118,12 +157,18 @@ describe('production shell publication boundaries', { timeout: 30_000 }, () => {
     expect(paths.nativeApi).toEqual(NATIVE_API)
     expect(paths.portTrees).toEqual(PORT_TREES)
     for (const port of PORTS) {
-      expect(existsSync(join(directory, '_site', DEFAULT_LOCALE, port.slug, 'latest/api')), port.slug)
-        .toBe(!NATIVE_API.includes(port.slug) && !PORT_TREES.includes(port.slug))
+      expect(existsSync(join(directory, '_site', DEFAULT_LOCALE, port.slug, 'latest/api')), port.slug).toBe(
+        !NATIVE_API.includes(port.slug) && !PORT_TREES.includes(port.slug),
+      )
     }
-    for (const [path, content] of preserved) expect(readFileSync(join(directory, '_site', DEFAULT_LOCALE, path), 'utf8')).toBe(content)
-    expect(readFileSync(join(directory, 'reserved-prefixes.txt'), 'utf8')).toBe(PORTS.map(({ slug }) => slug).join('\n') + '\n')
-    expect(readFileSync(join(directory, 'reserved-products.txt'), 'utf8')).toBe(Object.keys(DOC_PRODUCTS).join('\n') + '\n')
+    for (const [path, content] of preserved)
+      expect(readFileSync(join(directory, '_site', DEFAULT_LOCALE, path), 'utf8')).toBe(content)
+    expect(readFileSync(join(directory, 'reserved-prefixes.txt'), 'utf8')).toBe(
+      PORTS.map(({ slug }) => slug).join('\n') + '\n',
+    )
+    expect(readFileSync(join(directory, 'reserved-products.txt'), 'utf8')).toBe(
+      Object.keys(DOC_PRODUCTS).join('\n') + '\n',
+    )
   })
 
   it('rejects a native API symlink without removing it or its target', () => {
@@ -142,7 +187,13 @@ describe('production shell publication boundaries', { timeout: 30_000 }, () => {
 
   it('protects the complete Python version tree through assembly and publication', () => {
     const directory = assemblyFixture()
-    for (const path of ['index.html', 'guides/index.html', 'reference/index.html', 'mcp/index.html', '_astro/port.js']) {
+    for (const path of [
+      'index.html',
+      'guides/index.html',
+      'reference/index.html',
+      'mcp/index.html',
+      '_astro/port.js',
+    ]) {
       write(join(directory, '_site', DEFAULT_LOCALE, 'py/latest', path), 'Port-owned output\n')
     }
     const result = spawnSync(process.execPath, [metadataScript], { cwd: directory, encoding: 'utf8', timeout: 10000 })
@@ -157,51 +208,77 @@ describe('production shell publication boundaries', { timeout: 30_000 }, () => {
     expect(destinations.some((path) => path.startsWith('s3://docs-test/en/py/latest/'))).toBe(false)
   })
 
-  it.each(['en', 'ja'])('publishes %s products without replacing port, version, native API, or historical prefixes', (locale) => {
-    const result = publish(fixture(true), locale)
-    expect(result.status, result.stderr).toBe(0)
-    const syncs = result.commands.filter((args) => args[0] === 's3' && args[1] === 'sync')
-    const destinations = syncs.map((args) => args[3])
-    expect(destinations).toContain(`s3://docs-test/${locale}/_astro/`)
-    for (const port of PORTS.filter((candidate) => !PORT_TREES.includes(candidate.slug))) {
-      for (const section of sectionsFor(port.slug)) {
-        expect(destinations).toContain(`s3://docs-test/${locale}/${port.slug}/latest/${section}/`)
+  it.each(['en', 'ja'])(
+    'publishes %s products without replacing port, version, native API, or historical prefixes',
+    (locale) => {
+      const result = publish(fixture(true), locale)
+      expect(result.status, result.stderr).toBe(0)
+      const syncs = result.commands.filter((args) => args[0] === 's3' && args[1] === 'sync')
+      const destinations = syncs.map((args) => args[3])
+      expect(destinations).toContain(`s3://docs-test/${locale}/_astro/`)
+      for (const port of PORTS.filter((candidate) => !PORT_TREES.includes(candidate.slug))) {
+        for (const section of sectionsFor(port.slug)) {
+          expect(destinations).toContain(`s3://docs-test/${locale}/${port.slug}/latest/${section}/`)
+        }
       }
-    }
-    const productPrefixes = new Set(PORTS.flatMap((port) => sectionsFor(port.slug)
-      .filter(() => !PORT_TREES.includes(port.slug))
-      .map((section) => `s3://docs-test/${locale}/${port.slug}/latest/${section}/`)))
-    for (const args of syncs) {
-      const destination = args[3]
-      if (destination.endsWith('/_astro/')) expect(args, destination).not.toContain('--delete')
-      else expect(args, destination).toContain('--delete')
-      expect(destination === `s3://docs-test/${locale}/_astro/` || productPrefixes.has(destination), destination).toBe(true)
-      for (const port of PORTS) {
-        const preserved = ['stable/api/index.html', 'v0.1.0/mcp/index.html',
-          ...(NATIVE_API.includes(port.slug) ? ['latest/api/index.html'] : [])]
-        for (const path of preserved) {
-          expect(`s3://docs-test/${locale}/${port.slug}/${path}`.startsWith(destination), `${destination} preserves ${path}`).toBe(false)
+      const productPrefixes = new Set(
+        PORTS.flatMap((port) =>
+          sectionsFor(port.slug)
+            .filter(() => !PORT_TREES.includes(port.slug))
+            .map((section) => `s3://docs-test/${locale}/${port.slug}/latest/${section}/`),
+        ),
+      )
+      for (const args of syncs) {
+        const destination = args[3]
+        if (destination.endsWith('/_astro/')) expect(args, destination).not.toContain('--delete')
+        else expect(args, destination).toContain('--delete')
+        expect(
+          destination === `s3://docs-test/${locale}/_astro/` || productPrefixes.has(destination),
+          destination,
+        ).toBe(true)
+        for (const port of PORTS) {
+          const preserved = [
+            'stable/api/index.html',
+            'v0.1.0/mcp/index.html',
+            ...(NATIVE_API.includes(port.slug) ? ['latest/api/index.html'] : []),
+          ]
+          for (const path of preserved) {
+            expect(
+              `s3://docs-test/${locale}/${port.slug}/${path}`.startsWith(destination),
+              `${destination} preserves ${path}`,
+            ).toBe(false)
+          }
         }
       }
-    }
-    const copies = result.commands.filter((args) => args[1] === 'cp')
-    expect(copies.some((args) => args.includes('--recursive'))).toBe(false)
-    expect(copies.map((args) => args[3]).sort()).toEqual([
-      ...PORTS.flatMap((port) => ['index.html', 'index.md'].map((file) => `s3://docs-test/${locale}/${port.slug}/${file}`)),
-      ...PORTS.filter((port) => !PORT_TREES.includes(port.slug))
-        .flatMap((port) => ['index.html', 'docs.json'].map((file) => `s3://docs-test/${locale}/${port.slug}/latest/${file}`)),
-      `s3://docs-test/${locale}/index.html`, `s3://docs-test/${locale}/robots.txt`, 's3://docs-test/robots.txt',
-    ].sort())
-  })
+      const copies = result.commands.filter((args) => args[1] === 'cp')
+      expect(copies.some((args) => args.includes('--recursive'))).toBe(false)
+      expect(copies.map((args) => args[3]).sort()).toEqual(
+        [
+          ...PORTS.flatMap((port) =>
+            ['index.html', 'index.md'].map((file) => `s3://docs-test/${locale}/${port.slug}/${file}`),
+          ),
+          ...PORTS.filter((port) => !PORT_TREES.includes(port.slug)).flatMap((port) =>
+            ['index.html', 'docs.json'].map((file) => `s3://docs-test/${locale}/${port.slug}/latest/${file}`),
+          ),
+          `s3://docs-test/${locale}/index.html`,
+          `s3://docs-test/${locale}/robots.txt`,
+          's3://docs-test/robots.txt',
+        ].sort(),
+      )
+    },
+  )
 
-  it.each(['.hidden/index.html', '.hidden-file'])('rejects %s at the artifact root before any AWS operation', (path) => {
-    const directory = fixture()
-    write(join(directory, 'dist', path))
-    const result = publish(directory)
-    expect(result.status).toBe(1)
-    expect(result.stderr).toContain('hidden entry')
-    expect(result.commands).toEqual([])
-  })
+  it.each(['.hidden/index.html', '.hidden-file'])(
+    'rejects %s at the artifact root before any AWS operation',
+    (path) => {
+      const directory = fixture()
+      write(join(directory, 'dist', path))
+      const result = publish(directory)
+      expect(result.status).toBe(1)
+      expect(result.stderr).toContain('hidden entry')
+      expect(result.commands).toEqual([])
+    },
+  )
 
   it.each(NATIVE_API)('refuses to publish %s/latest/api however the artifact declares it', (slug) => {
     const directory = fixture()
@@ -255,7 +332,8 @@ describe('production shell publication boundaries', { timeout: 30_000 }, () => {
   })
 
   it.each(['go/stable/guides', 'unknown/latest/guides', 'go/latest/../api'])(
-    'rejects declared path %s outside latest shell ownership', (path) => {
+    'rejects declared path %s outside latest shell ownership',
+    (path) => {
       const directory = fixture()
       const metadata = join(directory, 'shell-paths.json')
       const paths = JSON.parse(readFileSync(metadata, 'utf8'))
@@ -269,8 +347,13 @@ describe('production shell publication boundaries', { timeout: 30_000 }, () => {
   )
 
   it.each([
-    'py/latest/api/index.html', 'go/stable/mcp/index.html', 'go/v0.1.0/mcp/index.html',
-    'go/unknown/index.html', 'go/.unknown/index.html', 'go/latest/unknown/index.html', 'go/latest/.unknown/index.html',
+    'py/latest/api/index.html',
+    'go/stable/mcp/index.html',
+    'go/v0.1.0/mcp/index.html',
+    'go/unknown/index.html',
+    'go/.unknown/index.html',
+    'go/latest/unknown/index.html',
+    'go/latest/.unknown/index.html',
   ])('rejects unexpected %s before any AWS operation', (path) => {
     const directory = fixture()
     write(join(directory, 'dist', path))
@@ -307,13 +390,16 @@ describe('production shell publication boundaries', { timeout: 30_000 }, () => {
     expect(result.commands).toEqual([])
   })
 
-  it.each(['.outside', '_astro/outside', `${SHELL_PORT}/latest/mcp/outside`])('rejects symlink %s before any AWS operation', (path) => {
-    const directory = fixture(true)
-    write(join(directory, 'outside/index.html'))
-    symlinkSync(join(directory, 'outside'), join(directory, 'dist', path), 'dir')
-    const result = publish(directory)
-    expect(result.status).toBe(1)
-    expect(result.stderr).toContain('symlink')
-    expect(result.commands).toEqual([])
-  })
+  it.each(['.outside', '_astro/outside', `${SHELL_PORT}/latest/mcp/outside`])(
+    'rejects symlink %s before any AWS operation',
+    (path) => {
+      const directory = fixture(true)
+      write(join(directory, 'outside/index.html'))
+      symlinkSync(join(directory, 'outside'), join(directory, 'dist', path), 'dir')
+      const result = publish(directory)
+      expect(result.status).toBe(1)
+      expect(result.stderr).toContain('symlink')
+      expect(result.commands).toEqual([])
+    },
+  )
 })
diff --git a/site/test/rehype-code-tabs.test.ts b/site/test/rehype-code-tabs.test.ts
index e46dd5a0b..5b76c912a 100644
--- a/site/test/rehype-code-tabs.test.ts
+++ b/site/test/rehype-code-tabs.test.ts
@@ -47,8 +47,7 @@ const run = (children: El[]) => {
   return tree
 }
 
-const groups = (tree: El) =>
-  (tree.children ?? []).filter((c) => c.tagName === 'libtmux-code-tabs')
+const groups = (tree: El) => (tree.children ?? []).filter((c) => c.tagName === 'libtmux-code-tabs')
 
 const portsOf = (group: El) => String(group.properties?.['data-ports'] ?? '').split(',')
 
@@ -98,13 +97,7 @@ describe('rehypeCodeTabs grouping', () => {
   })
 
   it('renders that prose inside the panel it introduces', () => {
-    const tree = run([
-      fence('python'),
-      gap(),
-      para('Swift is the outlier.'),
-      gap(),
-      fence('swift'),
-    ])
+    const tree = run([fence('python'), gap(), para('Swift is the outlier.'), gap(), fence('swift')])
 
     const swift = panelFor(groups(tree)[0], 'swift')
     expect(swift, 'a Swift panel').toBeTruthy()
@@ -117,13 +110,7 @@ describe('rehypeCodeTabs grouping', () => {
   })
 
   it('ends the group at prose that introduces no fence', () => {
-    const tree = run([
-      fence('python'),
-      gap(),
-      fence('go'),
-      gap(),
-      para('An unrelated closing paragraph.'),
-    ])
+    const tree = run([fence('python'), gap(), fence('go'), gap(), para('An unrelated closing paragraph.')])
 
     expect(groups(tree)).toHaveLength(1)
     expect(portsOf(groups(tree)[0])).toEqual(['py', 'go'])
@@ -133,15 +120,7 @@ describe('rehypeCodeTabs grouping', () => {
   })
 
   it('starts a new group when a port repeats', () => {
-    const tree = run([
-      fence('python'),
-      gap(),
-      fence('go'),
-      gap(),
-      fence('python'),
-      gap(),
-      fence('go'),
-    ])
+    const tree = run([fence('python'), gap(), fence('go'), gap(), fence('python'), gap(), fence('go')])
 
     const gs = groups(tree)
     expect(gs).toHaveLength(2)
diff --git a/site/test/row-anchors.test.ts b/site/test/row-anchors.test.ts
index 900938f73..8fc85ef34 100644
--- a/site/test/row-anchors.test.ts
+++ b/site/test/row-anchors.test.ts
@@ -14,9 +14,12 @@ const render = (html: string) => {
   visit(tree, 'element', (node) => {
     if (node.tagName !== 'tr' || !node.properties.id) return
     visit(node, 'element', (child) => {
-      if (child.properties.dataRowPermalink) rows.push({
-        id: node.properties.id, href: child.properties.href, label: child.properties.ariaLabel,
-      })
+      if (child.properties.dataRowPermalink)
+        rows.push({
+          id: node.properties.id,
+          href: child.properties.href,
+          label: child.properties.ariaLabel,
+        })
     })
   })
   return { tree, rows }
@@ -24,8 +27,8 @@ const render = (html: string) => {
 
 describe('section and item permalinks', () => {
   it('names option rows consistently across tmux versions', () => {
-    const rows = (version: string) => tmuxCommandNotes(version, 'capture-pane')!.groups
-      .flatMap((group) => group.options)
+    const rows = (version: string) =>
+      tmuxCommandNotes(version, 'capture-pane')!.groups.flatMap((group) => group.options)
     const current = rows('latest')
     expect(current.find((row) => row.flag === 'p')!.id).toBe('capture-pane-options-output-and-line-range-p')
     expect(current.find((row) => row.flag === 'S')!.id).toBe('capture-pane-options-output-and-line-range-s')
@@ -41,24 +44,33 @@ describe('section and item permalinks', () => {
   })
 
   it('links data rows using their section without changing existing links or header rows', () => {
-    const { tree, rows } = render('<h2 id="filters">Filters</h2><table><thead><tr><th>Name</th><th>Meaning</th></tr></thead><tbody><tr><td><a href="/api/">Server</a></td><td>Owner</td></tr></tbody></table>')
+    const { tree, rows } = render(
+      '<h2 id="filters">Filters</h2><table><thead><tr><th>Name</th><th>Meaning</th></tr></thead><tbody><tr><td><a href="/api/">Server</a></td><td>Owner</td></tr></tbody></table>',
+    )
     expect(rows).toEqual([{ id: 'filters-server', href: '#filters-server', label: 'Link to Server in Filters' }])
     const links: unknown[] = []
-    visit(tree, 'element', (node) => { if (node.tagName === 'a') links.push(node.properties.href) })
+    visit(tree, 'element', (node) => {
+      if (node.tagName === 'a') links.push(node.properties.href)
+    })
     expect(links).toEqual(['/api/', '#filters-server'])
     rehypeRowAnchors()(tree)
     const permalinks: unknown[] = []
-    visit(tree, 'element', (node) => { if (node.properties.dataRowPermalink) permalinks.push(node.properties.href) })
+    visit(tree, 'element', (node) => {
+      if (node.properties.dataRowPermalink) permalinks.push(node.properties.href)
+    })
     expect(permalinks).toEqual(['#filters-server'])
   })
 
   it('preserves explicit IDs and avoids collisions with headings and repeated rows', () => {
-    const { rows } = render('<h2 id="flags">Flags</h2><span id="flags-p"></span><table><tr><td>-p</td><td>First</td></tr><tr><td>-p</td><td>Second</td></tr><tr id="stable-option"><td>-q</td><td>Third</td></tr></table>')
+    const { rows } = render(
+      '<h2 id="flags">Flags</h2><span id="flags-p"></span><table><tr><td>-p</td><td>First</td></tr><tr><td>-p</td><td>Second</td></tr><tr id="stable-option"><td>-q</td><td>Third</td></tr></table>',
+    )
     expect(rows.map((row) => row.id)).toEqual(['flags-p-2', 'flags-p-3', 'stable-option'])
   })
 
   it('keeps distinct row identities stable when rows are reordered or inserted', () => {
-    const table = (labels: string[]) => `<h3 id="capture-options">Capture options</h3><table>${labels.map((label) => `<tr><td>${label}</td><td>Description</td></tr>`).join('')}</table>`
+    const table = (labels: string[]) =>
+      `<h3 id="capture-options">Capture options</h3><table>${labels.map((label) => `<tr><td>${label}</td><td>Description</td></tr>`).join('')}</table>`
     const first = render(table(['-p', '-J'])).rows.map((row) => row.id)
     const changed = render(table(['-S start', '-J', '-p'])).rows.map((row) => row.id)
     expect(changed).toEqual(['capture-options-s-start', first[1], first[0]])
@@ -66,10 +78,11 @@ describe('section and item permalinks', () => {
 
   it('includes ancestor sections and resets the path at a sibling heading', () => {
     const row = '<table><tr><td>--json</td><td>Output JSON</td></tr></table>'
-    const { rows } = render(`<h1 id="ls">ls</h1><h2 id="options">Options</h2>${row}<h3 id="formatting">Formatting</h3>${row}<h2 id="examples">Examples</h2>${row}`)
+    const { rows } = render(
+      `<h1 id="ls">ls</h1><h2 id="options">Options</h2>${row}<h3 id="formatting">Formatting</h3>${row}<h2 id="examples">Examples</h2>${row}`,
+    )
     expect(rows.map((entry) => entry.id)).toEqual(['ls-options-json', 'ls-options-formatting-json', 'ls-examples-json'])
-    expect(render(`<h1 id="ls">ls</h1><h2 id="ls-options">Options</h2>${row}`).rows[0].id)
-      .toBe('ls-options-json')
+    expect(render(`<h1 id="ls">ls</h1><h2 id="ls-options">Options</h2>${row}`).rows[0].id).toBe('ls-options-json')
   })
 })
 
diff --git a/site/test/ruby-api-examples.test.ts b/site/test/ruby-api-examples.test.ts
index c509e0136..c09b86454 100644
--- a/site/test/ruby-api-examples.test.ts
+++ b/site/test/ruby-api-examples.test.ts
@@ -34,13 +34,18 @@ describe('verified complete Ruby API programs', () => {
       }
       const code = blocks[file.block].code
       expect(hash(code), `${example.symbol}/${file.name}`).toBe(file.sha256)
-      expect(exported.some((block) => hash(block.value + '\n') === file.sha256),
-        `${example.symbol}/${file.name} Markdown`).toBe(true)
+      expect(
+        exported.some((block) => hash(block.value + '\n') === file.sha256),
+        `${example.symbol}/${file.name} Markdown`,
+      ).toBe(true)
       expect(hash(code.replace(/\n$/, ''))).toBe(file.clipboardSha256)
     }
-    expect(blocks.filter((block) => block.lang === 'console')
-      .map((block) => block.code.replace(/^\$ /gm, '').trim())).toEqual(example.shellRecipe)
-    expect(blocks[2].sourceUrl).toBe(`https://github.com/${model.repo}/blob/${example.sourceRevision}/${example.sourceFile}`)
+    expect(
+      blocks.filter((block) => block.lang === 'console').map((block) => block.code.replace(/^\$ /gm, '').trim()),
+    ).toEqual(example.shellRecipe)
+    expect(blocks[2].sourceUrl).toBe(
+      `https://github.com/${model.repo}/blob/${example.sourceRevision}/${example.sourceFile}`,
+    )
     expect(markdown).toContain(`[Source example](${blocks[2].sourceUrl}).`)
     expect(blocks[2].code).toContain('require "libtmux"')
     expect(blocks[2].code).toContain('LibTmux::Server.start do')
diff --git a/site/test/rust-api-examples.test.ts b/site/test/rust-api-examples.test.ts
index c9d4bc95c..ac74468ce 100644
--- a/site/test/rust-api-examples.test.ts
+++ b/site/test/rust-api-examples.test.ts
@@ -15,18 +15,34 @@ describe('complete Rust API examples', () => {
     expect(examples).toHaveLength(31)
     expect(new Set(examples.map((example) => example.sourceFile)).size).toBe(7)
     expect(new Set(examples.map((example) => example.page)).size).toBe(31)
-    const attached = model.symbols.filter((symbol) => symbol.doc?.examples?.some(
-      (block) => block.sourceUrl?.includes('/crates/libtmux/examples/api_'))).map((symbol) => symbol.id)
+    const attached = model.symbols
+      .filter((symbol) =>
+        symbol.doc?.examples?.some((block) => block.sourceUrl?.includes('/crates/libtmux/examples/api_')),
+      )
+      .map((symbol) => symbol.id)
     expect(examples.map((example) => example.symbol).sort()).toEqual(attached.sort())
-    for (const id of ['server.Server', 'server.Server.sessions', 'server.Server.windows',
-      'server.Server.panes', 'server.Server.new_session', 'session.Session.new_window',
-      'pane.Pane.split', 'query.QueryIteratorExt.matching', 'query.QueryIteratorExt.exactly_one',
-      'query.QueryIteratorExt.one_or_none', 'pane.Pane.send_keys', 'pane.Pane.capture']) {
+    for (const id of [
+      'server.Server',
+      'server.Server.sessions',
+      'server.Server.windows',
+      'server.Server.panes',
+      'server.Server.new_session',
+      'session.Session.new_window',
+      'pane.Pane.split',
+      'query.QueryIteratorExt.matching',
+      'query.QueryIteratorExt.exactly_one',
+      'query.QueryIteratorExt.one_or_none',
+      'pane.Pane.send_keys',
+      'pane.Pane.capture',
+    ]) {
       expect(attached).toContain(id)
     }
     expect(attached).not.toContain('options.OptionScope.Server')
-    expect(model.sources?.every((source) => source.revision === model.revision &&
-      source.extractedRevision === model.revision)).toBe(true)
+    expect(
+      model.sources?.every(
+        (source) => source.revision === model.revision && source.extractedRevision === model.revision,
+      ),
+    ).toBe(true)
   })
 
   it.each(examples)('preserves whole file and recipe bytes for $symbol in Markdown and copy payloads', (example) => {
@@ -43,12 +59,20 @@ describe('complete Rust API examples', () => {
     expect(example.files).toHaveLength(3)
     for (const file of example.files) {
       const label = `${example.symbol}/${file.name}`
-      if (!('sourceFile' in file) || typeof file.sourceFile !== 'string' ||
-          !('clipboardSha256' in file) || !('path' in file)) throw new Error(`${label}: missing receipt`)
+      if (
+        !('sourceFile' in file) ||
+        typeof file.sourceFile !== 'string' ||
+        !('clipboardSha256' in file) ||
+        !('path' in file)
+      )
+        throw new Error(`${label}: missing receipt`)
       const block = blocks[file.block]
       expect(hash(block.code), label).toBe(file.sha256)
       expect(hash(block.code.replace(/\n$/, ''))).toBe(file.clipboardSha256)
-      expect(exported.some((entry) => hash(entry.value + '\n') === file.sha256), label).toBe(true)
+      expect(
+        exported.some((entry) => hash(entry.value + '\n') === file.sha256),
+        label,
+      ).toBe(true)
       expect(block.sourceUrl).toBe(`https://github.com/${model.repo}/blob/${example.sourceRevision}/${file.sourceFile}`)
       expect(markdown).toContain(`[Source example](${block.sourceUrl}).`)
       expect(block.intro).toContain(file.path)
@@ -56,8 +80,9 @@ describe('complete Rust API examples', () => {
         expect(line.length).toBeLessThanOrEqual(100)
       }
     }
-    expect(example.consoleBlocks?.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim()))
-      .toEqual(example.shellRecipe)
+    expect(example.consoleBlocks?.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim())).toEqual(
+      example.shellRecipe,
+    )
     for (const command of example.shellRecipe) {
       expect(exported.some((entry) => entry.value.replace(/^\$ /gm, '').trim() === command)).toBe(true)
     }
diff --git a/site/test/search-panel.test.ts b/site/test/search-panel.test.ts
index f820b4500..6a73016db 100644
--- a/site/test/search-panel.test.ts
+++ b/site/test/search-panel.test.ts
@@ -20,10 +20,14 @@ function fixture(initialPort?: string) {
   // Happy DOM implements the browser API with its own element types.
   const root = window.document.querySelector('.search-panel')! as unknown as HTMLElement
   const input = root.querySelector<HTMLInputElement>('input')!
-  const pages = ['Go', 'Rust'].map((port) => ({ port, data: {
-    url: `/en/${port === 'Go' ? 'go' : 'rs'}/latest/topics/capture/`,
-    excerpt: `${port} capture`, meta: { title: `${port} capture` },
-  } }))
+  const pages = ['Go', 'Rust'].map((port) => ({
+    port,
+    data: {
+      url: `/en/${port === 'Go' ? 'go' : 'rs'}/latest/topics/capture/`,
+      excerpt: `${port} capture`,
+      meta: { title: `${port} capture` },
+    },
+  }))
   const search = vi.fn<PagefindApi['search']>(async (query, options) => {
     const ports = (options?.filters as { port?: string[] } | undefined)?.port
     const hits = query === 'capture' ? pages.filter((page) => !ports || ports.includes(page.port)) : []
@@ -35,13 +39,16 @@ function fixture(initialPort?: string) {
   })
   const filters = vi.fn<PagefindApi['filters']>(async () => ({ port: { Go: 1, Rust: 1 } }))
   const handle = mountSearchPanel(root, '/en/pagefind/', {
-    initialPort, initialQuery: 'capture', mock: { search, filters },
+    initialPort,
+    initialQuery: 'capture',
+    mock: { search, filters },
   })
   const query = (value: string) => {
     input.value = value
     input.dispatchEvent(new Event('input', { bubbles: true }))
   }
-  const results = () => [...root.querySelectorAll<HTMLAnchorElement>('.search-panel__result')].map((link) => link.getAttribute('href'))
+  const results = () =>
+    [...root.querySelectorAll<HTMLAnchorElement>('.search-panel__result')].map((link) => link.getAttribute('href'))
   const filter = (port: string) => root.querySelector<HTMLInputElement>(`input[value="${port}"]`)!
   return { root, search, filters, handle, query, results, filter }
 }
@@ -86,7 +93,11 @@ describe('port search defaults', () => {
     const { root, filters, handle, query, results, filter } = fixture('Go')
     await vi.waitFor(() => expect(results()).toHaveLength(1))
     let release: (counts: Record<string, Record<string, number>>) => void = () => {}
-    filters.mockReturnValueOnce(new Promise((resolve) => { release = resolve }))
+    filters.mockReturnValueOnce(
+      new Promise((resolve) => {
+        release = resolve
+      }),
+    )
     handle.clear()
     await vi.waitFor(() => expect(filters).toHaveBeenCalledOnce())
     query('capture')
@@ -104,7 +115,12 @@ describe('port search defaults', () => {
     const { search, query, results, root } = fixture('Go')
     await vi.waitFor(() => expect(results()).toHaveLength(1))
     let release: (data: PagefindResultData) => void = () => {}
-    const data = vi.fn(() => new Promise<PagefindResultData>((resolve) => { release = resolve }))
+    const data = vi.fn(
+      () =>
+        new Promise<PagefindResultData>((resolve) => {
+          release = resolve
+        }),
+    )
     search.mockResolvedValueOnce({ results: [{ id: 'slow', data }] })
     query('slow')
     await vi.waitFor(() => expect(data).toHaveBeenCalled())
diff --git a/site/test/site-root.ts b/site/test/site-root.ts
index 9f97fe669..75766e864 100644
--- a/site/test/site-root.ts
+++ b/site/test/site-root.ts
@@ -15,11 +15,8 @@ export const BUCKET_ROOT: string = process.env.LIBTMUX_DOCS_TEST_SITE
 
 /** The default-locale content tree, or a bare shell build used by a test. */
 export const ASSEMBLY_ROOT = join(BUCKET_ROOT, PREVIEW_PREFIX)
-export const SITE_ROOT = existsSync(join(ASSEMBLY_ROOT, 'en', 'index.html'))
-  ? join(ASSEMBLY_ROOT, 'en')
-  : ASSEMBLY_ROOT
-export const SITE_PREFIX = relative(BUCKET_ROOT, SITE_ROOT).replaceAll('\\', '/')
-  .replace(/(.+)/, '$1/')
+export const SITE_ROOT = existsSync(join(ASSEMBLY_ROOT, 'en', 'index.html')) ? join(ASSEMBLY_ROOT, 'en') : ASSEMBLY_ROOT
+export const SITE_PREFIX = relative(BUCKET_ROOT, SITE_ROOT).replaceAll('\\', '/').replace(/(.+)/, '$1/')
 
 /** Resolve a published URL path from the bucket root. */
 export const publishedPath = (...parts: string[]): string => join(BUCKET_ROOT, ...parts)
@@ -53,11 +50,11 @@ export const SITE_BUILT: boolean = !SOURCE_ONLY && !ASSEMBLY_RUNNING && existsSy
 export const SKIP_REASON: string | undefined = SOURCE_ONLY
   ? 'source-only mode excludes assembled-output checks'
   : ASSEMBLY_RUNNING
-  ? `an assembly holds .build.lock — suites reading ${SITE_ROOT} were skipped rather than ` +
-    'measuring a tree mid-rebuild'
-  : !existsSync(join(SITE_ROOT, 'index.html'))
-    ? `nothing assembled at ${SITE_ROOT} — run scripts/build-site.sh`
-    : undefined
+    ? `an assembly holds .build.lock — suites reading ${SITE_ROOT} were skipped rather than ` +
+      'measuring a tree mid-rebuild'
+    : !existsSync(join(SITE_ROOT, 'index.html'))
+      ? `nothing assembled at ${SITE_ROOT} — run scripts/build-site.sh`
+      : undefined
 
 /** Path inside the assembled tree. */
 export const sitePath = (...parts: string[]): string => join(SITE_ROOT, ...parts)
diff --git a/site/test/sitemap-workspace.test.ts b/site/test/sitemap-workspace.test.ts
index fe3c0fa92..01ad12898 100644
--- a/site/test/sitemap-workspace.test.ts
+++ b/site/test/sitemap-workspace.test.ts
@@ -76,26 +76,23 @@ describe('canonical workspace sitemap routes', () => {
     expect(sitemapOptions.filter!(`https://libtmux.org/en/${canonical}`)).toBe(true)
   })
   it.each(['py', 'ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift', 'ruby'])(
-    'includes real %s Guides and Examples pages', (port) => {
+    'includes real %s Guides and Examples pages',
+    (port) => {
       expect(includes(port, 'guides')).toBe(true)
       expect(includes(port, 'examples')).toBe(true)
     },
   )
 
-  it.each(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])(
-    'excludes retired %s Topics and API routes', (port) => {
-      expect(includes(port, 'topics')).toBe(false)
-      expect(includes(port, 'api/builder')).toBe(false)
-      expect(includes(port, 'internals/topics')).toBe(true)
-    },
-  )
+  it.each(['ts', 'rs', 'go', 'java', 'csharp', 'cxx', 'swift'])('excludes retired %s Topics and API routes', (port) => {
+    expect(includes(port, 'topics')).toBe(false)
+    expect(includes(port, 'api/builder')).toBe(false)
+    expect(includes(port, 'internals/topics')).toBe(true)
+  })
 
-  it.each(['lua', 'kotlin', 'scala', 'fsharp'])(
-    'does not invent shared %s browse pages', (port) => {
-      expect(includes(port, 'guides')).toBe(false)
-      expect(includes(port, 'examples')).toBe(false)
-    },
-  )
+  it.each(['lua', 'kotlin', 'scala', 'fsharp'])('does not invent shared %s browse pages', (port) => {
+    expect(includes(port, 'guides')).toBe(false)
+    expect(includes(port, 'examples')).toBe(false)
+  })
 
   it('retains the published Python and Ruby Topics pages', () => {
     expect(includes('py', 'topics')).toBe(true)
@@ -108,18 +105,36 @@ describe('canonical workspace sitemap routes', () => {
     const run = async (name: keyof typeof hooks, value: unknown) => {
       await (hooks[name] as (input: unknown) => unknown)(value)
     }
-    const kept = ['ts/latest/workspace/guides/', 'go/latest/workspace/examples/', 'py/stable/workspace/guides/', 'ruby/latest/workspace/topics/', 'powershell/latest/guides/mcp/', 'julia/latest/reference/']
-    const omitted = ['ts/latest/workspace/topics/', 'go/latest/workspace/api/builder/', 'lua/latest/workspace/guides/', 'kotlin/latest/workspace/examples/', 'powershell/latest/mcp/', 'julia/latest/guides/api-overview/']
+    const kept = [
+      'ts/latest/workspace/guides/',
+      'go/latest/workspace/examples/',
+      'py/stable/workspace/guides/',
+      'ruby/latest/workspace/topics/',
+      'powershell/latest/guides/mcp/',
+      'julia/latest/reference/',
+    ]
+    const omitted = [
+      'ts/latest/workspace/topics/',
+      'go/latest/workspace/api/builder/',
+      'lua/latest/workspace/guides/',
+      'kotlin/latest/workspace/examples/',
+      'powershell/latest/mcp/',
+      'julia/latest/guides/api-overview/',
+    ]
     try {
-      await run('astro:config:done', { config: { site: 'https://libtmux.org', base: '/en/', trailingSlash: 'always', build: { format: 'directory' } } })
+      await run('astro:config:done', {
+        config: { site: 'https://libtmux.org', base: '/en/', trailingSlash: 'always', build: { format: 'directory' } },
+      })
       await run('astro:routes:resolved', { routes: [] })
       await run('astro:build:done', {
-        dir: pathToFileURL(`${dir}/`), pages: [...kept, ...omitted].map((pathname) => ({ pathname })),
+        dir: pathToFileURL(`${dir}/`),
+        pages: [...kept, ...omitted].map((pathname) => ({ pathname })),
         logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
       })
       const xml = await readFile(join(dir, 'sitemap-0.xml'), 'utf8')
-      expect([...xml.matchAll(/<loc>([^<]+)<\/loc>/g)].map((match) => match[1]).sort())
-        .toEqual(kept.map((path) => `https://libtmux.org/en/${path}`).sort())
+      expect([...xml.matchAll(/<loc>([^<]+)<\/loc>/g)].map((match) => match[1]).sort()).toEqual(
+        kept.map((path) => `https://libtmux.org/en/${path}`).sort(),
+      )
     } finally {
       await rm(dir, { recursive: true, force: true })
     }
diff --git a/site/test/stage-port-docs.outer.test.ts b/site/test/stage-port-docs.outer.test.ts
index 71b030d81..d200f10d9 100644
--- a/site/test/stage-port-docs.outer.test.ts
+++ b/site/test/stage-port-docs.outer.test.ts
@@ -1,5 +1,15 @@
 import { execFileSync, spawnSync } from 'node:child_process'
-import { copyFileSync, cpSync, existsSync, mkdirSync, mkdtempSync, readFileSync, rmSync, symlinkSync, writeFileSync } from 'node:fs'
+import {
+  copyFileSync,
+  cpSync,
+  existsSync,
+  mkdirSync,
+  mkdtempSync,
+  readFileSync,
+  rmSync,
+  symlinkSync,
+  writeFileSync,
+} from 'node:fs'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
 import { expect, it } from 'vitest'
@@ -8,24 +18,38 @@ import { PORTS } from '../src/lib/ports.ts'
 
 const root = new URL('../../', import.meta.url).pathname
 const cachedRevision = 'a'.repeat(40)
-const files = ['scripts/stage-port-docs.mjs', 'site/src/lib/ports.ts',
-  'site/src/lib/site-root.ts', 'site/src/lib/cooldown.ts', 'site/src/lib/port-documentation.ts',
-  'site/src/lib/versions.ts']
+const files = [
+  'scripts/stage-port-docs.mjs',
+  'site/src/lib/ports.ts',
+  'site/src/lib/site-root.ts',
+  'site/src/lib/cooldown.ts',
+  'site/src/lib/port-documentation.ts',
+  'site/src/lib/versions.ts',
+]
 const stagedPorts = ['ruby', 'lua', 'powershell', 'julia', 'kotlin', 'scala', 'fsharp']
 
-function fixture(slug: 'ruby' | 'lua' | 'kotlin', run: (fixture: {
-  directory: string; checkout: string; revision: string;
-  write: (path: string, value: string) => void;
-  artifact: (port: string, revision: string, label: string) => string;
-  invoke: (...args: string[]) => ReturnType<typeof invokeGenerator>;
-}) => void) {
+function fixture(
+  slug: 'ruby' | 'lua' | 'kotlin',
+  run: (fixture: {
+    directory: string
+    checkout: string
+    revision: string
+    write: (path: string, value: string) => void
+    artifact: (port: string, revision: string, label: string) => string
+    invoke: (...args: string[]) => ReturnType<typeof invokeGenerator>
+  }) => void,
+) {
   const directory = mkdtempSync(join(tmpdir(), 'libtmux-staged-publication-'))
   const checkout = join(directory, 'source')
-  const write = (path: string, value: string) => { mkdirSync(dirname(path), { recursive: true }); writeFileSync(path, value) }
-  const artifact = (port: string, revision: string, label: string) => JSON.stringify({
-    source: { repository: PORTS.find((entry) => entry.slug === port)!.repo, revision },
-    guides: Object.keys(stagedRoutesFor(port)).map((path) => ({ path, content: `# Guide\n\n${label}-${port}\n` })),
-  })
+  const write = (path: string, value: string) => {
+    mkdirSync(dirname(path), { recursive: true })
+    writeFileSync(path, value)
+  }
+  const artifact = (port: string, revision: string, label: string) =>
+    JSON.stringify({
+      source: { repository: PORTS.find((entry) => entry.slug === port)!.repo, revision },
+      guides: Object.keys(stagedRoutesFor(port)).map((path) => ({ path, content: `# Guide\n\n${label}-${port}\n` })),
+    })
   try {
     for (const file of files) {
       mkdirSync(dirname(join(directory, file)), { recursive: true })
@@ -36,108 +60,158 @@ function fixture(slug: 'ruby' | 'lua' | 'kotlin', run: (fixture: {
     write(join(directory, 'package.json'), '{"type":"module"}')
     for (const port of stagedPorts) {
       write(join(directory, `site/src/data/port-guides/${port}.json`), artifact(port, cachedRevision, 'cached'))
-      write(join(directory, `site/src/data/api/${port}.json`), JSON.stringify({
-        revision: cachedRevision, symbols: [],
-        ...(port === 'powershell' ? { nativeProvenance: { files: [] } } : {}),
-      }))
+      write(
+        join(directory, `site/src/data/api/${port}.json`),
+        JSON.stringify({
+          revision: cachedRevision,
+          symbols: [],
+          ...(port === 'powershell' ? { nativeProvenance: { files: [] } } : {}),
+        }),
+      )
     }
     let revision = 'b'.repeat(40)
     if (slug === 'kotlin') {
       for (const path of Object.keys(stagedRoutesFor(slug))) write(join(checkout, path), '# Guide\n\nfresh-kotlin\n')
-      const git = (...args: string[]) => execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: 'pipe' }).trim()
+      const git = (...args: string[]) =>
+        execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: 'pipe' }).trim()
       git('init', '-q')
       git('add', '.')
       git('-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid', 'commit', '-qm', 'Selected source')
       revision = git('rev-parse', 'HEAD')
     }
-    const env = { ...process.env, LIBTMUX_DOCS_PORT: slug, LIBTMUX_DOCS_SOURCE_SHA: revision,
-      [`LIBTMUX_DOCS_CHECKOUT_${slug.toUpperCase()}`]: checkout }
-    run({ directory, checkout, revision, write, artifact,
-      invoke: (...args) => invokeGenerator(directory, env, args) })
+    const env = {
+      ...process.env,
+      LIBTMUX_DOCS_PORT: slug,
+      LIBTMUX_DOCS_SOURCE_SHA: revision,
+      [`LIBTMUX_DOCS_CHECKOUT_${slug.toUpperCase()}`]: checkout,
+    }
+    run({ directory, checkout, revision, write, artifact, invoke: (...args) => invokeGenerator(directory, env, args) })
   } finally {
     rmSync(directory, { recursive: true, force: true })
   }
 }
 
 function invokeGenerator(directory: string, env: NodeJS.ProcessEnv, args: string[]) {
-  return spawnSync(process.execPath, [join(directory, 'scripts/stage-port-docs.mjs'), ...args],
-    { encoding: 'utf8', env, timeout: 10000 })
+  return spawnSync(process.execPath, [join(directory, 'scripts/stage-port-docs.mjs'), ...args], {
+    encoding: 'utf8',
+    env,
+    timeout: 10000,
+  })
 }
 
 it('leaves the preview mount to Markdown while selecting the parent API version', () => {
   fixture('lua', ({ directory, artifact, write }) => {
     const guides = JSON.parse(artifact('fsharp', cachedRevision, 'cached'))
-    guides.guides.find((guide: { path: string }) => guide.path === 'docs/fsharp/supported-query-fields.md').content
-      += '\n- Required depth: `Windows`\n'
+    guides.guides.find((guide: { path: string }) => guide.path === 'docs/fsharp/supported-query-fields.md').content +=
+      '\n- Required depth: `Windows`\n'
     write(join(directory, 'site/src/data/port-guides/fsharp.json'), JSON.stringify(guides))
-    write(join(directory, 'site/src/data/api/csharp.json'), JSON.stringify({ symbols: [{
-      id: 'LibTmux.SnapshotDepth.Windows', parent: 'LibTmux.SnapshotDepth', kind: 'constant',
-      product: 'core', slug: 'libtmux-snapshotdepth-windows',
-    }] }))
-    const run = invokeGenerator(directory, { ...process.env, LIBTMUX_DOCS_ROOT: '/pr-93/en/',
-      LIBTMUX_DOCS_PORT_ROOT: '/pr-93/en/', LIBTMUX_DOCS_PORT_DEFAULTS: '{"csharp":"v0.0.0-alpha.18"}',
-    }, ['--wrappers'])
+    write(
+      join(directory, 'site/src/data/api/csharp.json'),
+      JSON.stringify({
+        symbols: [
+          {
+            id: 'LibTmux.SnapshotDepth.Windows',
+            parent: 'LibTmux.SnapshotDepth',
+            kind: 'constant',
+            product: 'core',
+            slug: 'libtmux-snapshotdepth-windows',
+          },
+        ],
+      }),
+    )
+    const run = invokeGenerator(
+      directory,
+      {
+        ...process.env,
+        LIBTMUX_DOCS_ROOT: '/pr-93/en/',
+        LIBTMUX_DOCS_PORT_ROOT: '/pr-93/en/',
+        LIBTMUX_DOCS_PORT_DEFAULTS: '{"csharp":"v0.0.0-alpha.18"}',
+      },
+      ['--wrappers'],
+    )
     expect(run.status, run.stderr).toBe(0)
-    const guide = readFileSync(join(directory,
-      'site/src/content/docs/_staged/fsharp/guides/supported-query-fields/index.md'), 'utf8')
+    const guide = readFileSync(
+      join(directory, 'site/src/content/docs/_staged/fsharp/guides/supported-query-fields/index.md'),
+      'utf8',
+    )
     expect(guide).toContain('[`Windows`](/csharp/v0.0.0-alpha.18/reference/libtmux-snapshotdepth-windows/)')
     expect(guide).not.toContain('/pr-93/')
   })
 })
 
-it.each(['ruby', 'lua', 'kotlin'] as const)('stages other caches before accepting only the selected %s source', (slug) => {
-  fixture(slug, ({ directory, checkout, revision, write, artifact, invoke }) => {
-    const staged = join(directory, 'site/src/content/docs/_staged')
-    const cache = join(directory, `site/src/data/port-guides/${slug}.json`)
-    const cachedBytes = readFileSync(cache, 'utf8')
-    const otherCaches = Object.fromEntries(stagedPorts.filter((port) => port !== slug)
-      .map((port) => [port, readFileSync(join(directory, `site/src/data/port-guides/${port}.json`), 'utf8')]))
-    const baseline = invoke('--cached')
-    expect(baseline.status, baseline.stderr).toBe(0)
-    expect(existsSync(join(staged, slug))).toBe(false)
-    expect(readFileSync(cache, 'utf8')).toBe(cachedBytes)
-    for (const port of stagedPorts.filter((port) => port !== slug)) {
-      const route = Object.values(stagedRoutesFor(port))[0].route
-      expect(readFileSync(join(staged, port, route, 'index.md'), 'utf8')).toContain(`cached-${port}`)
-    }
+it.each(['ruby', 'lua', 'kotlin'] as const)(
+  'stages other caches before accepting only the selected %s source',
+  (slug) => {
+    fixture(slug, ({ directory, checkout, revision, write, artifact, invoke }) => {
+      const staged = join(directory, 'site/src/content/docs/_staged')
+      const cache = join(directory, `site/src/data/port-guides/${slug}.json`)
+      const cachedBytes = readFileSync(cache, 'utf8')
+      const otherCaches = Object.fromEntries(
+        stagedPorts
+          .filter((port) => port !== slug)
+          .map((port) => [port, readFileSync(join(directory, `site/src/data/port-guides/${port}.json`), 'utf8')]),
+      )
+      const baseline = invoke('--cached')
+      expect(baseline.status, baseline.stderr).toBe(0)
+      expect(existsSync(join(staged, slug))).toBe(false)
+      expect(readFileSync(cache, 'utf8')).toBe(cachedBytes)
+      for (const port of stagedPorts.filter((port) => port !== slug)) {
+        const route = Object.values(stagedRoutesFor(port))[0].route
+        expect(readFileSync(join(staged, port, route, 'index.md'), 'utf8')).toContain(`cached-${port}`)
+      }
 
-    const explicit = invoke('--cached', '--port', slug)
-    expect(explicit.status).not.toBe(0)
-    expect(explicit.stderr).toContain(`--cached cannot stage selected publication port ${slug}`)
-    expect(readFileSync(cache, 'utf8')).toBe(cachedBytes)
+      const explicit = invoke('--cached', '--port', slug)
+      expect(explicit.status).not.toBe(0)
+      expect(explicit.stderr).toContain(`--cached cannot stage selected publication port ${slug}`)
+      expect(readFileSync(cache, 'utf8')).toBe(cachedBytes)
 
-    if (slug !== 'kotlin') {
-      write(join(directory, `site/src/data/api/${slug}.json`), JSON.stringify({ revision }))
-      write(join(checkout, 'docs/_build/api.json'), artifact(slug, revision, 'fresh'))
-    }
-    const fresh = invoke('--port', slug, ...(slug === 'kotlin' ? ['--from-source'] : []))
-    expect(fresh.status, fresh.stderr).toBe(0)
-    const route = Object.values(stagedRoutesFor(slug))[0].route
-    const rendered = join(staged, slug, route, 'index.md')
-    expect(readFileSync(rendered, 'utf8')).toContain(`fresh-${slug}`)
-    expect(readFileSync(rendered, 'utf8')).toContain(revision)
-    expect(JSON.parse(readFileSync(cache, 'utf8')).source.revision).toBe(revision)
-    const wrappers = invoke('--wrappers')
-    expect(wrappers.status, wrappers.stderr).toBe(0)
-    const renderedBytes = readFileSync(rendered, 'utf8')
-    expect(renderedBytes).toContain(`fresh-${slug}`)
-    expect(renderedBytes).toContain(revision)
-    for (const [port, bytes] of Object.entries(otherCaches)) {
-      expect(readFileSync(join(directory, `site/src/data/port-guides/${port}.json`), 'utf8')).toBe(bytes)
-    }
+      if (slug !== 'kotlin') {
+        write(join(directory, `site/src/data/api/${slug}.json`), JSON.stringify({ revision }))
+        write(join(checkout, 'docs/_build/api.json'), artifact(slug, revision, 'fresh'))
+      }
+      const fresh = invoke('--port', slug, ...(slug === 'kotlin' ? ['--from-source'] : []))
+      expect(fresh.status, fresh.stderr).toBe(0)
+      const route = Object.values(stagedRoutesFor(slug))[0].route
+      const rendered = join(staged, slug, route, 'index.md')
+      expect(readFileSync(rendered, 'utf8')).toContain(`fresh-${slug}`)
+      expect(readFileSync(rendered, 'utf8')).toContain(revision)
+      expect(JSON.parse(readFileSync(cache, 'utf8')).source.revision).toBe(revision)
+      const wrappers = invoke('--wrappers')
+      expect(wrappers.status, wrappers.stderr).toBe(0)
+      const renderedBytes = readFileSync(rendered, 'utf8')
+      expect(renderedBytes).toContain(`fresh-${slug}`)
+      expect(renderedBytes).toContain(revision)
+      for (const [port, bytes] of Object.entries(otherCaches)) {
+        expect(readFileSync(join(directory, `site/src/data/port-guides/${port}.json`), 'utf8')).toBe(bytes)
+      }
 
-    const wrong = 'c'.repeat(40)
-    if (slug === 'kotlin') {
-      execFileSync('git', ['-C', checkout, '-c', 'user.name=Fixture', '-c', 'user.email=fixture@example.invalid',
-        'commit', '--allow-empty', '-qm', 'Different source'], { stdio: 'pipe' })
-    } else {
-      write(join(directory, `site/src/data/api/${slug}.json`), JSON.stringify({ revision: wrong }))
-      write(join(checkout, 'docs/_build/api.json'), artifact(slug, wrong, 'wrong'))
-    }
-    const rejected = invoke('--port', slug, ...(slug === 'kotlin' ? ['--from-source'] : []))
-    expect(rejected.status).not.toBe(0)
-    expect(rejected.stderr).toContain(`${slug}: expected source ${revision}, artifact records`)
-    expect(readFileSync(rendered, 'utf8')).toBe(renderedBytes)
-    expect(JSON.parse(readFileSync(cache, 'utf8')).source.revision).toBe(revision)
-  })
-})
+      const wrong = 'c'.repeat(40)
+      if (slug === 'kotlin') {
+        execFileSync(
+          'git',
+          [
+            '-C',
+            checkout,
+            '-c',
+            'user.name=Fixture',
+            '-c',
+            'user.email=fixture@example.invalid',
+            'commit',
+            '--allow-empty',
+            '-qm',
+            'Different source',
+          ],
+          { stdio: 'pipe' },
+        )
+      } else {
+        write(join(directory, `site/src/data/api/${slug}.json`), JSON.stringify({ revision: wrong }))
+        write(join(checkout, 'docs/_build/api.json'), artifact(slug, wrong, 'wrong'))
+      }
+      const rejected = invoke('--port', slug, ...(slug === 'kotlin' ? ['--from-source'] : []))
+      expect(rejected.status).not.toBe(0)
+      expect(rejected.stderr).toContain(`${slug}: expected source ${revision}, artifact records`)
+      expect(readFileSync(rendered, 'utf8')).toBe(renderedBytes)
+      expect(JSON.parse(readFileSync(cache, 'utf8')).source.revision).toBe(revision)
+    })
+  },
+)
diff --git a/site/test/stage-port-docs.test.ts b/site/test/stage-port-docs.test.ts
index ab4ebea30..489d424f9 100644
--- a/site/test/stage-port-docs.test.ts
+++ b/site/test/stage-port-docs.test.ts
@@ -3,7 +3,13 @@ import { mkdirSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from 'nod
 import { execFileSync } from 'node:child_process'
 import { tmpdir } from 'node:os'
 import { dirname, join } from 'node:path'
-import { artifactFromRevision, linkSnapshotDepths, rewriteLinks, stagedPortGuides, stagedRoutesFor } from '../../scripts/stage-port-docs.mjs'
+import {
+  artifactFromRevision,
+  linkSnapshotDepths,
+  rewriteLinks,
+  stagedPortGuides,
+  stagedRoutesFor,
+} from '../../scripts/stage-port-docs.mjs'
 import { PORTS } from '../src/lib/ports'
 import { SOURCE_GUIDE_PORTS } from '../src/lib/port-documentation'
 import scalaGuides from '../src/data/port-guides/scala.json'
@@ -16,7 +22,8 @@ describe('integrated guide inputs', () => {
 
   it('reads the integrated commit regardless of newer HEAD or dirty files', () => {
     const checkout = mkdtempSync(join(tmpdir(), 'libtmux-integrated-guides-'))
-    const git = (...args: string[]) => execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: 'pipe' }).trim()
+    const git = (...args: string[]) =>
+      execFileSync('git', ['-C', checkout, ...args], { encoding: 'utf8', stdio: 'pipe' }).trim()
     try {
       git('init', '-q')
       for (const path of Object.keys(stagedRoutesFor('lua'))) {
@@ -44,8 +51,9 @@ describe('integrated guide inputs', () => {
     const checkout = mode === 'missing-checkout' ? join(directory, 'absent') : directory
     try {
       if (mode === 'missing-commit') execFileSync('git', ['-C', checkout, 'init', '-q'])
-      expect(() => artifactFromRevision(port, checkout, 'a'.repeat(40)))
-        .toThrow(`integrated guides need libtmux/libtmux-lua@${'a'.repeat(40)} in ${checkout}. Set LIBTMUX_DOCS_CHECKOUT_LUA to a local checkout containing that commit; this check does not fetch.`)
+      expect(() => artifactFromRevision(port, checkout, 'a'.repeat(40))).toThrow(
+        `integrated guides need libtmux/libtmux-lua@${'a'.repeat(40)} in ${checkout}. Set LIBTMUX_DOCS_CHECKOUT_LUA to a local checkout containing that commit; this check does not fetch.`,
+      )
     } finally {
       rmSync(directory, { recursive: true, force: true })
     }
@@ -56,17 +64,26 @@ describe('staged port guide links', () => {
   it('keeps native PowerShell command and parameter links in their actual API product', () => {
     const artifact = structuredClone(powershellGuides)
     const guide = artifact.guides.find((entry) => entry.path === 'docs/capture.md')!
-    guide.content += '\n[content](reference/LibTmux/Get-TmuxPaneContent.md)\n'
-      + '[join](reference/LibTmux/Get-TmuxPaneContent.md#-joinwrappedlines)\n'
-      + '[confirm](reference/LibTmux/Disconnect-TmuxControl.md#-confirm)\n'
-      + '[plan](reference/LibTmux.Workspace/Invoke-TmuxWorkspace.md#-plan)\n'
-      + '[unknown](reference/LibTmux/Get-TmuxPaneContent.md#unknown-section)\n'
+    guide.content +=
+      '\n[content](reference/LibTmux/Get-TmuxPaneContent.md)\n' +
+      '[join](reference/LibTmux/Get-TmuxPaneContent.md#-joinwrappedlines)\n' +
+      '[confirm](reference/LibTmux/Disconnect-TmuxControl.md#-confirm)\n' +
+      '[plan](reference/LibTmux.Workspace/Invoke-TmuxWorkspace.md#-plan)\n' +
+      '[unknown](reference/LibTmux/Get-TmuxPaneContent.md#unknown-section)\n'
     const page = stagedPortGuides('powershell', artifact).get('powershell/guides/capture/index.md')!
     expect(page).toContain('[content](../../reference/libtmux-get-tmuxpanecontent/)')
-    expect(page).toContain('[join](../../reference/libtmux-get-tmuxpanecontent/#LibTmux%5CGet-TmuxPaneContent.parameter.JoinWrappedLines)')
-    expect(page).toContain('[confirm](../../reference/libtmux-disconnect-tmuxcontrol/#LibTmux%5CDisconnect-TmuxControl.parameter.Confirm)')
-    expect(page).toContain('[plan](../../workspace/reference/libtmux-workspace-invoke-tmuxworkspace/#LibTmux.Workspace%5CInvoke-TmuxWorkspace.parameter.Plan)')
-    expect(page).toContain(`[unknown](https://github.com/libtmux/libtmux-powershell/blob/${artifact.source.revision}/docs/reference/LibTmux/Get-TmuxPaneContent.md#unknown-section)`)
+    expect(page).toContain(
+      '[join](../../reference/libtmux-get-tmuxpanecontent/#LibTmux%5CGet-TmuxPaneContent.parameter.JoinWrappedLines)',
+    )
+    expect(page).toContain(
+      '[confirm](../../reference/libtmux-disconnect-tmuxcontrol/#LibTmux%5CDisconnect-TmuxControl.parameter.Confirm)',
+    )
+    expect(page).toContain(
+      '[plan](../../workspace/reference/libtmux-workspace-invoke-tmuxworkspace/#LibTmux.Workspace%5CInvoke-TmuxWorkspace.parameter.Plan)',
+    )
+    expect(page).toContain(
+      `[unknown](https://github.com/libtmux/libtmux-powershell/blob/${artifact.source.revision}/docs/reference/LibTmux/Get-TmuxPaneContent.md#unknown-section)`,
+    )
   })
 
   it.each(['julia', 'ruby'])('%s retains its MCP task identity without creating a redirect', (port) => {
@@ -112,28 +129,36 @@ describe('staged port guide links', () => {
 
   it('keeps registered documentation links inside the mounted site with their version and fragment', () => {
     const result = rewriteLinks(
-      '[MCP](https://libtmux.org/en/dotnet/latest/mcp/#install)\n\n'
-        + '[server]: https://libtmux.org/en/dotnet/v0.1.0/reference/server/?view=all#parameters\n'
-        + '[workspace]: https://libtmux.org/en/csharp/latest/workspace/reference/libtmux-workspace-workspacebuildexception/\n'
-        + '[result]: https://libtmux.org/en/julia/latest/mcp/tools/run_operations/#mcp.tool.run_operations.output/anyOf/0/properties/atomic\n'
-        + '[foreign]: https://libtmux.org/en/not-a-port/latest/reference/\n',
-      'docs/mcp.md', 'guides/mcp', {}, 'libtmux/libtmux-powershell', 'abc123',
+      '[MCP](https://libtmux.org/en/dotnet/latest/mcp/#install)\n\n' +
+        '[server]: https://libtmux.org/en/dotnet/v0.1.0/reference/server/?view=all#parameters\n' +
+        '[workspace]: https://libtmux.org/en/csharp/latest/workspace/reference/libtmux-workspace-workspacebuildexception/\n' +
+        '[result]: https://libtmux.org/en/julia/latest/mcp/tools/run_operations/#mcp.tool.run_operations.output/anyOf/0/properties/atomic\n' +
+        '[foreign]: https://libtmux.org/en/not-a-port/latest/reference/\n',
+      'docs/mcp.md',
+      'guides/mcp',
+      {},
+      'libtmux/libtmux-powershell',
+      'abc123',
     )
     expect(result).toContain('[MCP](/csharp/latest/mcp/#install)')
     expect(result).toContain('[server]: /csharp/v0.1.0/reference/server/?view=all#parameters')
-    expect(result).toContain('[workspace]: /csharp/latest/workspace/reference/libtmux-workspace-workspacebuildexception/')
-    expect(result).toContain('[result]: /julia/latest/mcp/tools/run_operations/#mcp.tool.run_operations.output/anyOf/0/properties/atomic')
+    expect(result).toContain(
+      '[workspace]: /csharp/latest/workspace/reference/libtmux-workspace-workspacebuildexception/',
+    )
+    expect(result).toContain(
+      '[result]: /julia/latest/mcp/tools/run_operations/#mcp.tool.run_operations.output/anyOf/0/properties/atomic',
+    )
     expect(result).toContain('[foreign]: https://libtmux.org/en/not-a-port/latest/reference/')
   })
 
   it('preserves foreign, source, image and example URLs when correcting the old C# documentation slug', () => {
-    const source = '[foreign](https://example.org/en/dotnet/latest/mcp/)\n\n'
-      + '[source](https://github.com/libtmux/libtmux-dotnet/blob/main/docs/mcp.md)\n\n'
-      + '![image](https://libtmux.org/en/dotnet/latest/image.png)\n\n'
-      + '`https://libtmux.org/en/dotnet/latest/mcp/`\n\n'
-      + '```text\n[MCP](https://libtmux.org/en/dotnet/latest/mcp/)\n```\n'
-    expect(rewriteLinks(source, 'docs/mcp.md', 'guides/mcp', {}, 'libtmux/libtmux-powershell', 'abc123'))
-      .toBe(source)
+    const source =
+      '[foreign](https://example.org/en/dotnet/latest/mcp/)\n\n' +
+      '[source](https://github.com/libtmux/libtmux-dotnet/blob/main/docs/mcp.md)\n\n' +
+      '![image](https://libtmux.org/en/dotnet/latest/image.png)\n\n' +
+      '`https://libtmux.org/en/dotnet/latest/mcp/`\n\n' +
+      '```text\n[MCP](https://libtmux.org/en/dotnet/latest/mcp/)\n```\n'
+    expect(rewriteLinks(source, 'docs/mcp.md', 'guides/mcp', {}, 'libtmux/libtmux-powershell', 'abc123')).toBe(source)
   })
 
   it('takes reader routes and aliases from the port documentation catalog', () => {
@@ -169,9 +194,13 @@ describe('staged port guide links', () => {
     const otherRepo = 'https://github.com/other/project/blob/master/docs/query.md'
     const example = `\`${own}master/docs/query.md\``
     const result = rewriteLinks(
-      `[current](${own}master/docs/query.md#filters) [main](${own}main/docs/query.md) `
-        + `[pinned](${own}abc123/docs/query.md) [old](${historical}) [other](${otherRepo}) ${example}`,
-      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-lua', 'abc123',
+      `[current](${own}master/docs/query.md#filters) [main](${own}main/docs/query.md) ` +
+        `[pinned](${own}abc123/docs/query.md) [old](${historical}) [other](${otherRepo}) ${example}`,
+      'docs/runtime.md',
+      'guides/source/runtime',
+      routes,
+      'libtmux/libtmux-lua',
+      'abc123',
     )
     expect(result).toContain('[current](../query/#filters)')
     expect(result).toContain('[main](../query/)')
@@ -188,15 +217,18 @@ describe('staged port guide links', () => {
     }
     expect(staged).toContain('](../../reference/)')
     expect(staged).not.toMatch(/https:\/\/github.com\/libtmux\/libtmux-dotnet\/blob\/master\/docs\/fsharp\//)
-    expect(staged).toContain(`https://github.com/libtmux/libtmux-dotnet/blob/${fsharpGuides.source.revision}/examples/LibTmux.FSharp.Quickstart/Program.fs`)
+    expect(staged).toContain(
+      `https://github.com/libtmux/libtmux-dotnet/blob/${fsharpGuides.source.revision}/examples/LibTmux.FSharp.Quickstart/Program.fs`,
+    )
   })
 
   it('keeps F# query API links in the owned reference', () => {
     const artifact = structuredClone(fsharpGuides)
     const source = artifact.guides.find((guide) => guide.path === 'docs/fsharp/queries.md')!
-    source.content += '\n[Server](../fsharp-reference/reference/libtmux-fsharp-server.md)\n'
-      + '[sessions](../fsharp-reference/reference/libtmux-fsharp-server.md#sessions)\n'
-      + '[matching](../fsharp-reference/reference/libtmux-fsharp-query.md#matching)\n'
+    source.content +=
+      '\n[Server](../fsharp-reference/reference/libtmux-fsharp-server.md)\n' +
+      '[sessions](../fsharp-reference/reference/libtmux-fsharp-server.md#sessions)\n' +
+      '[matching](../fsharp-reference/reference/libtmux-fsharp-query.md#matching)\n'
     const files = stagedPortGuides('fsharp', artifact)
     const queries = files.get('fsharp/guides/queries/index.md')!
     expect(queries).toContain('](../../reference/libtmux-fsharp-server/)')
@@ -207,7 +239,9 @@ describe('staged port guide links', () => {
   })
 
   it('links every native descriptor depth to its exact .NET enum constant', () => {
-    const original = fsharpGuides.guides.find((guide) => guide.path === 'docs/fsharp/supported-query-fields.md')!.content
+    const original = fsharpGuides.guides.find(
+      (guide) => guide.path === 'docs/fsharp/supported-query-fields.md',
+    )!.content
     const root = '/pr-93/en/csharp/v0.0.0-alpha.18/reference/'
     const result = linkSnapshotDepths(original, csharpModel.symbols, root)
     const depths = [...original.matchAll(/^- Required depth: `([^`]+)`$/gm)].map((match) => match[1])
@@ -215,37 +249,45 @@ describe('staged port guide links', () => {
     expect(depths.filter((value) => value === 'Windows')).toHaveLength(7)
     for (const value of new Set(depths)) {
       const symbol = csharpModel.symbols.find((entry) => entry.id === `LibTmux.SnapshotDepth.${value}`)!
-      expect(result.split(`- Required depth: [\`${value}\`](${root}${symbol.slug}/)`).length - 1)
-        .toBe(depths.filter((depth) => depth === value).length)
+      expect(result.split(`- Required depth: [\`${value}\`](${root}${symbol.slug}/)`).length - 1).toBe(
+        depths.filter((depth) => depth === value).length,
+      )
     }
     expect(result.replace(/\[(`[^`]+`)\]\([^\n)]+\)/g, '$1')).toBe(original)
     const staged = stagedPortGuides('fsharp', fsharpGuides).get('fsharp/guides/supported-query-fields/index.md')!
-    expect(staged.match(/- Required depth: \[`[^`]+`\]\([^\n)]+\/reference\/libtmux-snapshotdepth-[^/]+\/\)/g))
-      .toHaveLength(27)
+    expect(
+      staged.match(/- Required depth: \[`[^`]+`\]\([^\n)]+\/reference\/libtmux-snapshotdepth-[^/]+\/\)/g),
+    ).toHaveLength(27)
     expect(staged).not.toContain('/libtmux-fsharp-sessionspec-windows/')
   })
 
-  it.each(['missing', 'duplicate', 'wrong-owner', 'wrong-kind', 'wrong-product'])('rejects a %s depth declaration', (mode) => {
-    const actual = csharpModel.symbols.find((entry) => entry.id === 'LibTmux.SnapshotDepth.Windows')!
-    const candidate = { ...actual }
-    if (mode === 'wrong-owner') candidate.parent = 'LibTmux.FSharp.SessionSpec'
-    if (mode === 'wrong-kind') candidate.kind = 'property'
-    if (mode === 'wrong-product') candidate.product = 'workspace'
-    const symbols = mode === 'missing' ? [] : mode === 'duplicate' ? [candidate, candidate] : [candidate]
-    expect(() => linkSnapshotDepths('- Required depth: `Windows`\n', symbols, '/csharp/latest/reference/'))
-      .toThrow('F# descriptor depth must resolve to one public .NET enum constant: LibTmux.SnapshotDepth.Windows')
-  })
+  it.each(['missing', 'duplicate', 'wrong-owner', 'wrong-kind', 'wrong-product'])(
+    'rejects a %s depth declaration',
+    (mode) => {
+      const actual = csharpModel.symbols.find((entry) => entry.id === 'LibTmux.SnapshotDepth.Windows')!
+      const candidate = { ...actual }
+      if (mode === 'wrong-owner') candidate.parent = 'LibTmux.FSharp.SessionSpec'
+      if (mode === 'wrong-kind') candidate.kind = 'property'
+      if (mode === 'wrong-product') candidate.product = 'workspace'
+      const symbols = mode === 'missing' ? [] : mode === 'duplicate' ? [candidate, candidate] : [candidate]
+      expect(() => linkSnapshotDepths('- Required depth: `Windows`\n', symbols, '/csharp/latest/reference/')).toThrow(
+        'F# descriptor depth must resolve to one public .NET enum constant: LibTmux.SnapshotDepth.Windows',
+      )
+    },
+  )
 
   it('keeps code, existing links and unrelated bare names out of depth linking', () => {
-    const source = 'A `Windows` property.\n\n- Other property: `Windows`\n\n'
-      + '```text\n- Required depth: `Windows`\n```\n\n'
-      + '- Required depth: [`Windows`](https://example.org/depth)\n'
+    const source =
+      'A `Windows` property.\n\n- Other property: `Windows`\n\n' +
+      '```text\n- Required depth: `Windows`\n```\n\n' +
+      '- Required depth: [`Windows`](https://example.org/depth)\n'
     expect(linkSnapshotDepths(source, [], '/csharp/latest/reference/')).toBe(source)
     const artifact = structuredClone(fsharpGuides)
     const guide = artifact.guides.find((entry) => entry.path === 'docs/fsharp/queries.md')!
     guide.content += '\n- Required depth: `Windows`\n'
-    expect(stagedPortGuides('fsharp', artifact).get('fsharp/guides/queries/index.md'))
-      .toContain('- Required depth: `Windows`')
+    expect(stagedPortGuides('fsharp', artifact).get('fsharp/guides/queries/index.md')).toContain(
+      '- Required depth: `Windows`',
+    )
   })
 
   it('pins non-staged source links while preserving historical links and inline images', () => {
@@ -253,9 +295,17 @@ describe('staged port guide links', () => {
     const destinations = ['master', 'main', 'abc123'].map((ref) => `[source](${own}${ref}/src/main.lua#run)`)
     const image = `![source](${own}master/art/example.png)`
     const historical = `[old](${own}older/src/main.lua#run)`
-    const result = rewriteLinks([...destinations, image, historical].join('\n\n'),
-      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-lua', 'abc123')
-    expect(result.match(/\[source\]\(https:\/\/github.com\/libtmux\/libtmux-lua\/blob\/abc123\/src\/main.lua#run\)/g)).toHaveLength(3)
+    const result = rewriteLinks(
+      [...destinations, image, historical].join('\n\n'),
+      'docs/runtime.md',
+      'guides/source/runtime',
+      routes,
+      'libtmux/libtmux-lua',
+      'abc123',
+    )
+    expect(
+      result.match(/\[source\]\(https:\/\/github.com\/libtmux\/libtmux-lua\/blob\/abc123\/src\/main.lua#run\)/g),
+    ).toHaveLength(3)
     expect(result).toContain(image)
     expect(result).toContain(historical)
   })
@@ -263,7 +313,11 @@ describe('staged port guide links', () => {
   it('rewrites Scala reference links across lines without changing external links', () => {
     const result = rewriteLinks(
       '[query]: query.md#filters\n[source]:\n  ../src/Server.scala\n[external]: https://example.org/\n',
-      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-java', 'abc123',
+      'docs/runtime.md',
+      'guides/source/runtime',
+      routes,
+      'libtmux/libtmux-java',
+      'abc123',
     )
     expect(result).toContain('[query]: ../query/#filters')
     expect(result).toContain('[source]: https://github.com/libtmux/libtmux-java/blob/abc123/src/Server.scala')
@@ -280,8 +334,14 @@ describe('staged port guide links', () => {
       '\\[query](query.md)',
     ]
     const content = `${examples.join('\n\n')}\n\n[query](query.md#filters "Read filters")\n`
-    const result = rewriteLinks(content, 'docs/runtime.md', 'guides/source/runtime', routes,
-      'libtmux/libtmux-java', 'abc123')
+    const result = rewriteLinks(
+      content,
+      'docs/runtime.md',
+      'guides/source/runtime',
+      routes,
+      'libtmux/libtmux-java',
+      'abc123',
+    )
     for (const example of examples) expect(result).toContain(example)
     expect(result).toContain('[query](../query/#filters "Read filters")')
     expect(result).not.toContain('/docs/config')
@@ -290,9 +350,17 @@ describe('staged port guide links', () => {
   })
 
   it('rewrites images nested in links without damaging their labels', () => {
-    const result = rewriteLinks('[![example](../art/example.png "Example")](query.md#filters)',
-      'docs/runtime.md', 'guides/source/runtime', routes, 'libtmux/libtmux-java', 'abc123')
-    expect(result).toContain('[![example](https://github.com/libtmux/libtmux-java/raw/abc123/art/example.png "Example")](../query/#filters)')
+    const result = rewriteLinks(
+      '[![example](../art/example.png "Example")](query.md#filters)',
+      'docs/runtime.md',
+      'guides/source/runtime',
+      routes,
+      'libtmux/libtmux-java',
+      'abc123',
+    )
+    expect(result).toContain(
+      '[![example](https://github.com/libtmux/libtmux-java/raw/abc123/art/example.png "Example")](../query/#filters)',
+    )
   })
 
   it('stages the actual Scala generic calls unchanged', () => {
@@ -310,14 +378,34 @@ describe('staged port guide links', () => {
 
   it('extracts centered README titles without losing links or examples', () => {
     const header = [
-      '<!-- libtmux-logo -->', '<p>artwork</p>', '<!-- /libtmux-logo -->', '',
-      '<div align="center">', '', '# libtmux for Ruby', '',
-      'Create tmux sessions from Ruby. [Guide](docs/modes.md)', '', '</div>', '',
-      '## Example', '', '```ruby', 'puts "hello"', '```', '',
-      '<div align="center">', '', 'A later centered block.', '', '</div>', '',
+      '<!-- libtmux-logo -->',
+      '<p>artwork</p>',
+      '<!-- /libtmux-logo -->',
+      '',
+      '<div align="center">',
+      '',
+      '# libtmux for Ruby',
+      '',
+      'Create tmux sessions from Ruby. [Guide](docs/modes.md)',
+      '',
+      '</div>',
+      '',
+      '## Example',
+      '',
+      '```ruby',
+      'puts "hello"',
+      '```',
+      '',
+      '<div align="center">',
+      '',
+      'A later centered block.',
+      '',
+      '</div>',
+      '',
     ].join('\n')
     const guides = Object.keys(stagedRoutesFor('ruby')).map((path) => ({
-      path, content: path === 'README.md' ? header : '# Guide\n\nbody\n',
+      path,
+      content: path === 'README.md' ? header : '# Guide\n\nbody\n',
     }))
     const files = stagedPortGuides('ruby', {
       source: { repository: 'libtmux/libtmux-ruby', revision: '0123456789abcdef' },
diff --git a/site/test/swift-api-examples.test.ts b/site/test/swift-api-examples.test.ts
index 08cbaaece..9c096af0e 100644
--- a/site/test/swift-api-examples.test.ts
+++ b/site/test/swift-api-examples.test.ts
@@ -14,9 +14,19 @@ describe('complete Swift API programs', () => {
   it('covers construction, listing, creation, query, input and capture', () => {
     expect(examples).toHaveLength(21)
     expect(new Set(examples.map((example) => example.sourceFile)).size).toBe(9)
-    for (const id of ['Server', 'Server.sessions()', 'Server.windows()', 'Server.panes()',
-      'Server.panes(where:)', 'Server.sendKeys(_:to:literally:)', 'Server.capture(_:includingHistory:)']) {
-      expect(examples.some((example) => example.symbol === id), id).toBe(true)
+    for (const id of [
+      'Server',
+      'Server.sessions()',
+      'Server.windows()',
+      'Server.panes()',
+      'Server.panes(where:)',
+      'Server.sendKeys(_:to:literally:)',
+      'Server.capture(_:includingHistory:)',
+    ]) {
+      expect(
+        examples.some((example) => example.symbol === id),
+        id,
+      ).toBe(true)
     }
   })
 
@@ -34,10 +44,15 @@ describe('complete Swift API programs', () => {
       const block = blocks[file.block]
       expect(hash(block.code), file.name).toBe(file.sha256)
       expect(file).toHaveProperty('clipboardSha256', hash(block.code.replace(/\n$/, '')))
-      expect(exported.some((block) => hash(block.value + '\n') === file.sha256),
-        `${file.name} Markdown`).toBe(true)
-      expect(block.sourceUrl).toBe(`https://github.com/${model.repo}/blob/${example.sourceRevision}/${
-        file.name === 'Package.swift' ? 'Examples/Standalone/Package.swift' : example.sourceFile}`)
+      expect(
+        exported.some((block) => hash(block.value + '\n') === file.sha256),
+        `${file.name} Markdown`,
+      ).toBe(true)
+      expect(block.sourceUrl).toBe(
+        `https://github.com/${model.repo}/blob/${example.sourceRevision}/${
+          file.name === 'Package.swift' ? 'Examples/Standalone/Package.swift' : example.sourceFile
+        }`,
+      )
       for (const line of block.code.split('\n').filter((line) => /^\s*\/\//.test(line))) {
         expect(line.length).toBeLessThanOrEqual(100)
       }
@@ -47,10 +62,12 @@ describe('complete Swift API programs', () => {
     expect(program.code).toContain('import TmuxFixture')
     expect(program.code).toContain('@main')
     expect(program.intro).toContain('`Server`')
-    expect(blocks.filter((block) => block.lang === 'console')
-      .map((block) => block.code.replace(/^\$ /gm, '').trim())).toEqual(example.shellRecipe)
-    expect(example.consoleBlocks?.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim()))
-      .toEqual(example.shellRecipe)
+    expect(
+      blocks.filter((block) => block.lang === 'console').map((block) => block.code.replace(/^\$ /gm, '').trim()),
+    ).toEqual(example.shellRecipe)
+    expect(example.consoleBlocks?.map((index) => blocks[index].code.replace(/^\$ /gm, '').trim())).toEqual(
+      example.shellRecipe,
+    )
     expect(example.expectedOutputs.at(-1)).toEqual(blocks.at(-1)!.code.trimEnd().split('\n'))
   })
 })
diff --git a/site/test/switcher-targets.test.ts b/site/test/switcher-targets.test.ts
index e40f68e8c..1cbf67167 100644
--- a/site/test/switcher-targets.test.ts
+++ b/site/test/switcher-targets.test.ts
@@ -13,14 +13,25 @@ const describeIfAssembled = SITE_BUILT ? describe : describe.skip
 function samplePages(): string[] {
   const prefix = SITE_PREFIX
   const wanted = [
-    'index.html', 'concepts/index.html', 'mcp/tools/index.html',
-    'topics/architecture/index.html', 'py/index.html',
-    'py/latest/topics/architecture/index.html', 'ts/latest/topics/architecture/index.html',
-    'rs/index.html', 'reference/index.html', 'ts/latest/reference/index.html',
-    'ts/latest/reference/session-session-panes/index.html', 'ts/latest/reference/session-session-sessionbrand/index.html',
-    'ts/latest/mcp/reference/index.html', 'go/latest/workspace/reference/index.html',
+    'index.html',
+    'concepts/index.html',
+    'mcp/tools/index.html',
+    'topics/architecture/index.html',
+    'py/index.html',
+    'py/latest/topics/architecture/index.html',
+    'ts/latest/topics/architecture/index.html',
+    'rs/index.html',
+    'reference/index.html',
+    'ts/latest/reference/index.html',
+    'ts/latest/reference/session-session-panes/index.html',
+    'ts/latest/reference/session-session-sessionbrand/index.html',
+    'ts/latest/mcp/reference/index.html',
+    'go/latest/workspace/reference/index.html',
   ].map((page) => prefix + page)
-  wanted.push(`${PREVIEW_PREFIX.slice(1)}${PREVIEW_PREFIX ? '/' : ''}ja/index.html`, `${PREVIEW_PREFIX.slice(1)}${PREVIEW_PREFIX ? '/' : ''}ja/concepts/index.html`)
+  wanted.push(
+    `${PREVIEW_PREFIX.slice(1)}${PREVIEW_PREFIX ? '/' : ''}ja/index.html`,
+    `${PREVIEW_PREFIX.slice(1)}${PREVIEW_PREFIX ? '/' : ''}ja/concepts/index.html`,
+  )
   const present = wanted.filter((page) => existsSync(join(SITE, page)))
 
   return present
@@ -66,7 +77,10 @@ describeIfAssembled('switcher targets', () => {
     const noDocument = NO_PAGE_COUNTERPART.some((suffix) => page.endsWith(suffix))
     // The counterpart picker is distinct from the app/section picker. Keep
     // explicit exceptions so losing a document's control remains a failure.
-    const window = new Window({ url: `https://libtmux.org/${page}`, settings: { disableJavaScriptEvaluation: true, disableJavaScriptFileLoading: true, disableCSSFileLoading: true } })
+    const window = new Window({
+      url: `https://libtmux.org/${page}`,
+      settings: { disableJavaScriptEvaluation: true, disableJavaScriptFileLoading: true, disableCSSFileLoading: true },
+    })
     try {
       window.document.write(html)
       const allMenus = [...window.document.querySelectorAll('details[data-page-port-switcher]')]
@@ -78,7 +92,10 @@ describeIfAssembled('switcher targets', () => {
       for (const menu of allMenus) {
         const counterparts = [...menu.querySelectorAll('a[href]')].map((link) => link.getAttribute('href')!)
         expect(counterparts.length, `${page} has an available destination`).toBeGreaterThan(0)
-        expect(counterparts.filter((href) => !resolves(href)), `${page}: destinations missing on disk`).toEqual([])
+        expect(
+          counterparts.filter((href) => !resolves(href)),
+          `${page}: destinations missing on disk`,
+        ).toEqual([])
         for (const disabled of menu.querySelectorAll('[aria-disabled="true"]')) {
           expect(disabled.hasAttribute('href'), `${page} unavailable counterparts are not links`).toBe(false)
         }
@@ -91,7 +108,9 @@ describeIfAssembled('switcher targets', () => {
   it.each(pages.map((p) => [p]))('%s: every hreflang alternate resolves', (page) => {
     const html = readFileSync(join(SITE, page), 'utf8')
     const hrefs = [...html.matchAll(/<link[^>]+hreflang="[^"]+"[^>]+href="([^"]+)"/g)].map((m) => m[1])
-    expect(hrefs.filter((h) => !resolves(h)), `${page}: alternates with no page`).toEqual([])
+    expect(
+      hrefs.filter((h) => !resolves(h)),
+      `${page}: alternates with no page`,
+    ).toEqual([])
   })
-
 })
diff --git a/site/test/symbol-markdown.test.ts b/site/test/symbol-markdown.test.ts
index 4a5e16c24..f91fbcd4f 100644
--- a/site/test/symbol-markdown.test.ts
+++ b/site/test/symbol-markdown.test.ts
@@ -42,7 +42,9 @@ describe('API Markdown content parity', () => {
     const symbol = model.symbols.find((entry) => entry.id === 'mcp.server.createTmuxMcpServer')!
     const text = symbolMarkdown({ model, symbol })
     const signature = fromMarkdown(text).children.find((node) => node.type === 'code')!
-    expect(signature.type === 'code' && signature.value).toContain('createTmuxMcpServer(\n  tmux: Server,\n  options: {\n    readonly callerEnvironment?')
+    expect(signature.type === 'code' && signature.value).toContain(
+      'createTmuxMcpServer(\n  tmux: Server,\n  options: {\n    readonly callerEnvironment?',
+    )
     expect(signature.type === 'code' && signature.value).not.toContain('/**')
     expect(text).not.toContain(': :')
     const params = text.slice(text.indexOf('## Parameters'))
@@ -76,7 +78,10 @@ describe('API Markdown content parity', () => {
     expect(markdown).toContain('](/reference/libtmux-observation_cursor/)')
     const spans = index.linkText('[`observation_cursor`](@ref) and [Unicode](https://www.unicode.org/)', cursor)
     expect(spans.find((span) => span.kind === 'ref')?.link?.href).toBe('/reference/libtmux-observation_cursor/')
-    expect(spans.find((span) => span.kind === 'link')).toMatchObject({ text: 'Unicode', href: 'https://www.unicode.org/' })
+    expect(spans.find((span) => span.kind === 'link')).toMatchObject({
+      text: 'Unicode',
+      href: 'https://www.unicode.org/',
+    })
   })
 
   it('resolves PowerShell help links relative to their immutable source file', () => {
@@ -85,14 +90,20 @@ describe('API Markdown content parity', () => {
     const links = commands.flatMap((symbol) => symbol.command!.relatedLinks).filter((link) => link.href)
     expect(links.length).toBeGreaterThan(100)
     expect(links.every((link) => /^https:\/\//.test(link.href))).toBe(true)
-    expect(links.some((link) => link.href === `https://github.com/${model.repo}/blob/${model.revision}/docs/commands.md`)).toBe(true)
+    expect(
+      links.some((link) => link.href === `https://github.com/${model.repo}/blob/${model.revision}/docs/commands.md`),
+    ).toBe(true)
     const index = new SymbolIndex(model.symbols, (symbol) => `/reference/${symbol.slug}/`, 'powershell')
     const spans = index.linkText('[Guide](https://example.com/guide)')
     expect(spans).toEqual([{ kind: 'link', text: 'Guide', href: 'https://example.com/guide' }])
   })
 
   it('retains Julia method documentation, source links and optional-extension requirements', () => {
-    const model = extractJulia(JSON.parse(readFileSync(new URL('../../packages/api-model/test/fixtures/julia-native.json', import.meta.url), 'utf8')))
+    const model = extractJulia(
+      JSON.parse(
+        readFileSync(new URL('../../packages/api-model/test/fixtures/julia-native.json', import.meta.url), 'utf8'),
+      ),
+    )
     const index = new SymbolIndex(model.symbols, (symbol) => `/reference/${encodeURIComponent(symbol.id)}/`, 'julia')
     const kill = model.symbols.find((entry) => entry.id === 'LibTmux.kill_session')!
     const text = symbolMarkdown({ model, symbol: kill, index })
@@ -112,19 +123,31 @@ describe('API Markdown content parity', () => {
     const symbol = model.symbols.find((entry) => entry.id === 'libtmux::mcp::Arguments::Arguments')!
     const index = new SymbolIndex(model.symbols, (entry) => `/reference/${entry.slug}/`, 'cxx')
     const text = symbolMarkdown({ model, symbol, index })
-    expect(text).toContain('Arguments() = default;\n\nArguments(\n    std::initializer_list<std::pair<std::string_view, std::string_view>> values);\n\nexplicit Arguments(FlatArguments values);')
+    expect(text).toContain(
+      'Arguments() = default;\n\nArguments(\n    std::initializer_list<std::pair<std::string_view, std::string_view>> values);\n\nexplicit Arguments(FlatArguments values);',
+    )
     expect(text).not.toContain('values:')
     const signature = symbol.signatures[2]
     const spans = index.linkType(signature.raw!, symbol, signature)
     expect(spans.find((span) => span.text === 'Arguments')?.declaration).toBe(true)
     expect(spans.find((span) => span.text === 'explicit')?.keyword).toBe(true)
-    expect(spans.find((span) => span.text === 'values')?.link?.href).toBe(`/reference/${symbol.slug}/#${encodeURIComponent(parameterId(symbol, 'values'))}`)
+    expect(spans.find((span) => span.text === 'values')?.link?.href).toBe(
+      `/reference/${symbol.slug}/#${encodeURIComponent(parameterId(symbol, 'values'))}`,
+    )
     expect(spans.find((span) => span.text === 'FlatArguments')?.link?.symbol?.id).toBe('libtmux::mcp::FlatArguments')
   })
 
   it('exports PowerShell syntax, parameter bindings, defaults and prose after examples', () => {
-    const model = extractPowerShell(JSON.parse(readFileSync(new URL('../../packages/api-model/test/fixtures/powershell-native.json', import.meta.url), 'utf8')))
-    const index = new SymbolIndex(model.symbols, (symbol) => `/reference/${encodeURIComponent(symbol.id)}/`, 'powershell')
+    const model = extractPowerShell(
+      JSON.parse(
+        readFileSync(new URL('../../packages/api-model/test/fixtures/powershell-native.json', import.meta.url), 'utf8'),
+      ),
+    )
+    const index = new SymbolIndex(
+      model.symbols,
+      (symbol) => `/reference/${encodeURIComponent(symbol.id)}/`,
+      'powershell',
+    )
     const pane = model.symbols.find((entry) => entry.name === 'Get-TmuxPane')!
     const text = symbolMarkdown({ model, symbol: pane, index })
     for (const signature of pane.signatures) expect(text).toContain(nativeSignatureText(pane, signature, 'powershell'))
@@ -167,17 +190,28 @@ describe('API Markdown content parity', () => {
 
   it('prefers a library error over a same-named .NET exception in the selected version', () => {
     const error: ApiSymbol = {
-      id: 'LibTmux.ArgumentException', name: 'ArgumentException', kind: 'class',
-      modifiers: [], signatures: [], source: { file: 'example.fs' }, slug: 'argument-exception',
+      id: 'LibTmux.ArgumentException',
+      name: 'ArgumentException',
+      kind: 'class',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'example.fs' },
+      slug: 'argument-exception',
     }
     const symbol: ApiSymbol = {
-      id: 'LibTmux.sample', name: 'sample', kind: 'function', modifiers: [],
+      id: 'LibTmux.sample',
+      name: 'sample',
+      kind: 'function',
+      modifiers: [],
       signatures: [{ params: [], raises: [{ type: 'ArgumentException', doc: 'A library error.' }] }],
-      source: { file: 'example.fs' }, slug: 'sample',
+      source: { file: 'example.fs' },
+      slug: 'sample',
     }
     const model = { ...API_MODELS.fsharp, symbols: [error, symbol] }
     const text = symbolMarkdown({ model, symbol, version: 'stable' })
-    expect(text).toContain('[`ArgumentException`](' + referenceUrl(PORT_BY_SLUG.fsharp, 'stable') + 'argument-exception/)')
+    expect(text).toContain(
+      '[`ArgumentException`](' + referenceUrl(PORT_BY_SLUG.fsharp, 'stable') + 'argument-exception/)',
+    )
     expect(text).not.toContain('learn.microsoft.com')
   })
 
@@ -194,8 +228,9 @@ describe('API Markdown content parity', () => {
 
   it('preserves escaped parameter names and generic types as literal code', () => {
     const model = API_MODELS.kotlin
-    for (const symbol of model.symbols.filter((entry) => entry.signatures.some((signature) =>
-      signature.params.some((param) => param.name.includes('`'))))) {
+    for (const symbol of model.symbols.filter((entry) =>
+      entry.signatures.some((signature) => signature.params.some((param) => param.name.includes('`'))),
+    )) {
       const codes = inlineCodes(symbolMarkdown({ model, symbol }))
       for (const signature of symbol.signatures) {
         for (const param of signature.params) {
@@ -242,8 +277,13 @@ describe('API Markdown content parity', () => {
   it('preserves example bytes when blank lines and backticks are part of the program', () => {
     const code = 'const output = `first\n\n\nlast`;\nconsole.log(output);\nconsole.log("```");\n'
     const symbol: ApiSymbol = {
-      id: 'example', name: 'example', kind: 'function', modifiers: [], signatures: [],
-      source: { file: 'example.ts', line: 1 }, doc: { summary: 'Print the literal text.', examples: [{ lang: 'ts', code }] },
+      id: 'example',
+      name: 'example',
+      kind: 'function',
+      modifiers: [],
+      signatures: [],
+      source: { file: 'example.ts', line: 1 },
+      doc: { summary: 'Print the literal text.', examples: [{ lang: 'ts', code }] },
     }
     const text = symbolMarkdown({ model: { ...API_MODELS.ts, symbols: [symbol] }, symbol })
     expect(text).toContain(`\`\`\`\`ts\n${code}\`\`\`\``)
@@ -262,17 +302,37 @@ describe('API Markdown content parity', () => {
 
   it('uses the documented signature and keeps all declarations, warnings and provenance', () => {
     const symbol: ApiSymbol = {
-      id: 'Server.capture', name: 'capture', kind: 'method', modifiers: ['overload'],
-      source: { file: 'server.ts', line: 1 }, inheritedFrom: 'Base.capture',
+      id: 'Server.capture',
+      name: 'capture',
+      kind: 'method',
+      modifiers: ['overload'],
+      source: { file: 'server.ts', line: 1 },
+      inheritedFrom: 'Base.capture',
       signatures: [
         { params: [{ name: 'limit', type: 'number' }], returns: 'string[]' },
-        { params: [{ name: 'options', type: 'CaptureOptions', doc: 'Choose the line range.', since: '1.2', deprecated: 'Use a range.' }],
-          returns: 'string[]', returnsDoc: 'The captured lines.', raises: [{ type: 'CaptureError', doc: 'The pane no longer exists.' }] },
+        {
+          params: [
+            {
+              name: 'options',
+              type: 'CaptureOptions',
+              doc: 'Choose the line range.',
+              since: '1.2',
+              deprecated: 'Use a range.',
+            },
+          ],
+          returns: 'string[]',
+          returnsDoc: 'The captured lines.',
+          raises: [{ type: 'CaptureError', doc: 'The pane no longer exists.' }],
+        },
       ],
-      doc: { summary: 'Read pane output.', deprecated: 'Use Pane.capture.', changed: 'Returns complete lines.',
+      doc: {
+        summary: 'Read pane output.',
+        deprecated: 'Use Pane.capture.',
+        changed: 'Returns complete lines.',
         admonitions: [{ kind: 'warning', text: 'The pane may exit between commands.' }],
         references: [{ name: 'manual', text: 'The tmux capture-pane manual.' }],
-        examples: [{ lang: 'ts', code: 'await pane.capture()', intro: 'Read visible lines.' }] },
+        examples: [{ lang: 'ts', code: 'await pane.capture()', intro: 'Read visible lines.' }],
+      },
     }
     const text = symbolMarkdown({ model: { ...API_MODELS.ts, symbols: [symbol] }, symbol })
     expect(text).toContain('Server.capture(limit: number): string[]')
@@ -283,7 +343,9 @@ describe('API Markdown content parity', () => {
     expect(text).toContain('**warning:** The pane may exit between commands.')
     expect(text).toContain('- [manual] The tmux capture-pane manual.')
     expect(text).toContain('## Parameters\n\n- `limit` (`number`)')
-    expect(text).toContain('- `options` (`CaptureOptions`): Choose the line range. (added 1.2) (deprecated Use a range.)')
+    expect(text).toContain(
+      '- `options` (`CaptureOptions`): Choose the line range. (added 1.2) (deprecated Use a range.)',
+    )
     expect(text).toContain('## Returns\n\nThe captured lines.')
     expect(text).toContain('## Raises\n\n- `CaptureError`: The pane no longer exists.')
     expect(text.indexOf('## Examples')).toBeLessThan(text.indexOf('## Parameters'))
@@ -303,8 +365,10 @@ describe('API Markdown content parity', () => {
       const owner = byId.get(id) ?? model.symbols.find((symbol) => symbol.publicId === id)!
       const text = symbolMarkdown({ model, symbol: owner })
       const members = ordered.map((entry) => byId.get(entry.id)!)
-      const expected = [...members.filter((member) => !member.inheritedFrom), ...members.filter((member) => member.inheritedFrom)]
-        .map((member) => member.name)
+      const expected = [
+        ...members.filter((member) => !member.inheritedFrom),
+        ...members.filter((member) => member.inheritedFrom),
+      ].map((member) => member.name)
       const memberText = text.slice(text.search(/^## (?:Members|Inherited members)$/m))
       const names = [...memberText.matchAll(/^- `([^`]+)` \([a-z]+\)/gm)].map((match) => match[1])
       expect(names).toEqual(expected)
diff --git a/site/test/table-of-contents.test.ts b/site/test/table-of-contents.test.ts
index f19d921b9..c31f92d13 100644
--- a/site/test/table-of-contents.test.ts
+++ b/site/test/table-of-contents.test.ts
@@ -10,15 +10,30 @@ afterEach(async () => {
 
 async function contents() {
   win = new Window({ url: 'https://libtmux.org/en/tmux/latest/manual/capture-pane/#option-h' })
-  for (const key of ['window', 'document', 'HTMLElement', 'HTMLHeadingElement', 'customElements', 'IntersectionObserver'] as const) {
+  for (const key of [
+    'window',
+    'document',
+    'HTMLElement',
+    'HTMLHeadingElement',
+    'customElements',
+    'IntersectionObserver',
+  ] as const) {
     vi.stubGlobal(key, key === 'window' ? win : win[key])
   }
   vi.stubGlobal('getComputedStyle', win.getComputedStyle.bind(win))
   win.document.documentElement.style.scrollPaddingTop = '72px'
   Object.defineProperty(win, 'scrollY', { configurable: true, value: 500 })
   Object.defineProperty(win.document.documentElement, 'scrollHeight', { configurable: true, value: 10000 })
-  Object.defineProperty(win, 'requestIdleCallback', { value: (callback: IdleRequestCallback) => { callback({ didTimeout: false, timeRemaining: () => 50 }); return 1 } })
-  vi.spyOn(win, 'setTimeout').mockImplementation((callback) => { (callback as () => void)(); return 1 as unknown as ReturnType<typeof win.setTimeout> })
+  Object.defineProperty(win, 'requestIdleCallback', {
+    value: (callback: IdleRequestCallback) => {
+      callback({ didTimeout: false, timeRemaining: () => 50 })
+      return 1
+    },
+  })
+  vi.spyOn(win, 'setTimeout').mockImplementation((callback) => {
+    ;(callback as () => void)()
+    return 1 as unknown as ReturnType<typeof win.setTimeout>
+  })
   win.HTMLElement.prototype.scrollIntoView = () => {}
   win.document.body.innerHTML = `<header></header><main><article>
     <h2 id="common" data-top="-2000">Common uses</h2>
@@ -33,8 +48,15 @@ async function contents() {
     <a href="#hidden">Hidden</a><a href="#output">Output</a></starlight-toc>`
   for (const element of win.document.querySelectorAll<HTMLElement>('h2, h3')) {
     element.style.scrollMarginTop = '72px'
-    vi.spyOn(element, 'getBoundingClientRect').mockImplementation(() => new win.DOMRect(0, Number(element.getAttribute('data-top')), 100, 24))
-    vi.spyOn(element, 'getClientRects').mockImplementation(() => (element.hasAttribute('hidden') ? [] : [element.getBoundingClientRect()]) as ReturnType<typeof element.getClientRects>)
+    vi.spyOn(element, 'getBoundingClientRect').mockImplementation(
+      () => new win.DOMRect(0, Number(element.getAttribute('data-top')), 100, 24),
+    )
+    vi.spyOn(element, 'getClientRects').mockImplementation(
+      () =>
+        (element.hasAttribute('hidden') ? [] : [element.getBoundingClientRect()]) as ReturnType<
+          typeof element.getClientRects
+        >,
+    )
   }
   vi.resetModules()
   await import('../src/components/TableOfContents/starlight-toc')
diff --git a/site/test/tmux-manual.test.ts b/site/test/tmux-manual.test.ts
index 114c13f64..489620b38 100644
--- a/site/test/tmux-manual.test.ts
+++ b/site/test/tmux-manual.test.ts
@@ -1,17 +1,32 @@
 import { afterEach, beforeAll, describe, expect, it, vi } from 'vitest'
 import { parseManual } from '../../scripts/gen-tmux-manual.mjs'
-import { buildsTmuxDocumentation, tmuxCommandNotes, tmuxCommandsFor, tmuxGuidesFor, tmuxManualHtml, tmuxManualHeadings, tmuxManual, tmuxManualUrl, tmuxManualVersionUrl } from '../src/lib/tmux-manual-data'
+import {
+  buildsTmuxDocumentation,
+  tmuxCommandNotes,
+  tmuxCommandsFor,
+  tmuxGuidesFor,
+  tmuxManualHtml,
+  tmuxManualHeadings,
+  tmuxManual,
+  tmuxManualUrl,
+  tmuxManualVersionUrl,
+} from '../src/lib/tmux-manual-data'
 import { highlightTmuxManual, linkTmuxManualEntries } from '../src/lib/tmux-manual'
 import { fromHtml } from 'hast-util-from-html'
 import { select, selectAll, type Nodes } from 'astro-expressive-code/hast'
 
-const contents = (node: Nodes): string => node.type === 'text' ? node.value
-  : 'children' in node ? node.children.map(contents).join('') : ''
+const contents = (node: Nodes): string =>
+  node.type === 'text' ? node.value : 'children' in node ? node.children.map(contents).join('') : ''
 
-afterEach(() => { vi.unstubAllEnvs(); vi.resetModules() })
+afterEach(() => {
+  vi.unstubAllEnvs()
+  vi.resetModules()
+})
 
 describe('versioned tmux manual', () => {
-  beforeAll(async () => { await highlightTmuxManual('<pre>set -g status off</pre>') })
+  beforeAll(async () => {
+    await highlightTmuxManual('<pre>set -g status off</pre>')
+  })
   it.each(['3.2a', '3.7c'])('links every %s definition without colliding keys or losing old targets', (version) => {
     const original = fromHtml(tmuxManual(version).manual, { fragment: true })
     const linked = fromHtml(linkTmuxManualEntries(tmuxManual(version).manual), { fragment: true })
@@ -29,23 +44,48 @@ describe('versioned tmux manual', () => {
     expect(contents(select('#default-key-binding-right-bracket', linked)!)).toBe(']')
   })
 
-  it.each(['3.2a', '3.7c'])('highlights the %s manual without changing example text or destinations', async (version) => {
-    const html = tmuxManualHtml(tmuxManual(version).manual, version)
-    const original = fromHtml(html, { fragment: true })
-    const rendered = fromHtml(await highlightTmuxManual(html), { fragment: true })
-    expect(selectAll('pre:not([data-language="tmux-usage"])', rendered).map(contents))
-      .toEqual(selectAll('pre', original).map(contents))
-    expect(selectAll('pre span[style*="--shiki-light:"]', rendered).length).toBeGreaterThan(100)
-    expect(contents(select('[data-language="tmux-usage"]', rendered)!))
-      .toBe(contents(select('table.Nm', original)!).replace(/\s+/g, ' ').trim())
-    expect(selectAll('a', rendered).map((node) => node.properties.href))
-      .toEqual(selectAll('a', original).map((node) => node.properties.href))
-  })
+  it.each(['3.2a', '3.7c'])(
+    'highlights the %s manual without changing example text or destinations',
+    async (version) => {
+      const html = tmuxManualHtml(tmuxManual(version).manual, version)
+      const original = fromHtml(html, { fragment: true })
+      const rendered = fromHtml(await highlightTmuxManual(html), { fragment: true })
+      expect(selectAll('pre:not([data-language="tmux-usage"])', rendered).map(contents)).toEqual(
+        selectAll('pre', original).map(contents),
+      )
+      expect(selectAll('pre span[style*="--shiki-light:"]', rendered).length).toBeGreaterThan(100)
+      expect(contents(select('[data-language="tmux-usage"]', rendered)!)).toBe(
+        contents(select('table.Nm', original)!).replace(/\s+/g, ' ').trim(),
+      )
+      expect(selectAll('a', rendered).map((node) => node.properties.href)).toEqual(
+        selectAll('a', original).map((node) => node.properties.href),
+      )
+    },
+  )
   it('organizes every capture flag for lookup without showing flags from newer tmux releases', () => {
     const current = tmuxCommandNotes('latest', 'capture-pane')!
     const old = tmuxCommandNotes('3.2a', 'capture-pane')!
-    const flags = (notes: typeof current) => notes.groups.flatMap((group) => group.options.map((option) => option.flag)).sort()
-    expect(flags(current)).toEqual(['C', 'E', 'F', 'H', 'J', 'L', 'M', 'N', 'P', 'S', 'T', 'a', 'b', 'e', 'p', 'q', 't'])
+    const flags = (notes: typeof current) =>
+      notes.groups.flatMap((group) => group.options.map((option) => option.flag)).sort()
+    expect(flags(current)).toEqual([
+      'C',
+      'E',
+      'F',
+      'H',
+      'J',
+      'L',
+      'M',
+      'N',
+      'P',
+      'S',
+      'T',
+      'a',
+      'b',
+      'e',
+      'p',
+      'q',
+      't',
+    ])
     expect(flags(old)).toEqual(['C', 'E', 'J', 'N', 'P', 'S', 'a', 'b', 'e', 'p', 'q', 't'])
     expect(current.groups[1].options.find((option) => option.flag === 'J')!.text).toContain('Implies -T.')
     expect(old.groups[1].options.find((option) => option.flag === 'J')!.text).not.toContain('-T')
@@ -65,7 +105,8 @@ describe('versioned tmux manual', () => {
     expect(current).toBe(tmuxManual('3.7c'))
     expect(old.commands.some((command) => command.name === 'new-pane')).toBe(false)
     expect(current.commands.some((command) => command.name === 'new-pane')).toBe(true)
-    const capture = (version: string) => tmuxManual(version).commands.find((command) => command.name === 'capture-pane')!
+    const capture = (version: string) =>
+      tmuxManual(version).commands.find((command) => command.name === 'capture-pane')!
     expect(capture('3.2a').usage.split(']')[0]).not.toContain('F')
     expect(capture('3.7c').usage.split(']')[0]).toContain('F')
     expect(() => tmuxManual('3.99')).toThrow('Unknown tmux manual version')
@@ -89,7 +130,8 @@ describe('versioned tmux manual', () => {
 
   it('links commands and retains upstream descriptions and license', () => {
     const commands = [{ name: 'capture-pane', alias: 'capturep', usage: '[-p]' }]
-    const html = '<section class="Sh"><h1 id="PANES">Panes</h1><dl><dt><code class="Ic">capture-pane</code></dt><dd><div class="Bd">(alias: capturep)</div>Capture visible lines. See <a href="#FORMATS">formats</a> and <code class="Ic">capturep</code>.</dd></dl></section>'
+    const html =
+      '<section class="Sh"><h1 id="PANES">Panes</h1><dl><dt><code class="Ic">capture-pane</code></dt><dd><div class="Bd">(alias: capturep)</div>Capture visible lines. See <a href="#FORMATS">formats</a> and <code class="Ic">capturep</code>.</dd></dl></section>'
     const result = parseManual(html, commands, '3.7c')
     expect(result.commands[0].summary).toBe('Capture visible lines.')
     expect(result.commands[0].html).not.toContain('(alias:')
@@ -98,7 +140,9 @@ describe('versioned tmux manual', () => {
     const older = html.replace('(alias: capturep)</div>', '(alias: capturep</div>\n    ) ')
     expect(parseManual(older, commands, '3.2a').commands[0].summary).toBe('Capture visible lines.')
     expect(tmuxManual('latest').license).toContain('Permission to use, copy, modify, and distribute')
-    expect(() => parseManual(html.replace('capture-pane</code>', 'unknown</code>'), commands, '3.7c')).toThrow('Command absent from the manual')
+    expect(() => parseManual(html.replace('capture-pane</code>', 'unknown</code>'), commands, '3.7c')).toThrow(
+      'Command absent from the manual',
+    )
   })
 
   it('excludes the formatter build date and host from the pinned manual', () => {
@@ -126,14 +170,23 @@ describe('versioned tmux manual', () => {
   })
 
   it('exports the same command sections and related guides as the page', () => {
-    expect(tmuxManualHeadings('latest', 'capture-pane').map((heading) => heading.slug))
-      .toEqual(['capture-pane-common-uses', 'capture-pane-syntax', 'capture-pane-options',
-        'capture-pane-options-output-and-line-range', 'capture-pane-options-text-formatting',
-        'capture-pane-options-screens-and-pending-output', 'capture-pane-guides', 'capture-pane-use-from-a-library'])
-    expect(tmuxManualHeadings('latest', 'server-access').map((heading) => heading.slug))
-      .toEqual(['server-access-syntax', 'server-access-behavior'])
-    expect(tmuxGuidesFor('capture-pane').map((guide) => guide.href))
-      .toEqual([tmuxManualUrl().replace('/tmux/latest/manual/', '/tmux/guides/capturing-output/')])
+    expect(tmuxManualHeadings('latest', 'capture-pane').map((heading) => heading.slug)).toEqual([
+      'capture-pane-common-uses',
+      'capture-pane-syntax',
+      'capture-pane-options',
+      'capture-pane-options-output-and-line-range',
+      'capture-pane-options-text-formatting',
+      'capture-pane-options-screens-and-pending-output',
+      'capture-pane-guides',
+      'capture-pane-use-from-a-library',
+    ])
+    expect(tmuxManualHeadings('latest', 'server-access').map((heading) => heading.slug)).toEqual([
+      'server-access-syntax',
+      'server-access-behavior',
+    ])
+    expect(tmuxGuidesFor('capture-pane').map((guide) => guide.href)).toEqual([
+      tmuxManualUrl().replace('/tmux/latest/manual/', '/tmux/guides/capturing-output/'),
+    ])
     expect(tmuxManualHeadings('3.2a', 'full').some((heading) => heading.slug === 'COMMANDS')).toBe(true)
   })
 })
diff --git a/site/test/tmux-reference.test.ts b/site/test/tmux-reference.test.ts
index 43685a77c..a99ed4fea 100644
--- a/site/test/tmux-reference.test.ts
+++ b/site/test/tmux-reference.test.ts
@@ -1,6 +1,16 @@
 import { describe, expect, it } from 'vitest'
 import { readInventory, sourceUrl, writeInventory } from '@libtmux/api-model'
-import { tmuxCommandSources, tmuxReferenceContext, tmuxReferenceIndex, tmuxReferencePaths, tmuxReferenceTree, tmuxReferenceUrl, tmuxReferenceVersionUrl, tmuxSourceCommands, tmuxSourceModel } from '../src/lib/tmux-reference'
+import {
+  tmuxCommandSources,
+  tmuxReferenceContext,
+  tmuxReferenceIndex,
+  tmuxReferencePaths,
+  tmuxReferenceTree,
+  tmuxReferenceUrl,
+  tmuxReferenceVersionUrl,
+  tmuxSourceCommands,
+  tmuxSourceModel,
+} from '../src/lib/tmux-reference'
 import { tmuxManual, tmuxManualUrl } from '../src/lib/tmux-manual-data'
 import { referenceIndexSectionsFor } from '../src/lib/api-tree'
 import { searchApi } from '../src/lib/api-search'
@@ -16,25 +26,48 @@ describe.each(['3.7c', '3.2a'])('tmux %s through the shared API system', (versio
     expect(new Set(model.symbols.map((symbol) => symbol.id)).size).toBe(model.symbols.length)
     expect(new Set(model.symbols.map((symbol) => symbol.slug)).size).toBe(model.symbols.length)
     expect(model.symbols.filter((symbol) => !symbol.slug || (symbol.parent && !byId.has(symbol.parent)))).toEqual([])
-    expect(model.symbols.flatMap((symbol) => symbol.references ?? []).filter((reference) => !byId.has(reference.target))).toEqual([])
+    expect(
+      model.symbols.flatMap((symbol) => symbol.references ?? []).filter((reference) => !byId.has(reference.target)),
+    ).toEqual([])
     expect(model).not.toHaveProperty('port')
-    expect(PORTS.some((port) => port.slug as string === 'tmux' || port.slug as string === 'c')).toBe(false)
+    expect(PORTS.some((port) => (port.slug as string) === 'tmux' || (port.slug as string) === 'c')).toBe(false)
   })
 
   it('uses the shared bucket index and searchable tree without losing declarations', () => {
     const context = tmuxReferenceContext(version)
     const sections = referenceIndexSectionsFor(model, context.tree)
     const indexed = sections.flatMap((section) => [...section.types, ...section.free]).map((symbol) => symbol.id)
-    expect(indexed.toSorted()).toEqual(model.symbols.filter((symbol) => !symbol.parent).map((symbol) => symbol.id).toSorted())
+    expect(indexed.toSorted()).toEqual(
+      model.symbols
+        .filter((symbol) => !symbol.parent)
+        .map((symbol) => symbol.id)
+        .toSorted(),
+    )
     const tree = tmuxReferenceTree(version)
-    expect(searchApi(tree, '').map((entry) => entry.id).toSorted()).toEqual(model.symbols.map((symbol) => symbol.id).toSorted())
+    expect(
+      searchApi(tree, '')
+        .map((entry) => entry.id)
+        .toSorted(),
+    ).toEqual(model.symbols.map((symbol) => symbol.id).toSorted())
     expect(searchApi(tree, 'window_pane')[0].id).toBe('c:struct:window_pane')
     expect(context.nav.placement['c:struct:window_pane']).toBe('pane')
     expect(context.tree.find((bucket) => bucket.id === 'pane')?.entries[0].id).toBe('c:struct:window_pane')
-    expect(context.tree.slice(0, 5).map((bucket) => bucket.id)).toEqual(['server', 'session', 'window', 'pane', 'client'])
-    expect(context.tree.find((bucket) => bucket.id === 'session')?.entries.slice(0, 4).map((entry) => entry.name))
-      .toEqual(['session', 'session_create', 'session_find', 'session_find_by_id'])
-    expect(context.tree.find((bucket) => bucket.id === 'session')?.children[0].entries.map((entry) => entry.name)).toContain('session_cmp')
+    expect(context.tree.slice(0, 5).map((bucket) => bucket.id)).toEqual([
+      'server',
+      'session',
+      'window',
+      'pane',
+      'client',
+    ])
+    expect(
+      context.tree
+        .find((bucket) => bucket.id === 'session')
+        ?.entries.slice(0, 4)
+        .map((entry) => entry.name),
+    ).toEqual(['session', 'session_create', 'session_find', 'session_find_by_id'])
+    expect(
+      context.tree.find((bucket) => bucket.id === 'session')?.children[0].entries.map((entry) => entry.name),
+    ).toContain('session_cmp')
     expect(sections.find((section) => section.id === 'session-support')?.collapsed).toBe(true)
     expect(context.nav.diagnostics).toMatchObject({ unmatched: [], ambiguous: [], deadBuckets: [] })
     expect(tree.relationships?.['c:function:server_start']?.some((edge) => edge.kind === 'call')).toBe(true)
@@ -48,8 +81,13 @@ describe.each(['3.7c', '3.2a'])('tmux %s through the shared API system', (versio
     // This guarded expression is outside the conservative call projection.
     // The native relationship stays a reference instead of being guessed.
     expect(paths[1].edges).toEqual(['reference', 'call', 'call'])
-    const text = symbolMarkdown({ model, symbol: byId.get('c:function:spawn_pane')!, index: tmuxReferenceIndex(version),
-      hrefFor: (symbol) => tmuxReferenceUrl(version, symbol), paths })
+    const text = symbolMarkdown({
+      model,
+      symbol: byId.get('c:function:spawn_pane')!,
+      index: tmuxReferenceIndex(version),
+      hrefFor: (symbol) => tmuxReferenceUrl(version, symbol),
+      paths,
+    })
     expect(text).toContain('## Called by')
     expect(text).toContain('## Calls')
     expect(text).toContain('## Paths through the source')
@@ -57,27 +95,47 @@ describe.each(['3.7c', '3.2a'])('tmux %s through the shared API system', (versio
   })
 
   it('links command registrations and callbacks to the matching manual version', () => {
-    expect(model.commands.map((command) => command.name).toSorted()).toEqual(tmuxManual(version).commands.map((command) => command.name).toSorted())
+    expect(model.commands.map((command) => command.name).toSorted()).toEqual(
+      tmuxManual(version)
+        .commands.map((command) => command.name)
+        .toSorted(),
+    )
     const capture = model.commands.find((command) => command.name === 'capture-pane')!
     const clear = model.commands.find((command) => command.name === 'clear-history')!
     expect(capture.callback).toBe(clear.callback)
-    expect(tmuxReferenceContext(version, byId.get(capture.callback)).pagePorts.some((port) => port.links.length > 0)).toBe(true)
+    expect(
+      tmuxReferenceContext(version, byId.get(capture.callback)).pagePorts.some((port) => port.links.length > 0),
+    ).toBe(true)
     expect(tmuxCommandSources(version, 'capture-pane').map((entry) => entry.href)).toEqual([
-      tmuxReferenceUrl(version, byId.get(capture.entry)), tmuxReferenceUrl(version, byId.get(capture.callback)),
+      tmuxReferenceUrl(version, byId.get(capture.entry)),
+      tmuxReferenceUrl(version, byId.get(capture.callback)),
     ])
-    expect(tmuxSourceCommands(version, byId.get(capture.callback)!)).toContainEqual({ name: 'capture-pane', href: tmuxManualUrl(version, 'capture-pane') })
+    expect(tmuxSourceCommands(version, byId.get(capture.callback)!)).toContainEqual({
+      name: 'capture-pane',
+      href: tmuxManualUrl(version, 'capture-pane'),
+    })
   })
 
   it('copies native C syntax and links types in the selected version', () => {
     const symbol = byId.get('c:function:server_start')!
     const index = tmuxReferenceIndex(version)
-    expect(index.linkType('struct tmuxproc *', symbol).find((span) => span.link)?.link?.symbol?.id).toBe('c:struct:tmuxproc')
-    const text = symbolMarkdown({ model, symbol, index, version,
-      source: sourceUrl(model, symbol), hrefFor: (entry) => tmuxReferenceUrl(version, entry) })
+    expect(index.linkType('struct tmuxproc *', symbol).find((span) => span.link)?.link?.symbol?.id).toBe(
+      'c:struct:tmuxproc',
+    )
+    const text = symbolMarkdown({
+      model,
+      symbol,
+      index,
+      version,
+      source: sourceUrl(model, symbol),
+      hrefFor: (entry) => tmuxReferenceUrl(version, entry),
+    })
     expect(text).toContain('```c\nint server_start(')
     expect(text).not.toContain('client: struct tmuxproc')
     expect(text).toContain(`/blob/${model.revision}/server.c#L`)
-    expect(relatedApiTypes(symbol, [], index, undefined, { includeInternal: true }).map((entry) => entry.id)).toContain('c:struct:tmuxproc')
+    expect(relatedApiTypes(symbol, [], index, undefined, { includeInternal: true }).map((entry) => entry.id)).toContain(
+      'c:struct:tmuxproc',
+    )
   })
 
   it('uses the same compressed inventory writer with the C domain and symbol pages', () => {
@@ -85,13 +143,16 @@ describe.each(['3.7c', '3.2a'])('tmux %s through the shared API system', (versio
     const inventory = readInventory(buffer)
     expect(inventory.entries).toHaveLength(model.symbols.length)
     expect(inventory.entries.find((entry) => entry.name === 'window_pane')).toMatchObject({
-      type: 'c:struct', uri: 'c-struct-window_pane/',
+      type: 'c:struct',
+      uri: 'c-struct-window_pane/',
     })
     expect(inventory.entries.find((entry) => entry.name === 'server_start')?.type).toBe('c:function')
     const nestedUnion = model.symbols.find((symbol) => symbol.kind === 'union' && symbol.parent)!
     expect(inventory.entries.find((entry) => entry.uri === `${nestedUnion.slug}/`)?.type).toBe('c:union')
     expect(inventory.entries.find((entry) => entry.name === 'session.name')?.type).toBe('c:member')
-    const enumerator = model.symbols.find((symbol) => symbol.kind === 'constant' && byId.get(symbol.parent ?? '')?.kind === 'enum')!
+    const enumerator = model.symbols.find(
+      (symbol) => symbol.kind === 'constant' && byId.get(symbol.parent ?? '')?.kind === 'enum',
+    )!
     expect(inventory.entries.find((entry) => entry.uri === `${enumerator.slug}/`)?.type).toBe('c:enumerator')
     expect(new Set(inventory.entries.map((entry) => `${entry.type}:${entry.name}`)).size).toBe(inventory.entries.length)
   })
@@ -101,7 +162,12 @@ it('separates version indexes and preserves only existing symbol counterparts',
   const current = tmuxSourceModel('latest')
   const old = tmuxSourceModel('3.2a')
   const session = current.symbols.find((symbol) => symbol.id === 'c:struct:session')!
-  expect(tmuxReferenceVersionUrl('3.2a', 'latest', session.slug)).toBe(tmuxReferenceUrl('3.2a', old.symbols.find((symbol) => symbol.id === session.id)))
+  expect(tmuxReferenceVersionUrl('3.2a', 'latest', session.slug)).toBe(
+    tmuxReferenceUrl(
+      '3.2a',
+      old.symbols.find((symbol) => symbol.id === session.id),
+    ),
+  )
   const absent = current.symbols.find((symbol) => !old.symbols.some((entry) => entry.id === symbol.id))!
   expect(tmuxReferenceVersionUrl('3.2a', 'latest', absent.slug)).toBe(tmuxReferenceUrl('3.2a'))
   expect(tmuxReferenceIndex('latest')).not.toBe(tmuxReferenceIndex('3.7c'))
diff --git a/site/test/tmux-usage.test.ts b/site/test/tmux-usage.test.ts
index 1e5ac713c..7b9a7ac08 100644
--- a/site/test/tmux-usage.test.ts
+++ b/site/test/tmux-usage.test.ts
@@ -26,22 +26,26 @@ function contrast(foreground: string, background: string) {
   return (values[0] + 0.05) / (values[1] + 0.05)
 }
 
-const scopeOf = (token?: ThemedToken) => token?.explanation?.flatMap((part) =>
-  part.scopes.map((scope) => scope.scopeName)) ?? []
+const scopeOf = (token?: ThemedToken) =>
+  token?.explanation?.flatMap((part) => part.scopes.map((scope) => scope.scopeName)) ?? []
 
 describe('tmux usage highlighting', () => {
   let highlighter: HighlighterCore
   beforeAll(async () => {
     highlighter = await createHighlighterCore({
-      themes: shellThemes(), langs: [tmuxUsage, tmuxShell, tmuxConfig, ...bash],
+      themes: shellThemes(),
+      langs: [tmuxUsage, tmuxShell, tmuxConfig, ...bash],
       engine: createOnigurumaEngine(import('shiki/wasm')),
     })
   })
   afterAll(() => highlighter.dispose())
 
-  const tokens = (code: string, theme = 'github-light') => highlighter.codeToTokens(code, {
-    lang: 'tmux-usage', theme, includeExplanation: true,
-  })
+  const tokens = (code: string, theme = 'github-light') =>
+    highlighter.codeToTokens(code, {
+      lang: 'tmux-usage',
+      theme,
+      includeExplanation: true,
+    })
 
   it.each([catalog32, catalog37])('distinguishes capture syntax from Bash in tmux $version', (catalog) => {
     const command = catalog.commands.find((entry) => entry.name === 'capture-pane')!
@@ -68,14 +72,20 @@ describe('tmux usage highlighting', () => {
     for (const word of ['session-name', 'shell-command', 'argument']) {
       expect(scopeOf(result.find((token) => token.content === word)!)).toContain('variable.parameter.tmux-usage')
     }
-    expect(scopeOf(result.find((token) => token.content.includes('...'))!)).toContain('punctuation.definition.tmux-usage')
+    expect(scopeOf(result.find((token) => token.content.includes('...'))!)).toContain(
+      'punctuation.definition.tmux-usage',
+    )
   })
 
   it('preserves every recorded command synopsis byte for byte', () => {
     for (const catalog of [catalog32, catalog37]) {
       for (const command of catalog.commands) {
         const text = `tmux ${command.name} ${command.usage}`
-        expect(tokens(text).tokens.map((line) => line.map((token) => token.content).join('')).join('\n')).toBe(text)
+        expect(
+          tokens(text)
+            .tokens.map((line) => line.map((token) => token.content).join(''))
+            .join('\n'),
+        ).toBe(text)
       }
     }
   })
@@ -108,15 +118,14 @@ describe('tmux usage highlighting', () => {
     expect(html).toContain('--1:#8A5400')
   })
 
-  const captureCommands = [
-    'tmux capture-pane -p -t "$TMUX_PANE"',
-    'tmux capture-pane -p -J -S -1000 -t "$TMUX_PANE"',
-  ]
+  const captureCommands = ['tmux capture-pane -p -t "$TMUX_PANE"', 'tmux capture-pane -p -J -S -1000 -t "$TMUX_PANE"']
 
   it.each(captureCommands)('highlights the runnable command %s in both themes', async (code) => {
     for (const theme of ['github-light', 'github-dark']) {
       const result = highlighter.codeToTokens(code, {
-        lang: 'tmux-shell', theme, includeExplanation: true,
+        lang: 'tmux-shell',
+        theme,
+        includeExplanation: true,
       })
       const tokens = result.tokens.flat()
       expect(tokens.map((token) => token.content).join('')).toBe(code)
@@ -146,13 +155,19 @@ describe('tmux usage highlighting', () => {
 
   it('lets Bash distinguish literal, escaped and expanded dollar signs', () => {
     const code = `tmux display-message '$TMUX_PANE' "\\$TMUX_PANE" "$TMUX_PANE"`
-    const result = highlighter.codeToTokens(code, {
-      lang: 'tmux-shell', theme: 'github-light', includeExplanation: true,
-    }).tokens.flat()
+    const result = highlighter
+      .codeToTokens(code, {
+        lang: 'tmux-shell',
+        theme: 'github-light',
+        includeExplanation: true,
+      })
+      .tokens.flat()
     expect(result.map((token) => token.content).join('')).toBe(code)
     const expanded = result.filter((token) => scopeOf(token).includes('variable.other.normal.shell'))
     expect(expanded.map((token) => token.content)).toEqual(['$TMUX_PANE'])
-    expect(scopeOf(result.find((token) => token.content.includes("'$TMUX_PANE'")))).toContain('string.quoted.single.shell')
+    expect(scopeOf(result.find((token) => token.content.includes("'$TMUX_PANE'")))).toContain(
+      'string.quoted.single.shell',
+    )
     expect(result.some((token) => scopeOf(token).includes('constant.character.escape.shell'))).toBe(true)
   })
 
@@ -160,12 +175,19 @@ describe('tmux usage highlighting', () => {
     const code = '%if "#{==:#{host},myhost}"\nset -g status-style bg=red\n%else\nset -g status-style bg=blue\n%endif'
     const result = highlighter.codeToTokens(code, { lang: 'tmux-config', theme, includeExplanation: true })
     expect(result.tokens.map((line) => line.map((part) => part.content).join('')).join('\n')).toBe(code)
-    for (const [value, scope] of [['%if', 'keyword.control'], ['host', 'variable.other'], ['set', 'entity.name.function'], ['-g', 'constant.other.option']]) {
+    for (const [value, scope] of [
+      ['%if', 'keyword.control'],
+      ['host', 'variable.other'],
+      ['set', 'entity.name.function'],
+      ['-g', 'constant.other.option'],
+    ]) {
       const token = result.tokens.flat().find((part) => part.content === value)!
       expect(scopeOf(token)).toContain(`${scope}.tmux-config`)
       expect(contrast(token.color!, result.bg!)).toBeGreaterThanOrEqual(4.5)
     }
-    expect(scopeOf(result.tokens[1].find((part) => part.content === 'set'))).not.toContain('string.quoted.double.tmux-config')
+    expect(scopeOf(result.tokens[1].find((part) => part.content === 'set'))).not.toContain(
+      'string.quoted.double.tmux-config',
+    )
     const renderer = await createRenderer(config)
     const rendered = await renderer.ec.render({ code, language: 'tmux-config' })
     expect(select('[data-code]', rendered.renderedGroupAst)?.properties.dataCode).toBe(code.replaceAll('\n', '\x7f'))
@@ -173,14 +195,21 @@ describe('tmux usage highlighting', () => {
   })
 
   it('recognizes runtime formats inside both quotes while leaving single-quoted environment variables literal', () => {
-    const result = highlighter.codeToTokens("# a comment\nset -g status-left '#{host} #[fg=red]#S $HOME'\nset -g status-right \"#{?pane_in_mode,#[fg=red],#[fg=green]}#W\"", {
-      lang: 'tmux-config', theme: 'github-dark', includeExplanation: true,
-    }).tokens
+    const result = highlighter.codeToTokens(
+      '# a comment\nset -g status-left \'#{host} #[fg=red]#S $HOME\'\nset -g status-right "#{?pane_in_mode,#[fg=red],#[fg=green]}#W"',
+      {
+        lang: 'tmux-config',
+        theme: 'github-dark',
+        includeExplanation: true,
+      },
+    ).tokens
     expect(scopeOf(result[0][0])).toContain('comment.line.number-sign.tmux-config')
     expect(result[1].some((token) => scopeOf(token).includes('meta.interpolation.tmux-config'))).toBe(true)
     expect(result[1].some((token) => scopeOf(token).includes('meta.style.tmux-config'))).toBe(true)
     expect(scopeOf(result[1].find((token) => token.content === '#S'))).toContain('variable.other.tmux-config')
-    expect(scopeOf(result[1].find((token) => token.content.includes('$HOME')))).not.toContain('variable.other.tmux-config')
+    expect(scopeOf(result[1].find((token) => token.content.includes('$HOME')))).not.toContain(
+      'variable.other.tmux-config',
+    )
     expect(result[2].some((token) => scopeOf(token).includes('meta.interpolation.tmux-config'))).toBe(true)
     expect(result[2].some((token) => scopeOf(token).includes('meta.style.tmux-config'))).toBe(true)
   })
diff --git a/site/test/versions.test.ts b/site/test/versions.test.ts
index 97c71be90..d8e3cf197 100644
--- a/site/test/versions.test.ts
+++ b/site/test/versions.test.ts
@@ -18,9 +18,11 @@ import {
 } from '../src/lib/versions'
 
 it('keeps the production fallback manifest in sync with the seed generator', () => {
-  const generated = execFileSync(process.execPath, [
-    new URL('../../scripts/gen-versions.mjs', import.meta.url).pathname, '--seed',
-  ], { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] })
+  const generated = execFileSync(
+    process.execPath,
+    [new URL('../../scripts/gen-versions.mjs', import.meta.url).pathname, '--seed'],
+    { encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] },
+  )
   const fallback = readFileSync(new URL('../public/versions.json', import.meta.url), 'utf8')
   expect(JSON.parse(fallback)).toEqual(JSON.parse(generated))
 })
@@ -36,12 +38,14 @@ it('derives refs from an explicit source checkout instead of a local docs worktr
     execFileSync('git', ['-C', directory, 'commit', '-qm', 'fixture'])
     execFileSync('git', ['-C', directory, 'tag', 'v9.8.7.rc.1'])
 
-    const generated = execFileSync(process.execPath, [
-      new URL('../../scripts/gen-versions.mjs', import.meta.url).pathname,
-    ], {
-      encoding: 'utf8',
-      env: { ...process.env, LIBTMUX_DOCS_CHECKOUT_RUBY: directory },
-    })
+    const generated = execFileSync(
+      process.execPath,
+      [new URL('../../scripts/gen-versions.mjs', import.meta.url).pathname],
+      {
+        encoding: 'utf8',
+        env: { ...process.env, LIBTMUX_DOCS_CHECKOUT_RUBY: directory },
+      },
+    )
     const manifest = JSON.parse(generated) as VersionManifest
     expect(manifest.ports.ruby.map((entry) => entry.slug)).toContain('v9.8.7.rc.1')
     expect(manifest.defaultVersion.ruby).toBe('latest')
@@ -82,21 +86,32 @@ describe('assembly version selection', () => {
   ])('sets rendered defaults from --versions %s before building', (selected, pythonDefault) => {
     const directory = mkdtempSync(join(tmpdir(), 'libtmux-build-versions-'))
     try {
-      writeFileSync(join(directory, 'gen-versions.mjs'),
-        "import { writeFileSync } from 'node:fs'; writeFileSync(process.argv[3], process.env.TEST_VERSION_MANIFEST);\n")
-      const output = execFileSync('bash', ['-euc', `. ${bookkeeping}\nnode -e 'console.log(process.env.LIBTMUX_DOCS_PORT_DEFAULTS)'`], {
-        encoding: 'utf8',
-        env: {
-          ...process.env, scratch: directory, script_dir: directory,
-          repo_root: new URL('../../', import.meta.url).pathname,
-          site_dir: new URL('../', import.meta.url).pathname,
-          locale: 'en', versions_arg: selected,
-          TEST_VERSION_MANIFEST: JSON.stringify(candidate),
+      writeFileSync(
+        join(directory, 'gen-versions.mjs'),
+        "import { writeFileSync } from 'node:fs'; writeFileSync(process.argv[3], process.env.TEST_VERSION_MANIFEST);\n",
+      )
+      const output = execFileSync(
+        'bash',
+        ['-euc', `. ${bookkeeping}\nnode -e 'console.log(process.env.LIBTMUX_DOCS_PORT_DEFAULTS)'`],
+        {
+          encoding: 'utf8',
+          env: {
+            ...process.env,
+            scratch: directory,
+            script_dir: directory,
+            repo_root: new URL('../../', import.meta.url).pathname,
+            site_dir: new URL('../', import.meta.url).pathname,
+            locale: 'en',
+            versions_arg: selected,
+            TEST_VERSION_MANIFEST: JSON.stringify(candidate),
+          },
         },
-      })
+      )
       expect(JSON.parse(output)).toEqual({ py: pythonDefault, go: 'latest' })
       const manifest = JSON.parse(readFileSync(join(directory, 'versions.json'), 'utf8')) as VersionManifest
-      expect(manifest.ports.py.map((entry) => entry.slug)).toEqual(selected === 'latest' ? ['latest'] : ['stable', 'latest'])
+      expect(manifest.ports.py.map((entry) => entry.slug)).toEqual(
+        selected === 'latest' ? ['latest'] : ['stable', 'latest'],
+      )
       expect(manifest.defaultVersion).toEqual({ py: pythonDefault, go: 'latest' })
     } finally {
       rmSync(directory, { recursive: true, force: true })
@@ -108,15 +123,20 @@ describe('assembly version selection', () => {
   it('refuses a default version for a port this build kept nothing of', () => {
     const directory = mkdtempSync(join(tmpdir(), 'libtmux-build-versions-'))
     try {
-      writeFileSync(join(directory, 'gen-versions.mjs'),
-        "import { writeFileSync } from 'node:fs'; writeFileSync(process.argv[3], process.env.TEST_VERSION_MANIFEST);\n")
+      writeFileSync(
+        join(directory, 'gen-versions.mjs'),
+        "import { writeFileSync } from 'node:fs'; writeFileSync(process.argv[3], process.env.TEST_VERSION_MANIFEST);\n",
+      )
       const result = spawnSync('bash', ['-euc', `. ${bookkeeping}\ndefault_version_for go`], {
         encoding: 'utf8',
         env: {
-          ...process.env, scratch: directory, script_dir: directory,
+          ...process.env,
+          scratch: directory,
+          script_dir: directory,
           repo_root: new URL('../../', import.meta.url).pathname,
           site_dir: new URL('../', import.meta.url).pathname,
-          locale: 'en', versions_arg: 'stable',
+          locale: 'en',
+          versions_arg: 'stable',
           TEST_VERSION_MANIFEST: JSON.stringify(candidate),
         },
       })
@@ -130,8 +150,10 @@ describe('assembly version selection', () => {
   it('binds an alias to the exact source artifact it resolves to', () => {
     const directory = mkdtempSync(join(tmpdir(), 'libtmux-build-alias-'))
     try {
-      writeFileSync(join(directory, 'gen-versions.mjs'),
-        "import { writeFileSync } from 'node:fs'; writeFileSync(process.argv[3], process.env.TEST_VERSION_MANIFEST);\n")
+      writeFileSync(
+        join(directory, 'gen-versions.mjs'),
+        "import { writeFileSync } from 'node:fs'; writeFileSync(process.argv[3], process.env.TEST_VERSION_MANIFEST);\n",
+      )
       execFileSync('bash', ['-euc', `. ${bookkeeping}`], {
         env: {
           ...process.env,
@@ -150,12 +172,14 @@ describe('assembly version selection', () => {
         },
       })
       const manifest = JSON.parse(readFileSync(join(directory, 'versions.json'), 'utf8')) as VersionManifest
-      expect(manifest.ports.ruby).toEqual([expect.objectContaining({
-        slug: 'next',
-        kind: 'alias',
-        resolvesTo: 'v0.1.0.alpha.1',
-        source: 'a'.repeat(40),
-      })])
+      expect(manifest.ports.ruby).toEqual([
+        expect.objectContaining({
+          slug: 'next',
+          kind: 'alias',
+          resolvesTo: 'v0.1.0.alpha.1',
+          source: 'a'.repeat(40),
+        }),
+      ])
     } finally {
       rmSync(directory, { recursive: true, force: true })
     }
@@ -173,12 +197,7 @@ describe('compareTags', () => {
 
   it('orders prerelease identifiers numerically', () => {
     const tags = ['v0.0.0-alpha.1', 'v0.0.0-alpha.2', 'v0.0.0-alpha.9', 'v0.0.0-alpha.10']
-    expect(newestFirst(tags)).toEqual([
-      'v0.0.0-alpha.10',
-      'v0.0.0-alpha.9',
-      'v0.0.0-alpha.2',
-      'v0.0.0-alpha.1',
-    ])
+    expect(newestFirst(tags)).toEqual(['v0.0.0-alpha.10', 'v0.0.0-alpha.9', 'v0.0.0-alpha.2', 'v0.0.0-alpha.1'])
   })
 
   it('puts a release ahead of its own prereleases', () => {
@@ -200,10 +219,13 @@ describe('sortVersions', () => {
     slugs.map((slug) => ({ slug, label: slug, kind: 'tag', supported: true }))
 
   it('orders crate-prefixed and bare tags without changing their source names', () => {
-    expect(sortVersions(tags(['libtmux@v1.0.0-alpha.10', 'libtmux@v1.0.0']), 'semver', 'libtmux@').map((e) => e.slug))
-      .toEqual(['libtmux@v1.0.0', 'libtmux@v1.0.0-alpha.10'])
-    expect(sortVersions(tags(['0.1.0-alpha.9', '0.1.0-alpha.10'])).map((e) => e.slug))
-      .toEqual(['0.1.0-alpha.10', '0.1.0-alpha.9'])
+    expect(
+      sortVersions(tags(['libtmux@v1.0.0-alpha.10', 'libtmux@v1.0.0']), 'semver', 'libtmux@').map((e) => e.slug),
+    ).toEqual(['libtmux@v1.0.0', 'libtmux@v1.0.0-alpha.10'])
+    expect(sortVersions(tags(['0.1.0-alpha.9', '0.1.0-alpha.10'])).map((e) => e.slug)).toEqual([
+      '0.1.0-alpha.10',
+      '0.1.0-alpha.9',
+    ])
   })
 
   it('puts a release above its own prereleases', () => {
diff --git a/site/test/workspace-shared-loader.test.ts b/site/test/workspace-shared-loader.test.ts
index 92adec32a..43df1a696 100644
--- a/site/test/workspace-shared-loader.test.ts
+++ b/site/test/workspace-shared-loader.test.ts
@@ -18,7 +18,9 @@ const PORTS = ALL_PORTS.filter((port) => KNOWN_PORTS.has(port.slug))
 vi.mock('astro/loaders', () => ({ glob: () => ({ load: async () => {} }) }))
 
 const roots: string[] = []
-afterEach(async () => { await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true }))) })
+afterEach(async () => {
+  await Promise.all(roots.splice(0).map((root) => rm(root, { recursive: true, force: true })))
+})
 
 async function fixture() {
   const root = await mkdtemp(join(tmpdir(), 'workspace-loader-'))
@@ -56,7 +58,8 @@ async function fixture() {
     const stats = event === 'unlink' ? undefined : statSync(path)
     await Promise.all(watcher.listeners(event).map((listener) => Promise.resolve(listener(path, stats))))
   }
-  const notify = (event: string, path = file) => watcher.emit(event, path, event === 'unlink' ? undefined : statSync(path))
+  const notify = (event: string, path = file) =>
+    watcher.emit(event, path, event === 'unlink' ? undefined : statSync(path))
   const bodies = () => PORTS.map(({ slug }) => entries.get(`ports/${slug}/workspace`)?.body)
   return { shared, file, entries, writes, render, parseData, infos, errors, emit, notify, bodies }
 }
@@ -117,42 +120,48 @@ it('converges to the latest edit when watcher events overlap', async () => {
   expect(bodies()).toEqual(PORTS.map(() => '\nlatest edit'))
 })
 
-it.each(['render', 'schema', 'render dependency'] as const)('retains complete previous entries on %s failure and recovers on the next edit', async (failure) => {
-  const { file, shared, entries, render, parseData, infos, errors, emit, bodies } = await fixture()
-  const original = [...entries]
-  let calls = 0
-  if (failure === 'schema') {
-    parseData.mockImplementation(async ({ data }) => {
-      if (++calls === 3) throw new Error('invalid shared metadata')
-      return data
-    })
-  } else {
-    render.mockImplementation(async (body) => {
-      if (++calls === 3) throw Object.assign(new Error('invalid shared page'), { code: failure === 'render dependency' ? 'ENOENT' : undefined })
-      return { html: body }
-    })
-  }
-  await writeFile(file, '---\ntitle: Shared\n---\nbroken edit')
-  await expect(emit('change')).resolves.toBeUndefined()
-  expect(errors).toHaveBeenCalled()
-  expect([...entries]).toEqual(original)
-  await writeFile(file, '---\ntitle: Shared\n---\nrecovered edit')
-  await emit('change')
-  expect(bodies()).toEqual(PORTS.map(() => '\nrecovered edit'))
-  render.mockClear()
-  infos.mockClear()
-  const sibling = `${shared}-backup/workspace/index.md`
-  const text = join(shared, 'notes.txt')
-  const outside = join(shared, '..', 'outside.md')
-  await mkdir(join(sibling, '..'), { recursive: true })
-  for (const ignored of [sibling, text, outside]) await writeFile(ignored, 'ignored')
-  await emit('change', sibling)
-  await emit('add', text)
-  await emit('change', outside)
-  expect(render).not.toHaveBeenCalled()
-  expect(infos).not.toHaveBeenCalled()
-  expect(await readFile(file, 'utf8')).toContain('recovered edit')
-})
+it.each(['render', 'schema', 'render dependency'] as const)(
+  'retains complete previous entries on %s failure and recovers on the next edit',
+  async (failure) => {
+    const { file, shared, entries, render, parseData, infos, errors, emit, bodies } = await fixture()
+    const original = [...entries]
+    let calls = 0
+    if (failure === 'schema') {
+      parseData.mockImplementation(async ({ data }) => {
+        if (++calls === 3) throw new Error('invalid shared metadata')
+        return data
+      })
+    } else {
+      render.mockImplementation(async (body) => {
+        if (++calls === 3)
+          throw Object.assign(new Error('invalid shared page'), {
+            code: failure === 'render dependency' ? 'ENOENT' : undefined,
+          })
+        return { html: body }
+      })
+    }
+    await writeFile(file, '---\ntitle: Shared\n---\nbroken edit')
+    await expect(emit('change')).resolves.toBeUndefined()
+    expect(errors).toHaveBeenCalled()
+    expect([...entries]).toEqual(original)
+    await writeFile(file, '---\ntitle: Shared\n---\nrecovered edit')
+    await emit('change')
+    expect(bodies()).toEqual(PORTS.map(() => '\nrecovered edit'))
+    render.mockClear()
+    infos.mockClear()
+    const sibling = `${shared}-backup/workspace/index.md`
+    const text = join(shared, 'notes.txt')
+    const outside = join(shared, '..', 'outside.md')
+    await mkdir(join(sibling, '..'), { recursive: true })
+    for (const ignored of [sibling, text, outside]) await writeFile(ignored, 'ignored')
+    await emit('change', sibling)
+    await emit('add', text)
+    await emit('change', outside)
+    expect(render).not.toHaveBeenCalled()
+    expect(infos).not.toHaveBeenCalled()
+    expect(await readFile(file, 'utf8')).toContain('recovered edit')
+  },
+)
 
 it('contains watcher failures when the emitter ignores the returned promise', async () => {
   const { file, render, errors, notify, emit, bodies } = await fixture()
diff --git a/site/test/workspace-shared.test.ts b/site/test/workspace-shared.test.ts
index 18023c792..5982d5907 100644
--- a/site/test/workspace-shared.test.ts
+++ b/site/test/workspace-shared.test.ts
@@ -30,7 +30,15 @@ describe('workspace-shared slots', () => {
 describe('workspace-shared frontmatter merge', () => {
   it('layers a port override over shared defaults and stamps port/product', () => {
     const frontmatter = { title: 'Shared title', ports: { go: { title: 'Go title' } } }
-    expect(resolvePortData(frontmatter, 'go', 'workspace')).toEqual({ title: 'Go title', port: 'go', product: 'workspace' })
-    expect(resolvePortData(frontmatter, 'ts', 'workspace')).toEqual({ title: 'Shared title', port: 'ts', product: 'workspace' })
+    expect(resolvePortData(frontmatter, 'go', 'workspace')).toEqual({
+      title: 'Go title',
+      port: 'go',
+      product: 'workspace',
+    })
+    expect(resolvePortData(frontmatter, 'ts', 'workspace')).toEqual({
+      title: 'Shared title',
+      port: 'ts',
+      product: 'workspace',
+    })
   })
 })
diff --git a/site/test/wrapper-libraries.test.ts b/site/test/wrapper-libraries.test.ts
index ad05676db..7c7caa943 100644
--- a/site/test/wrapper-libraries.test.ts
+++ b/site/test/wrapper-libraries.test.ts
@@ -64,7 +64,9 @@ describe('wrapper library identities', () => {
       expect(portSourceUrl(port, version)).toBe(`${root}master${path}`)
     }
     expect(portSourceUrl(port, 'latest', 'feature/source-links')).toBe(`${root}feature%2Fsource-links${path}`)
-    expect(portSourceUrl(PORT_BY_SLUG.java, 'v0.0.1-alpha.17', 'a'.repeat(40))).toBe('https://github.com/libtmux/libtmux-java')
+    expect(portSourceUrl(PORT_BY_SLUG.java, 'v0.0.1-alpha.17', 'a'.repeat(40))).toBe(
+      'https://github.com/libtmux/libtmux-java',
+    )
   })
 
   it('supplies native examples and registry versions in the library installer', () => {
@@ -86,10 +88,13 @@ describe('wrapper library identities', () => {
 
   it('keeps parent-language examples in wrapper-owned guides', () => {
     vi.stubEnv('LIBTMUX_DOCS_PORT', 'fsharp')
-    const sample = () => ({ type: 'root', children: [
-      { type: 'code', lang: 'fsharp', value: 'open LibTmux.FSharp' },
-      { type: 'code', lang: 'csharp', value: 'using LibTmux;' },
-    ] })
+    const sample = () => ({
+      type: 'root',
+      children: [
+        { type: 'code', lang: 'fsharp', value: 'open LibTmux.FSharp' },
+        { type: 'code', lang: 'csharp', value: 'using LibTmux;' },
+      ],
+    })
     const owned = sample()
     remarkPortCode()(owned, { data: { astro: { frontmatter: { port: 'fsharp' } } } })
     expect(owned.children).toHaveLength(2)
@@ -107,9 +112,8 @@ describe('wrapper library identities', () => {
 
 describe('quickstart display formatting', () => {
   const views = PORTS.flatMap((port) => HOME_VIEWS.map((view) => ({ ...port, view })))
-  const columns = (line: string) => [...line].reduce(
-    (column, char) => column + (char === '\t' ? 8 - column % 8 : 1), 0,
-  )
+  const columns = (line: string) =>
+    [...line].reduce((column, char) => column + (char === '\t' ? 8 - (column % 8) : 1), 0)
   it('provides a complete verified program for every registered language', () => {
     expect(Object.keys(HOME_EXAMPLES).sort()).toEqual(PORTS.map((port) => port.slug).sort())
     expect(HOME_PROOF.examples.map((example) => example.port).sort()).toEqual(Object.keys(HOME_EXAMPLES).sort())
@@ -124,7 +128,9 @@ describe('quickstart display formatting', () => {
     const example = HOME_EXAMPLES[slug as keyof typeof HOME_EXAMPLES]
     expect(example.files.map((file) => file.name)).not.toContain('run.sh')
     expect(example.commands.join('\n')).not.toContain('sh run.sh')
-    expect(homeProgram(example, view)).not.toMatch(/\b(?:args|argv)\s*(?:\[\d+\]|\(\d+\))|CommandLine\.arguments|TMUX_SOCKET/)
+    expect(homeProgram(example, view)).not.toMatch(
+      /\b(?:args|argv)\s*(?:\[\d+\]|\(\d+\))|CommandLine\.arguments|TMUX_SOCKET/,
+    )
   })
 
   it.each(views)('$slug/$view fits 80 columns, including expanded tabs', ({ slug, view }) => {
@@ -141,12 +147,24 @@ describe('quickstart display formatting', () => {
     expect(complete.sourceRevision).toBe(proof.sourceRevision)
     expect(complete.sourceTree).toBe(proof.sourceTree)
     expect(complete.commands).toEqual(proof.shellRecipe)
-    expect(complete.files.map((file) => ({ name: file.name, sha256: hash(file.code), clipboardSha256: hash(file.code.replace(/\n$/, '')) }))).toEqual(proof.files)
+    expect(
+      complete.files.map((file) => ({
+        name: file.name,
+        sha256: hash(file.code),
+        clipboardSha256: hash(file.code.replace(/\n$/, '')),
+      })),
+    ).toEqual(proof.files)
     expect(hash(homeProgram(complete, 'full').replace(/\n$/, ''))).toBe(proof.excerptSha256)
     for (const view of HOME_VIEWS.filter((item) => item !== 'full')) {
       const code = homeProgram(complete, view)
-      const files = complete.files.map((file) => file.name === complete.program ? { ...file, code } : file)
-      expect(files.map((file) => ({ name: file.name, sha256: hash(file.code), clipboardSha256: hash(file.code.replace(/\n$/, '')) }))).toEqual(proof.variants[view].files)
+      const files = complete.files.map((file) => (file.name === complete.program ? { ...file, code } : file))
+      expect(
+        files.map((file) => ({
+          name: file.name,
+          sha256: hash(file.code),
+          clipboardSha256: hash(file.code.replace(/\n$/, '')),
+        })),
+      ).toEqual(proof.variants[view].files)
       expect(hash(code.replace(/\n$/, ''))).toBe(proof.variants[view].excerptSha256)
       expect(code, `${proof.port}/${view} must offer a distinct program`).not.toBe(homeProgram(complete, 'full'))
     }
@@ -159,46 +177,70 @@ describe('quickstart display formatting', () => {
 })
 
 describe.skipIf(!SITE_BUILT)('published wrapper pages', () => {
-  it.each(PORTS.filter((port) => port.parentLibrary))('$slug has complete library routes and metadata', async (port) => {
-    const root = `${port.slug}/latest`
-    const prefix = `/${SITE_PREFIX}${root}/`
-    for (const product of ['mcp', 'workspace']) expect(existsSync(sitePath(root, product)), `${port.slug}/${product}`).toBe(false)
-    for (const route of ['', 'guides', 'examples', 'reference']) {
-      const window = new Window({
-        url: `https://libtmux.org${prefix}${route}/`,
-        settings: { disableJavaScriptEvaluation: true, disableJavaScriptFileLoading: true, disableCSSFileLoading: true },
-      })
-      try {
-        const document = window.document
-        document.write(readFileSync(sitePath(root, route, 'index.html'), 'utf8'))
-        expect(document.querySelectorAll('h1'), `${port.slug}/${route}`).toHaveLength(1)
-        expect(document.querySelector('link[rel="canonical"]')?.getAttribute('href')).toBe(`https://libtmux.org${prefix}${route ? `${route}/` : ''}`)
-        expect(document.querySelector('meta[property="og:image"]')?.getAttribute('content')).toContain(`/brand/${port.logoLanguage}/library/`)
-        expect(document.querySelector('link[rel="manifest"]')?.getAttribute('href')).toContain(`/brand/${port.logoLanguage}/library/`)
-        for (const anchor of document.querySelectorAll('main a[href], nav[aria-label="Documentation"] a[href], nav[aria-label="Port documentation"] a[href]')) {
-          const path = new URL(anchor.getAttribute('href')!, `https://libtmux.org${prefix}${route}/`).pathname
-          if (!path.startsWith(prefix)) continue
-          expect(path).not.toMatch(/\/(?:mcp|workspace)(?:\/|$)/)
-          expect(existsSync(publishedPath(decodeURIComponent(path))) || existsSync(publishedPath(decodeURIComponent(path), 'index.html')), path).toBe(true)
-        }
-        if (!route) {
-          const logo = document.querySelector('main img')
-          expect(logo?.getAttribute('src')).toContain(`/brand/${port.logoLanguage}/library/logo.svg`)
-          expect(logo?.getAttribute('width')).toBe('88')
-          expect(document.querySelector('main')?.textContent).toContain(PORT_BY_SLUG[port.parentLibrary!.slug].name)
-          expect(document.querySelector('.port-links a')?.getAttribute('href')).toBe(portSourceUrl(port))
-          expect(document.querySelector('footer a[aria-label="GitHub"]')?.getAttribute('href')).toBe(`${portSourceUrl(port)}${port.source ? '' : '/'}`)
+  it.each(PORTS.filter((port) => port.parentLibrary))(
+    '$slug has complete library routes and metadata',
+    async (port) => {
+      const root = `${port.slug}/latest`
+      const prefix = `/${SITE_PREFIX}${root}/`
+      for (const product of ['mcp', 'workspace'])
+        expect(existsSync(sitePath(root, product)), `${port.slug}/${product}`).toBe(false)
+      for (const route of ['', 'guides', 'examples', 'reference']) {
+        const window = new Window({
+          url: `https://libtmux.org${prefix}${route}/`,
+          settings: {
+            disableJavaScriptEvaluation: true,
+            disableJavaScriptFileLoading: true,
+            disableCSSFileLoading: true,
+          },
+        })
+        try {
+          const document = window.document
+          document.write(readFileSync(sitePath(root, route, 'index.html'), 'utf8'))
+          expect(document.querySelectorAll('h1'), `${port.slug}/${route}`).toHaveLength(1)
+          expect(document.querySelector('link[rel="canonical"]')?.getAttribute('href')).toBe(
+            `https://libtmux.org${prefix}${route ? `${route}/` : ''}`,
+          )
+          expect(document.querySelector('meta[property="og:image"]')?.getAttribute('content')).toContain(
+            `/brand/${port.logoLanguage}/library/`,
+          )
+          expect(document.querySelector('link[rel="manifest"]')?.getAttribute('href')).toContain(
+            `/brand/${port.logoLanguage}/library/`,
+          )
+          for (const anchor of document.querySelectorAll(
+            'main a[href], nav[aria-label="Documentation"] a[href], nav[aria-label="Port documentation"] a[href]',
+          )) {
+            const path = new URL(anchor.getAttribute('href')!, `https://libtmux.org${prefix}${route}/`).pathname
+            if (!path.startsWith(prefix)) continue
+            expect(path).not.toMatch(/\/(?:mcp|workspace)(?:\/|$)/)
+            expect(
+              existsSync(publishedPath(decodeURIComponent(path))) ||
+                existsSync(publishedPath(decodeURIComponent(path), 'index.html')),
+              path,
+            ).toBe(true)
+          }
+          if (!route) {
+            const logo = document.querySelector('main img')
+            expect(logo?.getAttribute('src')).toContain(`/brand/${port.logoLanguage}/library/logo.svg`)
+            expect(logo?.getAttribute('width')).toBe('88')
+            expect(document.querySelector('main')?.textContent).toContain(PORT_BY_SLUG[port.parentLibrary!.slug].name)
+            expect(document.querySelector('.port-links a')?.getAttribute('href')).toBe(portSourceUrl(port))
+            expect(document.querySelector('footer a[aria-label="GitHub"]')?.getAttribute('href')).toBe(
+              `${portSourceUrl(port)}${port.source ? '' : '/'}`,
+            )
+          }
+        } finally {
+          await window.happyDOM.close()
         }
-      } finally { await window.happyDOM.close() }
-    }
-    const manifest = JSON.parse(readFileSync(sitePath(root, 'docs.json'), 'utf8'))
-    const identity = manifest.ports.find((entry: { slug: string }) => entry.slug === port.slug)
-    expect(identity.parentLibrary).toEqual(port.parentLibrary)
-    expect(identity.products).toEqual([])
-    expect(manifest.sourceRepository).toBe(`https://github.com/${port.repo}`)
-    for (const page of manifest.pages) {
-      const path = new URL(page.url).pathname
-      if (path.startsWith(prefix)) expect(existsSync(join(publishedPath(path), 'index.html')), page.url).toBe(true)
-    }
-  })
+      }
+      const manifest = JSON.parse(readFileSync(sitePath(root, 'docs.json'), 'utf8'))
+      const identity = manifest.ports.find((entry: { slug: string }) => entry.slug === port.slug)
+      expect(identity.parentLibrary).toEqual(port.parentLibrary)
+      expect(identity.products).toEqual([])
+      expect(manifest.sourceRepository).toBe(`https://github.com/${port.repo}`)
+      for (const page of manifest.pages) {
+        const path = new URL(page.url).pathname
+        if (path.startsWith(prefix)) expect(existsSync(join(publishedPath(path), 'index.html')), page.url).toBe(true)
+      }
+    },
+  )
 })