diff --git a/.agents/skills/submit-pr/SKILL.md b/.agents/skills/submit-pr/SKILL.md
index 700a404d..a21c83da 100644
--- a/.agents/skills/submit-pr/SKILL.md
+++ b/.agents/skills/submit-pr/SKILL.md
@@ -1,7 +1,7 @@
 ---
 name: submit-pr
 description: Creates a pull request with a well-structured description after verifying CI passes. Use when the user asks to submit, create, or open a pull request.
-disable-model-invocation: true
+disable-model-invocation: false
 ---
 <!-- agent-pmo:a72c926 -->
 
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b45e17eb..0dd9df86 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -296,9 +296,9 @@ jobs:
   #
   # `always()` so it reports a real conclusion rather than inheriting a skip:
   # on a docs-only PR every upstream job skips and this passes; on a Dependabot
-  # PR the whole pipeline skips and this passes; any failure or cancellation
-  # anywhere upstream fails it, and so does a skipped build or test job when
-  # code changed. Either way the merge is blocked.
+  # PR the whole pipeline skips and this FAILS, since it ran nothing; any
+  # failure or cancellation anywhere upstream fails it, and so does a skipped
+  # build or test job when code changed. Either way the merge is blocked.
   ci:
     name: CI
     if: ${{ always() }}
@@ -338,6 +338,15 @@ jobs:
         run: |-
           echo "::error::Code changed but a build or test job was skipped. Check its if: condition."
           exit 1
+      # The whole pipeline skipped this Dependabot PR, so a pass would be a
+      # pass of nothing. Its bump reaches `main` only through the tested
+      # consolidation PR; the sweep retires this one. [DIST-CI-DEPENDABOT]
+      - name: Fail a Dependabot PR to main, which ran no job
+        if: ${{ github.actor == 'dependabot[bot]' }}
+        shell: bash
+        run: |-
+          echo "::error::Dependabot PRs run no CI. dependabot-automerge.yml sweeps this bump into dependabot-upgrades; it reaches main through the tested dependabot-upgrades -> main PR."
+          exit 1
       - name: Report
         shell: bash
         run: echo "All CI jobs passed or were skipped."
diff --git a/Makefile b/Makefile
index 78588bf1..809dac3f 100644
--- a/Makefile
+++ b/Makefile
@@ -40,7 +40,7 @@
 # sidecars ONCE and emitting that platform's VSIX and its standalone server
 # archive ([DIST-ARCHIVE]); VERSION is optional and defaults to 0.0.0. Then
 # `_print-publish-commands`. Also private: `_screenshots`, `_website-build`,
-# `_website-dev`, `_test-website` and `_uninstall-dotnet-10`.
+# `_website-dev`, `_test-website`, `_film` and `_uninstall-dotnet-10`.
 
 # ── OS detection ──────────────────────────────────────────────────
 # All recipes assume a POSIX shell. On Windows we use Git Bash (bundled with
@@ -145,7 +145,7 @@ KOVER_PERCENT = $(if $(COVERAGE_TOOLS_PREBUILT),$(DOTNET) target/coverage-tools/
 .PHONY: build ci test lint fmt clean audit setup _build-profiler-ui \
         reinstall-vsix install-vsix uninstall-vsix install-dotnet-10
 
-.PHONY: _screenshots _website-build _website-dev _uninstall-dotnet-10 \
+.PHONY: _screenshots _website-build _website-dev _film _uninstall-dotnet-10 \
         _package-vsix-linux-x64 _package-vsix-linux-arm64 \
         _package-vsix-darwin-arm64 _package-vsix-darwin-x64 \
         _package-vsix-win32-x64 _package-vsix-win32-arm64 \
@@ -805,6 +805,16 @@ _website-dev:
 	@echo "==> Starting website development server..."
 	npm run dev --prefix src/website
 
+# [WEB-DESIGN-MEDIA] Shoot and publish one website film from the packaged VSIX:
+# `make _film FILM=fsharp`, or `PUBLISH=1` to publish the last shoot again.
+# The films live in src/website/tools/profiler-film/films; its README says how.
+_film:
+	@test -n "$(FILM)" || { echo "usage: make _film FILM=<film> [PUBLISH=1]" >&2; exit 1; }
+	$(if $(PUBLISH),,$(MAKE) _build-vsix VSIX_PREBUILT=1)
+	@# Install once: npm ci would wipe the voice model kokoro-js caches in node_modules.
+	test -d src/website/tools/profiler-film/node_modules || npm ci --prefix src/website/tools/profiler-film
+	node src/website/tools/profiler-film/film.mjs $(FILM) $(if $(PUBLISH),--publish,)
+
 _test-website:
 	@echo "==> Running website Playwright tests..."
 	npm ci --prefix src/website
diff --git a/docs/plans/PROFILER-PLAN.md b/docs/plans/PROFILER-PLAN.md
index 5ea319a7..bb779b20 100644
--- a/docs/plans/PROFILER-PLAN.md
+++ b/docs/plans/PROFILER-PLAN.md
@@ -186,6 +186,23 @@ These are SharpLsp's shipped profiler features. Cutover is blocked until each ro
   - The Rust `profiler_shared` tests raced: each nextest process rewrote the engine beside the shared server binary while another test's engine started, and lost the race with "exited before attaching". The engine is now installed atomically.
   - The suites' lifecycle and flows live once in `profiler-kit.ts` (`profilingSuite`, `profileFromRowFor`, `stopTracking`, `snapshotSession`, `retentionGraph`). The Deslop gate is ratcheted from 6.73 % to 6.65 %.
 - [x] The `profiler` chunk on macOS (`make _test-vsix-shard CHUNK=profiler`, 2026-10-15): **294 passing, 0 failing**, after the defects below were fixed; the debugger, manifest and configuration suites they touch pass too (30 passing).
+- [x] F# on real programs: `FsPricingEngine` (CPU: CSV parsing, discount rules, fuzzy search, routing, reports) and `FsOrderLedger` (an event handler, a memoize cache, a mailbox audit trail, undo history and rejection capture, each rooted at its own module value), under `src/sharplsp/tests/fixtures/fsharp-profiling/`. The suites `profiler-fsharp-cpu-e2e`, `-memory-e2e`, `-retention-e2e`, `-corner-e2e`, `-soak-e2e`, `-soak-cpu-e2e` and `profiler-lsp-protocol-e2e`, `-cpu-e2e`, `-memory-e2e` drive them through the UI and over the wire. The defects they found are fixed in lspkit and the host:
+  - idle samples counted as active, so a main thread waiting on stdin took half of every profile (lspkit#12);
+  - a frame every thread shares counted once per thread, so its samples outnumbered the ticks (lspkit#12);
+  - naming a runtime that cannot profile a busy PID answered `ALREADY_PROFILING`, not `UNSUPPORTED_RUNTIME` (lspkit#12);
+  - a `ResizeArray<Order>`'s `Order[]` painted the line that builds an `Order` (lspkit#12);
+  - a retention graph that left instances out still said it was complete (lspkit#12);
+  - a memory step on a program that had exited answered `OTHER`, not `PROCESS_NOT_FOUND` (lspkit#12);
+  - a second diff kept the first diff's leak badges (lspkit#12);
+  - FSharp.Core types were placed at its build server's paths, which do not exist here (lspkit#13);
+  - `objectsByType` dropped the requested type from its summary when it ranked below the twenty largest, as F# union cases do (lspkit#13);
+  - the retention graph never drew a root's label, so a module value's `static sessions` looked like any holder (lspkit#14);
+  - the timeline's peak fell after a release, because `peak_bytes` was each snapshot's own heap size (lspkit#15);
+  - a heap snapshot taken during a CPU session named types by bare address, because the CPU session enabled the runtime provider (lspkit#15);
+  - a hot function with no location reached the UI as file `""`, line 0 (lspkit#15);
+  - the UI's Stop never sent `memory.stop`, so the server kept the session and its graphs and still answered steps (lspkit#15);
+  - a timed CPU session never left `cpu.list` once its duration elapsed (lspkit#15);
+  - the host accepted a profiler command with no argument, two arguments or a non-object argument (`profiler/host.rs`).
 - [ ] Assertions of the deleted suites with no replacement: counters webview and counter sessions, `openTrace`/`convertTrace` of a `.nettrace`, dump collection with cancellable progress, `inspectObject`, `diffSnapshots`/`detectLeaks` panels over dumps, graph browser interactions. Each maps to a parity gap above.
 
 ### Documentation and cutover
diff --git a/docs/reviews/V0.22.0-STATIC-REVIEW.md b/docs/reviews/V0.22.0-STATIC-REVIEW.md
index ce5e418e..840a40c1 100644
--- a/docs/reviews/V0.22.0-STATIC-REVIEW.md
+++ b/docs/reviews/V0.22.0-STATIC-REVIEW.md
@@ -8,6 +8,18 @@ The .NET Framework and multi-targeting feature has been implemented across the R
 
 The spec explicitly excludes debugging the desktop .NET Framework CLR: Debug of a Framework-only target is refused, while Run uses the desktop CLR on Windows. “Finished” must be judged against that stated scope, not against availability of a .NET Framework debugger.
 
+## Resolution
+
+Re-checked against `main` on 2026-10-18 (`817d359f`):
+
+| Finding | Status |
+|---|---|
+| Parenthesized C# project name read as a framework | Fixed (#382). `FrameworkOf` accepts only the `(tfm)` suffix past the project file's stem. Covered by a real single-target `Utility(net48).csproj` and a multi-targeted `Tool(net10.0).csproj` in `WorkspaceManagerTargetFrameworkTests`. |
+| Switch announced before invalidation and diagnostics | Fixed (#383). The host clears `nav_cache`, publishes every open document's diagnostics and waits for each, then announces and asks for refreshes. `test_full_stack_target_framework_switch` asserts that order, using a warning only `net10.0` compiles. |
+| Run/F5 project paths compared with the wrong case rule | Already fixed before this re-check: `chosenFramework` uses `samePath` from `paths.ts`, and `run-debug-target.test.ts` covers the explicit-project, differently cased focused project on Linux for C# and F#. |
+| Explicit Windows-only selection passes with zero tests | Fixed (#384). Off Windows, a `MOCHA_FILES` pattern that names only `windowsOnly` suites fails with the platform reason (`test-runner-selection.test.ts`). |
+| Dependabot skips `detect-changes`, and the terminal gate passes the skipped run | Fixed. The skip is intended: bumps are tested once, at the `dependabot-upgrades → main` consolidation PR. But `CI` now FAILS a Dependabot PR to `main`, so a security bump the sweep did not retire cannot merge untested ([DIST-CI-DEPENDABOT], `security-gates.test.mjs`). |
+
 ## Findings, in priority order
 
 ### [P2] A single-target C# project name can be mistaken for a framework
diff --git a/docs/specs/DESIGN-SYSTEM.md b/docs/specs/DESIGN-SYSTEM.md
index 16ee0826..37697c05 100644
--- a/docs/specs/DESIGN-SYSTEM.md
+++ b/docs/specs/DESIGN-SYSTEM.md
@@ -126,17 +126,18 @@ Page-level grids and marketing card styles must not leak into `.prose`. Do not r
 
 Screenshots and video of a SharpLsp feature show the real extension, never a mock-up.
 
-- **Capture.** The profiler media is shot by `src/website/tools/profiler-film/`. `capture.mjs` drives an isolated VS Code (its own user-data and extensions directories, never the user's editor) running the packaged VSIX against a real .NET app, and records stills and real-time screencasts. `render.mjs` turns them into the site's assets.
+- **Capture.** The profiler media is shot by `src/website/tools/profiler-film/` (its README says how). Every shot runs on `kit/set.mjs`'s `onSet`: an isolated VS Code (its own user-data and extensions directories, never the user's editor) running the packaged VSIX against a real .NET demo app from `demos/`. A walkthrough is one file in `films/`, a list of scenes that `film.mjs` shoots as real-time clips and publishes; `kit/acts/` tells the CPU and memory stories, so each film supplies only its words, its demo and its fix. `films/leak.mjs` films the C# Storefront demo and `films/fsharp.mjs` its F# twin, FsStorefront, so every F# claim the docs make about the profiler is shown on F# code. The composited one-minute film is `films/profiler/`: `capture.mjs` records stills and screencasts, and `render.mjs` turns them into the site's assets.
 - **Honesty.** Footage plays in real time unless the frame says otherwise: every fast-forwarded stretch carries an on-screen speed marker, and captions name time-lapses. Motion graphics (title cards, camera moves, highlights, the cursor) frame the footage but never alter what the editor shows.
 - **Privacy.** No frame may show a user name, home directory, hostname or terminal. The demo app runs from a neutral temporary path and the terminal is never opened.
 - **Formats.**
   - Films ship as H.264 MP4 and VP9 WebM with a WebP poster.
   - Stills ship as WebP, 2400px wide, with `width` and `height` set.
-  - Marketing pages may autoplay a film only when it is muted and looping; docs pages use controls.
+  - Marketing pages may autoplay a film only when it is muted and looping; docs pages use controls and are never muted.
   - Every autoplaying video pauses and shows its controls under `prefers-reduced-motion: reduce`.
   - Every video ships a WebP poster, the films and the recordings alike.
+- **Narration.** A walkthrough may be narrated (`kit/sound/`). Its reviewed script (`films/<film>.narration.json`) is spoken by Kokoro-82M through `kokoro-js` on the capturing machine, never by a speech service or the operating system's voices, whose licences forbid publishing. Each line starts just after its scene's cut, and a scene holds its last frame until its line ends. The music is an original score synthesised from code (`kit/sound/score.mjs`), so no film carries licensed or sampled music, and it ducks under the voice. A narrated film ships AAC in its MP4 and Opus in its WebM, plays unmuted with controls, and carries WebVTT captions in every site language (`<id>.<lang>.vtt`, the page's own language shown by default), listed under `captions` in the catalogue.
 - **One catalogue.** Every video on the site is declared once in `src/website/src/_data/videos.json`: encodings, size, length, upload date, and its label and caption in each language. Pages place a video with the `{% video "<id>" %}` shortcode (`src/website/video-figure.js`) and never repeat `<video>` markup. The shortcode renders in the page's language and emits a schema.org `VideoObject` whose name is the player's label, so search results describe exactly what a reader hears.
-- **Placement.** A video goes wherever a page talks about what it shows: the home page (the profiler film autoplaying in the hero, the CPU recording in the profiler section), the Getting Started page (the tour), the profiler docs (the film and both recordings), and every blog post that discusses the profiler or the editor experience, in every language the page is published in.
+- **Placement.** A video goes wherever a page talks about what it shows: the home page (the profiler film autoplaying in the hero, the CPU recording in the profiler section), the Getting Started page (the tour), the profiler docs (the film and both recordings), the F# profiling docs and the F# language page (the F# walkthrough), and every blog post that discusses the profiler or the editor experience, in every language the page is published in.
 
 ## [WEB-DESIGN-RESPONSIVE] Responsive Behavior
 
diff --git a/docs/specs/DISTRIBUTION-SPEC.md b/docs/specs/DISTRIBUTION-SPEC.md
index 5af0f875..2524895f 100644
--- a/docs/specs/DISTRIBUTION-SPEC.md
+++ b/docs/specs/DISTRIBUTION-SPEC.md
@@ -867,10 +867,10 @@ inheriting a skip:
 
 1. Any upstream job that FAILED or was CANCELLED fails `CI`, and with it the merge.
 2. A SKIPPED upstream job satisfies it only when no code changed. That is how a
-   docs-only PR (every job skipped by [DIST-CI-CLASSIFICATION]) and a Dependabot
-   PR (the whole pipeline skipped, [DIST-CI-DEPENDABOT]) pass. When code changed,
-   `build`, every test leg and `coverage` MUST have succeeded; a skip among them
-   fails `CI` (#365).
+   docs-only PR (every job skipped by [DIST-CI-CLASSIFICATION]) passes. When code
+   changed, `build`, every test leg and `coverage` MUST have succeeded; a skip
+   among them fails `CI` (#365). A Dependabot PR, whose whole pipeline skipped
+   ([DIST-CI-DEPENDABOT]), always fails `CI`: it ran nothing.
 3. Every PHASE 4 leg and `coverage` states its condition explicitly:
    `!cancelled()`, code changed, and success of the jobs it consumes. GitHub's
    implicit `success()` spans the whole dependency chain, so a legitimately
@@ -929,7 +929,9 @@ superseded, and MUST NOT merge anything into `main` unattended.
    staged batch is verified once, by the full pipeline and CodeQL, on the
    `dependabot-upgrades → main` consolidation PR — the only route a dependency
    change takes into `main`. A staged security fix reaches `main` when that PR
-   is opened, so it is opened promptly.
+   is opened, so it is opened promptly. `CI` enforces the route: it FAILS a
+   Dependabot PR to `main`, so a security bump whose sweep did not retire it
+   cannot merge untested.
 4. `dependabot-automerge.yml` MUST exist on both branches: for `pull_request`,
    GitHub runs the workflow from the PR's BASE branch.
 
@@ -1107,6 +1109,10 @@ Invariants:
   distinction the manifest carries is `"linuxOnly": true` or
   `"windowsOnly": true`, which drops a chunk from the other platform's matrix. A
   chunk MUST NOT be declared in CI YAML.
+- **A selection never runs nothing.** The in-host runner fails a run whose
+  `MOCHA_FILES` pattern matches no compiled suite, and, off Windows, one whose
+  pattern names only suites of `windowsOnly` chunks: dropping every one would
+  report a green run of zero tests (`test-runner-selection.test.ts`).
 - **One runner, one shard target.** `make _run-vsix-suite` is the single recipe;
   `CHUNK` selects the slice (empty runs every suite) and `VSIX_SUITE_PREBUILT`
   says the suite is already compiled. Coverage is NOT a knob — the runner always
diff --git a/docs/specs/DOTNET-FRAMEWORK-SPEC.md b/docs/specs/DOTNET-FRAMEWORK-SPEC.md
index a2f72951..9c10a616 100644
--- a/docs/specs/DOTNET-FRAMEWORK-SPEC.md
+++ b/docs/specs/DOTNET-FRAMEWORK-SPEC.md
@@ -64,13 +64,16 @@ built at load or at the switch that needs them
 - `sharplsp/targetFramework` `{ textDocument }` → `{ active, available, project }`;
   `sharplsp/setTargetFramework` `{ textDocument, targetFramework }` switches the whole PROJECT in
   both languages and answers the same shape. A single-target project answers
-  `{ active: null, available: [] }`; a document no loaded project compiles answers
-  `{ active: null, available: [], project: null }`, and switching it is an error.
+  `{ active: null, available: [] }`, even one whose name ends in `(tfm)`: a framework is
+  only the suffix `MSBuildWorkspace` appends to the project FILE's stem. A document no
+  loaded project compiles answers `{ active: null, available: [], project: null }`, and
+  switching it is an error.
 - After a switch the host clears its navigation cache, re-publishes every open document's
-  diagnostics, sends `sharplsp/targetFrameworkChanged` `{ textDocument, active, available,
-  project }`, then each of `workspace/semanticTokens/refresh`, `workspace/inlayHint/refresh`,
-  `workspace/codeLens/refresh` and `workspace/diagnostic/refresh` whose `refreshSupport` the
-  client declared.
+  diagnostics and waits for each first publication (a failed or provisional fetch goes on
+  retrying in the background), sends `sharplsp/targetFrameworkChanged` `{ textDocument,
+  active, available, project }`, then each of `workspace/semanticTokens/refresh`,
+  `workspace/inlayHint/refresh`, `workspace/codeLens/refresh` and
+  `workspace/diagnostic/refresh` whose `refreshSupport` the client declared.
 - VS Code: a status-bar item `$(versions) <tfm>` shows the focused document's active framework
   when its project is multi-targeted, and runs `sharplsp.selectTargetFramework [tfm]`. Without
   an argument the command opens a pick placeheld `Target framework for <Project>` (file name, no
diff --git a/docs/specs/PROFILER-SPEC.md b/docs/specs/PROFILER-SPEC.md
index 16db940a..c92683a0 100644
--- a/docs/specs/PROFILER-SPEC.md
+++ b/docs/specs/PROFILER-SPEC.md
@@ -62,7 +62,8 @@ flowchart LR
   - the record, the union case and the generic record each anchor, and are painted, at the exact `Program.fs` line that constructs them;
   - the dashboard names the union case `HotLeakAppFs.PayloadKind+Small`;
   - the diff scores the record as a leak;
-  - the leak's retention root is the module value `static items`, with no compiler-mangled name.
+  - the leak's retention root is the module value `static items`, with no compiler-mangled name;
+  - the fixture's line protocol builds the rest of the F# heap zoo one shape at a time: orders over a single-case union, a union case with fields, a list and a struct record; quotes behind a never-evicting cache; event-handler closures; a reference cycle; and arrays. Each anchors at its constructing line except arrays, which have none, and the growing record reaches Low confidence.
 - File-system paths go only through `src/editors/vscode/src/paths.ts`.
 
 ### [PROFILER-SHARED-LIBRARY-ENGINE] Engine bundling
@@ -651,7 +652,7 @@ Commands used per node:
 
 ### [PROFILER-GRAPH-WEBVIEW] Interactive Graph Webview
 
-The object graph renders as an interactive force-directed graph in a VS Code webview panel.
+The object graph renders as a layered graph in a VS Code webview panel: GC roots on top, named by their labels, and the target objects along the bottom ([PROF-UI-REFGRAPH] in lspkit).
 
 #### [PROFILER-GRAPH-WEBVIEW-LAYOUT] Graph Layout
 
@@ -762,7 +763,7 @@ output_directory = ".sharplsp/profiles"
 | Command palette | Start/stop trace, start/stop counters, collect dump, leak detection |
 | Webview panel | Display counter values as live-updating table |
 | Webview panel | Display heap stats as sortable table |
-| Webview panel | Interactive object retention graph (D3.js force-directed) |
+| Webview panel | Object retention graph, layered from GC roots down to the targets |
 | Webview panel | Heap snapshot diff table with growth indicators |
 | Quick pick | Process selection from discovered .NET processes |
 | File open | Open `.speedscope.json` output in browser/SpeedScope viewer |
diff --git a/docs/specs/SHARPLSP-SPEC.md b/docs/specs/SHARPLSP-SPEC.md
index b5ae558b..9794d097 100644
--- a/docs/specs/SHARPLSP-SPEC.md
+++ b/docs/specs/SHARPLSP-SPEC.md
@@ -208,7 +208,7 @@ A `<ProjectReference>` from a loaded F# project to a C# project is compiled in m
 
 An F# project that references a C# project always loads from MSBuild's design-time command line, even with one framework, because only MSBuild knows which build of the C# project that framework compiles against. Its `ReferencePathWithRefAssemblies` item names the C# project, the framework MSBuild picked and the `-r:` path, as for an F# reference ([SHARPLSP-ARCHITECTURE-PROJECTS-FSHARP-REFERENCES]). A design-time build of the C# project for that framework reports the C# compiler's command line (`CscCommandLineArgs`), and Roslyn compiles its sources against its references. A C# project it references in turn is compiled the same way and read from that compilation. A cycle, which MSBuild refuses anyway, is refused. Each C# build is prepared once per project and framework, at load or at the framework switch that needs it.
 
-Roslyn emits a metadata-only image that tolerates errors in method bodies, and FCS reads that image under the exact `-r:` MSBuild wrote, so the F# command line is unchanged.
+Roslyn emits a metadata-only image that tolerates errors in method bodies, and FCS reads that image under the exact `-r:` MSBuild wrote, so the F# command line is unchanged. The compilation first runs the C# source generators that the command line's `/analyzer:` assemblies hold, as the build does. A project that polyfills .NET Framework through one, such as PolySharp writing `IsExternalInit` for an `init` accessor, emits nothing without them, and F# would read a DLL nobody built.
 
 A build is stamped with the newest last-write time of its project file, its sources and the builds it reads. When the stamp moves, Roslyn compiles again and FCS reads the new image. When the changed sources no longer emit, the last image stays and the log says why. Unsaved C# edits live in the C# sidecar, so F# sees a C# edit once it is saved.
 
diff --git a/lspkit b/lspkit
index 031bfc83..ccc59bfc 160000
--- a/lspkit
+++ b/lspkit
@@ -1 +1 @@
-Subproject commit 031bfc83d9157f3256365553466424af1258e375
+Subproject commit ccc59bfc42eaa62980578317c749251098f2338b
diff --git a/src/editors/vscode/src/test/suite/index.ts b/src/editors/vscode/src/test/suite/index.ts
index feb44bb3..b2928f9b 100644
--- a/src/editors/vscode/src/test/suite/index.ts
+++ b/src/editors/vscode/src/test/suite/index.ts
@@ -47,8 +47,8 @@ interface ChunkManifest {
  * Suites of `windowsOnly` chunks: .NET Framework test hosts run only on Windows
  * ([NETFX-SCOPE]), so they never load elsewhere — not even in a local full run.
  */
-function windowsOnlySuites(): ReadonlySet<string> {
-  if (process.platform === 'win32') return new Set();
+function windowsOnlySuites(platform: NodeJS.Platform): ReadonlySet<string> {
+  if (platform === 'win32') return new Set();
   const manifest = path.resolve(__dirname, '..', '..', '..', 'test-chunks.json');
   const { chunks } = JSON.parse(fs.readFileSync(manifest, 'utf8')) as ChunkManifest;
   return new Set(
@@ -58,17 +58,28 @@ function windowsOnlySuites(): ReadonlySet<string> {
 
 /**
  * A chunk that selects nothing must fail loudly: a mistyped file list would
- * otherwise report a green run that executed zero assertions.
+ * otherwise report a green run that executed zero assertions. So must a pattern
+ * that, off Windows, names only Windows-only suites: dropping every one of them
+ * would pass a run of nothing.
  */
-function resolveSuiteFiles(testsRoot: string): string[] {
+export function resolveSuiteFiles(
+  testsRoot: string,
+  globs: readonly string[] = requestedGlobs(),
+  platform: NodeJS.Platform = process.platform,
+): string[] {
   const selected = new Set<string>();
-  const windowsOnly = windowsOnlySuites();
-  for (const pattern of requestedGlobs()) {
+  const windowsOnly = windowsOnlySuites(platform);
+  for (const pattern of globs) {
     const matches = globSync(pattern, { cwd: testsRoot });
     if (matches.length === 0) {
       throw new Error(`MOCHA_FILES pattern matched no compiled suite: ${pattern}`);
     }
     const runnable = matches.filter((match) => !windowsOnly.has(match.split(path.sep).join('/')));
+    if (runnable.length === 0) {
+      throw new Error(
+        `MOCHA_FILES pattern selects only Windows-only suites, which run on Windows alone ([NETFX-SCOPE]): ${pattern}`,
+      );
+    }
     for (const match of runnable.filter(matchesShape)) {
       selected.add(match);
     }
diff --git a/src/editors/vscode/src/test/suite/memory-autopilot-e2e.test.ts b/src/editors/vscode/src/test/suite/memory-autopilot-e2e.test.ts
index 24008f04..b9ec41dd 100644
--- a/src/editors/vscode/src/test/suite/memory-autopilot-e2e.test.ts
+++ b/src/editors/vscode/src/test/suite/memory-autopilot-e2e.test.ts
@@ -24,6 +24,7 @@ import {
   clearMemoryDecorations,
 } from '@nimblesite/lsp-profiler-ui/out/src/memory-decorations';
 import { comparablePath } from './test-helpers';
+import { setProfilerSetting } from './profiler-kit';
 import { launchConfigOf, pollUntilResult } from './profiler-ui-helpers';
 import {
   LEAK_LINES,
@@ -50,11 +51,7 @@ const AUTO_CAPTURE_WAIT_MS = 40_000;
 /** Profiler config keys this suite toggles; reset to default after each test. */
 const CONFIG_KEYS = ['autoSnapshotOnPause', 'autoSnapshot', 'autoSnapshotInterval'];
 
-async function setProfilerConfig(key: string, value: unknown): Promise<void> {
-  await vscode.workspace
-    .getConfiguration('sharplsp.profiler')
-    .update(key, value, vscode.ConfigurationTarget.Global);
-}
+const setProfilerConfig = setProfilerSetting;
 
 async function resetProfilerConfig(): Promise<void> {
   for (const key of CONFIG_KEYS) {
diff --git a/src/editors/vscode/src/test/suite/profiler-commands.test.ts b/src/editors/vscode/src/test/suite/profiler-commands.test.ts
index 637ddf68..4b37cd50 100644
--- a/src/editors/vscode/src/test/suite/profiler-commands.test.ts
+++ b/src/editors/vscode/src/test/suite/profiler-commands.test.ts
@@ -81,7 +81,7 @@ suite('Profiler — Command Registration', () => {
   });
 
   test('profiler.list returns empty sessions initially', async () => {
-    const result = await runCommand('sharplsp.lspProfiler.cpu.list');
+    const result = await runCommand('sharplsp.lspProfiler.cpu.list', {});
     assert.ok(result !== undefined, 'profiler.list should return a result');
     assert.ok(result !== null, 'profiler.list should not return null');
 
@@ -94,7 +94,7 @@ suite('Profiler — Command Registration', () => {
   });
 
   test('profiler.list result has correct shape', async () => {
-    const result = await runCommand('sharplsp.lspProfiler.cpu.list');
+    const result = await runCommand('sharplsp.lspProfiler.cpu.list', {});
     assert.ok(result !== undefined, 'profiler.list must return a value');
 
     assert.ok(isRecord(result), 'result must be an object');
diff --git a/src/editors/vscode/src/test/suite/profiler-fixtures.ts b/src/editors/vscode/src/test/suite/profiler-fixtures.ts
new file mode 100644
index 00000000..2bc5f610
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fixtures.ts
@@ -0,0 +1,86 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE]. The .NET programs the profiler
+// suites profile: where each fixture project lives, and its Release build.
+import * as assert from 'node:assert/strict';
+import { spawnSync } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+
+const FIXTURES = path.resolve(__dirname, '../../../../../sharplsp/tests/fixtures');
+/** lspkit's own targets, which prove the engine on every .NET language. */
+const LSPKIT_FIXTURES = path.resolve(__dirname, '../../../../../../lspkit/dotnet/fixtures');
+/** SharpLsp's real-world F# programs: a pricing engine and an event-sourced order ledger. */
+const FSHARP_FIXTURES = path.join(FIXTURES, 'fsharp-profiling');
+
+/** A profiling target: its project folder, target framework and source file. */
+interface FixtureProject {
+  readonly dir: string;
+  readonly framework: string;
+  readonly source: string;
+}
+
+const FIXTURE_PROJECTS: Readonly<Record<string, FixtureProject>> = {
+  ProfileTarget: { dir: FIXTURES, framework: 'net10.0', source: 'Program.cs' },
+  ProfileLeakTarget: { dir: FIXTURES, framework: 'net10.0', source: 'Program.cs' },
+  // F#: records holding union cases leak into a module value ([PROF-TESTING]).
+  HotLeakAppFs: { dir: LSPKIT_FIXTURES, framework: 'net8.0', source: 'Program.fs' },
+  // F# CPU: CSV parsing, recursive discount rules, fuzzy search, route planning, reports.
+  FsPricingEngine: { dir: FSHARP_FIXTURES, framework: 'net10.0', source: 'Program.fs' },
+  // F# memory: event, memoize, mailbox and undo-history leaks in an order ledger.
+  FsOrderLedger: { dir: FSHARP_FIXTURES, framework: 'net10.0', source: 'Program.fs' },
+};
+
+function fixtureProject(name: string): FixtureProject {
+  const project = FIXTURE_PROJECTS[name];
+  assert.ok(project, `unknown profiling fixture ${name}`);
+  return project;
+}
+
+/** `dotnet` from PATH, else the user-local install the test host's PATH may lack. */
+function dotnetExecutable(): string {
+  const candidates = [
+    'dotnet',
+    path.join(os.homedir(), '.dotnet', process.platform === 'win32' ? 'dotnet.exe' : 'dotnet'),
+  ];
+  for (const candidate of candidates) {
+    if (spawnSync(candidate, ['--version'], { encoding: 'utf8' }).status === 0) return candidate;
+  }
+  throw new Error('dotnet SDK not found: install it or put it on PATH');
+}
+
+/** Build a fixture project once (Release) and return its binary. */
+export function buildFixture(name: string): string {
+  const { dir, framework } = fixtureProject(name);
+  const project = path.join(dir, name);
+  const binary = path.join(
+    project,
+    'bin',
+    'Release',
+    framework,
+    process.platform === 'win32' ? `${name}.exe` : name,
+  );
+  if (!fs.existsSync(binary)) {
+    const build = spawnSync(dotnetExecutable(), ['build', '-c', 'Release', '--nologo', '-v', 'q'], {
+      cwd: project,
+      encoding: 'utf8',
+    });
+    assert.equal(
+      build.status,
+      0,
+      `building ${name} failed: ${build.stderr ?? build.error?.message}`,
+    );
+  }
+  assert.ok(fs.existsSync(binary), `${binary} missing after build`);
+  return binary;
+}
+
+/** The source file of a fixture, where hot lines and allocation sites land. */
+export function fixtureSource(name: string): string {
+  const { dir, source } = fixtureProject(name);
+  return path.join(dir, name, source);
+}
+
+/** Another source file of a multi-file fixture project. */
+export function fixtureFile(name: string, file: string): string {
+  return path.join(fixtureProject(name).dir, name, file);
+}
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-artifacts.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-artifacts.ts
new file mode 100644
index 00000000..778ae182
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-artifacts.ts
@@ -0,0 +1,72 @@
+// Tests for [PROF-EXPORT] and [PROF-DOTNET-CPU-SYMBOLS]: real F# profile artifacts.
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import type { ProfileResult } from '@nimblesite/lsp-profiler-ui';
+import { comparablePath } from './test-helpers';
+
+/** True when `file` is the fixture file named `name` (any fixture). */
+export function isFile(file: string | undefined, name: string): boolean {
+  return file !== undefined && path.basename(comparablePath(file)) === comparablePath(name);
+}
+
+interface Speedscope {
+  shared: { frames: { name: string; file?: string; line?: number }[] };
+  profiles: { samples: number[][]; weights: number[] }[];
+}
+
+interface CpuProfile {
+  nodes: { id: number; callFrame: { functionName: string; url: string } }[];
+  samples: number[];
+  timeDeltas: number[];
+  startTime: number;
+  endTime: number;
+}
+
+function readJson(file: string | undefined, what: string): unknown {
+  assert.ok(file !== undefined && fs.existsSync(file), `${what} is written: ${String(file)}`);
+  return JSON.parse(fs.readFileSync(file, 'utf8'));
+}
+
+/** [PROF-EXPORT]: all three artifacts exist, validate, and carry the F# function. */
+export function assertArtifacts(result: ProfileResult, identifier: string, file: string): void {
+  assert.equal(result.exportError, undefined, `no export error: ${result.exportError}`);
+  const speedscope = readJson(result.outputFile, 'the speedscope profile') as Speedscope;
+  const { frames } = speedscope.shared;
+  const keysSeen = frames.map((f) => `${f.name}|${f.file ?? ''}|${f.line ?? ''}`);
+  assert.equal(new Set(keysSeen).size, keysSeen.length, 'frames are deduplicated');
+  assert.ok(
+    frames.some((f) => f.name.includes(identifier) && isFile(f.file, file)),
+    `a speedscope frame names ${identifier} in ${file}`,
+  );
+  assert.ok(speedscope.profiles.length > 0, 'one profile per thread');
+  for (const profile of speedscope.profiles) {
+    assert.equal(profile.samples.length, profile.weights.length, 'samples match weights');
+    assert.ok(
+      profile.weights.every((w) => Number.isFinite(w) && w >= 0),
+      'weights are sane',
+    );
+    assert.ok(
+      profile.samples.flat().every((i) => i >= 0 && i < frames.length),
+      'indices in range',
+    );
+  }
+  const v8 = readJson(result.cpuProfilePath, 'the V8 .cpuprofile') as CpuProfile;
+  const ids = new Set(v8.nodes.map((n) => n.id));
+  assert.equal(v8.samples.length, v8.timeDeltas.length, 'one time delta per sample');
+  assert.ok(
+    v8.samples.every((id) => ids.has(id)),
+    'every sample names a node',
+  );
+  assert.ok(v8.endTime >= v8.startTime, 'time runs forward');
+  assert.ok(
+    v8.nodes.some((n) => n.callFrame.functionName.includes(identifier)),
+    `a .cpuprofile node names ${identifier}`,
+  );
+  assert.ok(result.flamegraphPath !== undefined, 'a flame graph is exported');
+  const svg = fs.readFileSync(result.flamegraphPath, 'utf8');
+  assert.ok(
+    svg.includes('<svg') && svg.includes(identifier),
+    `the flame graph shows ${identifier}`,
+  );
+}
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-corner-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-corner-e2e.test.ts
new file mode 100644
index 00000000..1b609c44
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-corner-e2e.test.ts
@@ -0,0 +1,493 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on real F# processes.
+// SharpLsp contract: docs/specs/PROFILER-SPEC.md.
+// Shared contract: lspkit/docs/specs/LSP-PROFILER-SPEC.md.
+// Each journey cites the specific protocol, CPU, memory and UI requirements it enforces.
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import {
+  appliedMemoryDecorations,
+  lastMemorySnapshot,
+  memoryDashboardState,
+  memoryStatusText,
+} from '@nimblesite/lsp-profiler-ui';
+import type {
+  GcResult,
+  HeapDiff,
+  MemoryStartResult as StartResult,
+  MemoryOutcome,
+  MemoryStep,
+  ObjectList,
+  RefGraph,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  completed,
+  execute,
+  executeError,
+  profilerStore,
+  profilingSuite,
+  stopTracking,
+  trackMemory,
+} from './profiler-kit';
+import {
+  assertEveryShape,
+  assertPaletteDiscipline,
+  assertSitesCoherent,
+  assertStoreCoherent,
+  assertTimelineCoherent,
+  step,
+  snapshotOutcome,
+  diffOutcome,
+  uiSnapshot,
+  CODE,
+} from './profiler-fsharp-soak-kit';
+import {
+  assertAnchored,
+  command,
+  count,
+  endProfiling,
+  isFile,
+  keys,
+  LEDGER,
+  SHAPES,
+  showSources,
+  STOP_MS,
+} from './profiler-fsharp-kit';
+
+suite('F# profiler corner cases — FsOrderLedger, wire first', () => {
+  const live = profilingSuite('profiler-fs-corner-', LEDGER, { stopping: endProfiling });
+
+  test('sessions: memory and CPU coexist on one PID, the second CPU session is ALREADY_PROFILING, and every refused start leaves no session behind', async function () {
+    this.timeout(STOP_MS * 6);
+    const { target } = live;
+    await showSources(LEDGER, ['Ledger.fs', 'Bus.fs']);
+
+    // ── [PROF-MEMORY-SESSION] CPU and memory sessions are independent: both on one PID.
+    const memory = await execute<StartResult>('memory.start', { pid: target.pid });
+    assert.ok(memory.memory_session_id.length > 0, 'a memory session id');
+    assert.equal(memory.mode.kind, 'Direct', '[PROF-MEMORY-MODE] .NET reads its own heap');
+    const cpu = await execute<{ session_id: string }>('cpu.start', { pid: target.pid });
+    assert.ok(cpu.session_id.length > 0, 'a CPU session id on the same PID');
+    assert.notEqual(cpu.session_id, memory.memory_session_id, 'the two ids never collide');
+    assert.equal(
+      (await execute<{ sessions: { pid: number }[] }>('cpu.list', {})).sessions.length,
+      1,
+      'the CPU session is listed while memory also runs',
+    );
+
+    // A memory step still works with a CPU session live on the same program.
+    const after = await command(target, 'place 200');
+    assert.equal(count(after, 'handlers'), 200, 'the ledger grew under both sessions');
+    const snap = await snapshotOutcome(memory.memory_session_id);
+    assert.ok(snap.snapshot.current_bytes > 0, 'the live heap is measured');
+    assert.ok(
+      snap.snapshot.sites.some((site) => isFile(site.file, 'Ledger.fs')),
+      '[PROF-DOTNET-SOURCE] a site anchors in Ledger.fs',
+    );
+
+    // ── [PROF-CPU-START] a second CPU session on the same PID is ALREADY_PROFILING.
+    const second = await executeError('cpu.start', { pid: target.pid });
+    assert.ok(second, 'the second CPU start fails');
+    assert.equal(
+      second.code,
+      CODE.ALREADY_PROFILING,
+      `ALREADY_PROFILING: ${JSON.stringify(second)}`,
+    );
+
+    // ── [PROF-ERRORS] a missing PID is PROCESS_NOT_FOUND, and no session appears.
+    for (const name of ['cpu.start', 'memory.start']) {
+      const missing = await executeError(name, { pid: 2_147_483_647 });
+      assert.ok(missing, `${name} on a missing PID fails`);
+      assert.equal(
+        missing.code,
+        CODE.PROCESS_NOT_FOUND,
+        `[PROF-ERRORS] ${name}: ${JSON.stringify(missing)}`,
+      );
+    }
+    assert.equal(
+      (await execute<{ sessions: unknown[] }>('cpu.list', {})).sessions.length,
+      1,
+      'still exactly the one session — a refused start never stacks one',
+    );
+
+    // ── [PROF-CPU-START] a named runtime that does not recognise the PID is UNSUPPORTED_RUNTIME.
+    const wrongRuntime = await executeError('cpu.start', { pid: target.pid, runtime: 'python' });
+    assert.ok(wrongRuntime, 'naming the wrong runtime fails');
+    assert.equal(
+      wrongRuntime.code,
+      CODE.UNSUPPORTED_RUNTIME,
+      `[PROF-ERRORS] named-runtime refusal: ${JSON.stringify(wrongRuntime)}`,
+    );
+
+    // ── [PROF-MEMORY-START] the real start after the refusals proves nothing leaked.
+    const fresh = await execute<StartResult>('memory.start', { pid: target.pid });
+    assert.ok(fresh.memory_session_id.length > 0, 'a fresh memory session still opens');
+
+    // ── Stop everything; a second stop of the same id is OTHER, not a silent success.
+    completed(
+      await execute<MemoryStep>('memory.stop', { memory_session_id: memory.memory_session_id }),
+    );
+    const again = await executeError('memory.stop', {
+      memory_session_id: memory.memory_session_id,
+    });
+    assert.ok(again, 'stopping a stopped session fails');
+    assert.equal(
+      again.code,
+      CODE.OTHER,
+      `[PROF-ERRORS] unknown session is OTHER: ${JSON.stringify(again)}`,
+    );
+    completed(
+      await execute<MemoryStep>('memory.stop', { memory_session_id: fresh.memory_session_id }),
+    );
+    await execute<unknown>('cpu.stop', { session_id: cpu.session_id });
+    assert.deepEqual(
+      (await execute<{ sessions: unknown[] }>('cpu.list', {})).sessions,
+      [],
+      'no session survives, CPU or memory',
+    );
+    assert.equal(
+      profilerStore().profiler.value.memory,
+      'idle',
+      '[PROF-UI-STATE] wire-only start leaves the UI idle',
+    );
+  });
+
+  test('memory steps: traceback-capped F# sites, exact objectsByType counts, retention roots, growth and release, and Direct mode refuses courier ingest', async function () {
+    this.timeout(STOP_MS * 6);
+    const { target } = live;
+    await command(target, 'release all');
+    const seeded = await command(target, 'place 300');
+    assert.equal(count(seeded, 'orders'), 300, '300 live orders');
+
+    // ── [PROF-MEMORY-START] an explicit traceback_depth caps every site's stack.
+    const start = await execute<StartResult>('memory.start', {
+      pid: target.pid,
+      traceback_depth: 5,
+    });
+    const id = start.memory_session_id;
+    const first = await snapshotOutcome(id);
+    assert.ok(first.snapshot.sites.length > 0, 'the baseline carries sites');
+    for (const site of first.snapshot.sites) {
+      assert.ok(
+        site.traceback.length <= 5,
+        `traceback_depth=5 caps ${site.traceback.length} frames`,
+      );
+      for (const frame of site.traceback) {
+        assert.ok(frame.line >= 1, '[PROF-WIRE] traceback lines are 1-based');
+        assert.ok(frame.file.length > 0, 'a traceback frame names a file');
+      }
+      if (site.line !== undefined) assert.ok(site.line >= 1, '[PROF-WIRE] site lines are 1-based');
+      assert.ok(site.size_bytes > 0 && site.count > 0, 'a site has bytes and objects');
+    }
+    assert.ok(
+      first.timeline.length === 1,
+      '[PROF-MEMORY-TIMELINE] the first snapshot is the first point',
+    );
+    assert.equal(first.trending_upward, false, 'one point cannot trend upward');
+    assert.ok(first.heapprofile_path, '[PROF-MEMORY-HEAPPROFILE] every snapshot exports');
+    assert.ok(fs.existsSync(first.heapprofile_path), 'the exported heap profile exists');
+
+    // ── [PROF-MEMORY-STEP] objectsByType names the type and summarises the heap.
+    const objects = (await step('memory.objectsByType', {
+      memory_session_id: id,
+      type_name: SHAPES.order.type,
+    })) as Extract<MemoryOutcome, { kind: 'Objects' }>;
+    assert.equal(objects.kind, 'Objects', 'objectsByType yields an Objects outcome');
+    const listed: ObjectList = objects.objects;
+    assert.equal(listed.type_name, SHAPES.order.type, 'the requested type is echoed');
+    assert.equal(
+      listed.total_count,
+      count(seeded, 'orders'),
+      'every live F# Order, counted exactly',
+    );
+    assert.ok(listed.total_bytes > 0, 'the type has live bytes');
+    assert.ok(
+      listed.objects.length > 0 && listed.objects.length <= listed.total_count,
+      'a capped slice of the largest objects',
+    );
+    for (const object of listed.objects) {
+      assert.equal(object.type_name, SHAPES.order.type, 'every sample is the requested type');
+      assert.ok(object.size_bytes > 0, 'a sample has a shallow size');
+      assert.ok(object.label.length > 0, 'a sample has a label');
+    }
+    assert.ok(listed.type_summary.length > 0, 'a per-type summary is offered');
+    const sizes = listed.type_summary.map((stat) => stat.size_bytes);
+    assert.deepEqual(
+      sizes,
+      [...sizes].sort((a, b) => b - a),
+      '[PROF-INVARIANTS] types ranked by live bytes, not instance count',
+    );
+
+    for (const shape of Object.values(SHAPES)) {
+      const listedType = (await step('memory.objectsByType', {
+        memory_session_id: id,
+        type_name: shape.type,
+      })) as Extract<MemoryOutcome, { kind: 'Objects' }>;
+      assert.equal(listedType.kind, 'Objects', `objectsByType(${shape.type}) yields Objects`);
+      assert.equal(
+        listedType.objects.type_name,
+        shape.type,
+        `[PROF-MEMORY-STEP] echoes ${shape.type}`,
+      );
+      assert.ok(
+        listedType.objects.objects.every((object) => object.type_name === shape.type),
+        `only ${shape.type} samples`,
+      );
+      assert.ok(listedType.objects.total_bytes >= 0, `${shape.type} bytes are never negative`);
+      assert.equal(
+        listedType.objects.total_count,
+        count(seeded, shape.live),
+        `[PROF-DOTNET-HEAP-MARK] exactly the retained ${shape.type} instances`,
+      );
+      assert.ok(
+        listedType.objects.objects.length <= listedType.objects.total_count,
+        `${shape.type} samples are a subset`,
+      );
+      assert.ok(
+        listedType.objects.type_summary.length > 0,
+        `${shape.type} still summarises the heap`,
+      );
+      const summary = listedType.objects.type_summary.map((stat) => stat.size_bytes);
+      assert.deepEqual(
+        summary,
+        [...summary].sort((a, b) => b - a),
+        'the summary is ranked',
+      );
+      assert.ok(
+        listedType.objects.type_summary.every((stat) => stat.count >= 0 && stat.size_bytes >= 0),
+        'summary numbers are non-negative',
+      );
+      assert.ok(
+        listedType.objects.type_summary.every((stat) => stat.type_name.length > 0),
+        'every summary row names a runtime type',
+      );
+    }
+
+    // ── [PROF-DOTNET-HEAP-GRAPH] references: a graph with locations, edges and cycles.
+    const graph = (await step('memory.references', {
+      memory_session_id: id,
+      type_name: SHAPES.order.type,
+      limit: 20,
+    })) as Extract<MemoryOutcome, { kind: 'Refs' }>;
+    assert.equal(graph.kind, 'Refs', 'references yields a Refs outcome');
+    const refs: RefGraph = graph.graph;
+    assert.ok(refs.nodes.length > 0, 'the retention graph has nodes');
+    assert.ok(refs.nodes.length <= 20, 'the node budget is honoured');
+    assert.ok(refs.edges.length > 0, 'the retention graph has edges');
+    assert.ok(Array.isArray(refs.cycles), 'cycles are reported as paths');
+    assert.equal(typeof refs.truncated, 'boolean', 'truncation is explicit');
+    assert.ok(
+      refs.nodes.some((node) => node.is_target),
+      'the target objects are marked',
+    );
+    assert.ok(
+      refs.truncated || refs.nodes.some((node) => node.is_root),
+      'an untruncated graph reaches a GC root',
+    );
+    for (const node of refs.nodes) {
+      assert.ok(node.depth >= 0, `a node has a depth: ${node.depth}`);
+      assert.ok(node.size_bytes >= 0, 'a node reports bytes');
+      assert.ok(node.label.length > 0, 'a node has a label');
+      assert.ok(node.type_name.length > 0, 'a node names its runtime type');
+    }
+    for (const edge of refs.edges) {
+      const ids = new Set(refs.nodes.map((node) => node.id));
+      assert.ok(ids.has(edge.from) && ids.has(edge.to), 'every edge joins two known nodes');
+    }
+
+    // ── [PROF-MEMORY-STEP] gcCollect reports what it freed and never ends the session.
+    const gc = (await step('memory.gcCollect', { memory_session_id: id })) as Extract<
+      MemoryOutcome,
+      { kind: 'Gc' }
+    >;
+    assert.equal(gc.kind, 'Gc', 'gcCollect yields a Gc outcome');
+    const collected: GcResult = gc.gc;
+    assert.equal(collected.collected, 1, '[PROF-DOTNET-GC] one induced collection was observed');
+    assert.ok(collected.freed_bytes >= 0, 'a freed-bytes total');
+    assert.equal(collected.uncollectable_count, 0, '.NET reports no uncollectable objects');
+    assert.equal(
+      collected.uncollectable.length,
+      collected.uncollectable_count,
+      'the uncollectable details match their count',
+    );
+
+    // ── [PROF-MEMORY-MODE] .NET is Direct: it never parses a courier's payload.
+    const marker = 'not-a-payload-7fd1';
+    const refused = await executeError('memory.ingest', { memory_session_id: id, output: marker });
+    assert.ok(refused, 'garbage is refused');
+    assert.equal(
+      refused.code,
+      CODE.OTHER,
+      '[PROF-ERRORS] a recognised runtime refuses an unsupported backend operation',
+    );
+    assert.ok(
+      refused.message.includes('captures directly'),
+      `[PROF-MEMORY-MODE] the refusal explains Direct capture: ${refused.message}`,
+    );
+
+    // ── Ingesting into an unknown session is an error, never a new session.
+    const unknown = await executeError('memory.ingest', {
+      memory_session_id: 'no-such-memory-session',
+      output: '{}',
+    });
+    assert.ok(unknown, 'an unknown session fails');
+    assert.equal(unknown.code, CODE.OTHER, 'ingest never invents an unknown session');
+    assert.equal((await snapshotOutcome(id)).kind, 'Snapshot', 'the real session still answers');
+
+    // ── [PROF-MEMORY-COMPARE] growth after the baseline, then release, then freed > 0.
+    const more = await command(target, 'place 300');
+    const diff = await diffOutcome(id);
+    assert.ok(diff.diff.total_growth > 0, 'the growth is measured');
+    assert.equal(diff.diff.net_growth, diff.diff.total_growth - diff.diff.total_freed);
+    const orderSite = diff.diff.grown.find((site) => site.type_name === SHAPES.order.type);
+    assert.ok(
+      orderSite,
+      `[PROF-MEMORY-COMPARE] the order site grew: ${JSON.stringify(diff.diff.grown.map((s) => s.type_name))}`,
+    );
+    assert.equal(orderSite.count_diff, count(more, 'orders') - count(seeded, 'orders'));
+    assert.ok(orderSite.size_diff > 0, 'the additional F# records grew in bytes');
+    assert.ok(isFile(orderSite.file, SHAPES.order.file), 'Order growth resolves to Ledger.fs');
+    assert.equal(orderSite.line, SHAPES.order.line, 'Order growth anchors where constructed');
+    const grown = await snapshotOutcome(id);
+    assert.ok(grown.snapshot.current_bytes >= first.snapshot.current_bytes, 'the heap grew');
+    assert.equal(
+      grown.snapshot.sites.find((site) => site.type_name === SHAPES.order.type)?.count,
+      count(more, 'orders'),
+      'the post-diff snapshot retains the exact new F# count',
+    );
+    for (let index = 1; index < grown.timeline.length; index += 1) {
+      const before = grown.timeline[index - 1];
+      const now = grown.timeline[index];
+      assert.ok(before && now && now.elapsed_secs >= before.elapsed_secs, 'time runs forward');
+      assert.ok(before && now && now.peak_bytes >= before.peak_bytes, 'peak never falls');
+    }
+
+    await command(target, 'release all');
+    const freed: HeapDiff = (await diffOutcome(id)).diff;
+    const shrunk = await snapshotOutcome(id);
+    assert.ok(shrunk.snapshot.current_bytes < grown.snapshot.current_bytes, 'the heap shrank');
+    assert.ok(
+      freed.grown.every((site) => site.size_diff > 0),
+      'only growing sites are listed as grown',
+    );
+    assert.ok(
+      freed.freed.every((site) => site.size_diff < 0),
+      'only shrinking sites are listed as freed',
+    );
+    assert.equal(
+      freed.freed.find((site) => site.type_name === SHAPES.order.type)?.count_diff,
+      -count(more, 'orders'),
+      'every unrooted F# Order is freed',
+    );
+    assert.ok(freed.total_freed > 0, 'the released F# records contribute freed bytes');
+    completed(await execute<MemoryStep>('memory.stop', { memory_session_id: id }));
+  });
+});
+
+suite('F# profiler corner cases — FsOrderLedger through the dashboard', () => {
+  const live = profilingSuite('profiler-fs-corner-ui-', LEDGER, { stopping: endProfiling });
+
+  test('the dashboard corner cases: a real .heapprofile, generation bytes kept apart from collection counts, a flat second snapshot, and every key back to false after Track → Snapshot → Stop', async function () {
+    this.timeout(STOP_MS * 6);
+    const { target } = live;
+    await showSources(LEDGER, ['Ledger.fs', 'Quotes.fs']);
+    const seeded = await command(target, 'quote 250');
+    await trackMemory(target.pid);
+    assert.equal(
+      profilerStore().profiler.value.memory,
+      'active',
+      '[PROF-UI-STATE] the store says tracking',
+    );
+
+    // ── [PROF-MEMORY-HEAPPROFILE] the .heapprofile is real V8 JSON.
+    const first = await uiSnapshot();
+    assert.ok(
+      fs.existsSync(first.heapProfilePath),
+      `[PROF-MEMORY-HEAPPROFILE] ${first.heapProfilePath}`,
+    );
+    const profile = JSON.parse(fs.readFileSync(first.heapProfilePath, 'utf8')) as {
+      head?: unknown;
+      samples?: unknown;
+    };
+    assert.ok(profile.head !== undefined, 'the profile has a call-tree root');
+    assert.ok(Array.isArray(profile.samples), 'the profile has samples');
+    assert.ok((profile.samples as unknown[]).length > 0, 'the live F# heap exports samples');
+
+    // ── [PROF-UI-MEMORY] generation bytes are not collection counts.
+    assert.deepEqual(first.gcCounts, [], 'counts are never presented as generation bytes');
+    assert.ok(first.generationSizes, 'the .NET runtime reports generation bytes');
+    assert.deepEqual(
+      first.generationSizes.map((region) => region.name),
+      ['Gen 0', 'Gen 1', 'Gen 2', 'LOH', 'POH'],
+      'all five .NET heap regions are named',
+    );
+    for (const region of first.generationSizes) {
+      assert.ok(region.name.length > 0, 'a region has a runtime label');
+      assert.ok(region.size >= 0, 'a region size is a byte count');
+    }
+    assert.equal(memoryDashboardState()?.title, 'SharpLsp Memory Dashboard');
+    assertAnchored(first, SHAPES.quote, 250);
+    assertSitesCoherent(first);
+    assertTimelineCoherent(first);
+    assertPaletteDiscipline();
+    assertStoreCoherent();
+    assertEveryShape(first, seeded);
+    for (const site of first.topAllocations) {
+      assert.ok((site.typeName ?? '').length > 0, 'every top site names its runtime type');
+      assert.ok(
+        !isFile(site.file, 'Domain.fs'),
+        '[PROF-DOTNET-SOURCE] built where it is allocated',
+      );
+    }
+
+    // ── [PROF-MEMORY-TIMELINE] a second snapshot with no growth still adds one point and
+    // never runs backwards; nothing is invented in between.
+    const second = await uiSnapshot(first);
+    assert.equal(second.timeline.length, 2, 'two snapshots, two points');
+    const [p1, p2] = second.timeline;
+    assert.ok(p1 && p2, 'both points exist');
+    assert.ok(p2.timestamp >= p1.timestamp, '[PROF-MEMORY-TIMELINE] time runs forward');
+    assert.ok(p2.peakMemory >= p1.peakMemory, 'peak never falls');
+    assert.ok(second.peakMemory >= second.currentMemory, 'peak is at least current');
+    assert.ok(second.gcObjects > 0, 'live objects are counted');
+    assert.equal(
+      second.topAllocations.filter((site) => site.typeName === SHAPES.quote.type).length,
+      1,
+      'one site per type, never a duplicate row',
+    );
+    assertAnchored(second, SHAPES.quote, count(seeded, 'quotes'));
+    assert.equal(
+      lastMemorySnapshot()?.snapshotId,
+      second.snapshotId,
+      'the second snapshot is current',
+    );
+
+    // ── [PROF-UI-MEMORY] stopping clears the dashboard's claim and every decoration.
+    await stopTracking();
+    assert.equal(
+      profilerStore().profiler.value.memory,
+      'idle',
+      '[PROF-UI-STATE] the store says idle',
+    );
+    assert.equal(memoryStatusText(), undefined, 'the status bar hides');
+    assert.deepEqual(appliedMemoryDecorations(), [], 'no memory decoration survives the stop');
+    assert.deepEqual(keys(), {
+      profiling: false,
+      cpuBusy: false,
+      memoryTracking: false,
+      memoryBusy: false,
+      profilerBusy: false,
+    });
+
+    // ── [PROF-UI-STATE] the session clears; [PROF-UI-MEMORY] the rendered report stays readable.
+    assert.equal(lastMemorySnapshot(), undefined, 'no stale session snapshot survives stop');
+    assert.ok(
+      memoryDashboardState()?.html.includes(SHAPES.quote.type),
+      'the F# report stays readable',
+    );
+    const stopped = await executeError('memory.snapshot', {
+      memory_session_id: second.memorySessionId,
+    });
+    assert.ok(stopped, 'the stopped session has no live snapshot');
+    assert.ok(stopped.code !== 0, 'a stopped session cannot snapshot');
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-cpu-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-cpu-e2e.test.ts
new file mode 100644
index 00000000..6e4c97ce
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-cpu-e2e.test.ts
@@ -0,0 +1,409 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on F#. See docs/specs/PROFILER-SPEC.md#PROFILER-SHARED-LIBRARY-VSCODE
+//
+// CPU profiling of a real F# program, FsPricingEngine: a retail checkout backend
+// whose workloads are the F# shapes a profiler must name and place —
+//   - active patterns over CSV rows;
+//   - a recursive discount-rule engine that matches every union case;
+//   - Levenshtein search over a 2D array, ranked through a List.sortBy closure;
+//   - Dijkstra over an immutable Set and Map with an inner `let rec`;
+//   - seq expressions and a task {} builder.
+// Every journey starts where a user starts: the program's row in the processes
+// panel. It then reads back everything the editor shows: the live chrome, the
+// gating keys, the heat map and its tiers, the results panel, and the three
+// exported artifacts. lspkit's [PROF-CPU-START], [PROF-CPU-SNAPSHOT],
+// [PROF-CPU-PROGRESS], [PROF-UI-CPU], [PROF-UI-HEATMAP], [PROF-EXPORT].
+import * as assert from 'node:assert/strict';
+import * as vscode from 'vscode';
+import { lastProfileResult, recordedOperations } from '@nimblesite/lsp-profiler-ui';
+import {
+  disposeFlamegraphPanel,
+  flamegraphPanelOpen,
+} from '@nimblesite/lsp-profiler-ui/out/src/profiler-flamegraph-html';
+import type { ProfileSessionList } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  execute,
+  executeError,
+  profilerStore,
+  profilingSuite,
+  setProfilerSetting,
+  stopProfiling,
+  uiCommand,
+  waitFor,
+} from './profiler-kit';
+import {
+  assertArtifacts,
+  assertCpuIdle,
+  assertCpuLive,
+  assertHeatMap,
+  assertIdleRow,
+  assertRanked,
+  assertResultsPanel,
+  awaitLiveProgress,
+  command,
+  count,
+  endProfiling,
+  ENGINE,
+  heatOn,
+  hotFunction,
+  processRow,
+  profileRow,
+  showSources,
+  type Span,
+  STOP_MS,
+  within,
+} from './profiler-fsharp-kit';
+
+const SAMPLE_MS = 3_000;
+
+/** One F# workload of FsPricingEngine and where its time must land. */
+interface Workload {
+  readonly command: string;
+  readonly shape: string;
+  /** Functions that must be hot, in `span.file`. The first names the artifacts. */
+  readonly identifiers: readonly string[];
+  /** The lines its hot lines fall in. */
+  readonly span: Span;
+}
+
+const WORKLOADS: readonly Workload[] = [
+  {
+    command: 'parse',
+    shape: 'active patterns over 2,000 CSV rows',
+    identifiers: ['parseAll', 'parseLine'],
+    span: { file: 'Csv.fs', first: 14, last: 39 },
+  },
+  {
+    command: 'price',
+    shape: 'a recursive discount-rule engine matching every union case',
+    identifiers: ['basketTotal', 'applyRules'],
+    span: { file: 'Pricing.fs', first: 10, last: 68 },
+  },
+  {
+    command: 'search',
+    shape: 'Levenshtein over a 2D array, ranked through a List.sortBy closure',
+    identifiers: ['rank', 'distance'],
+    span: { file: 'Search.fs', first: 10, last: 28 },
+  },
+  {
+    command: 'route',
+    shape: 'Dijkstra over an immutable Set and Map with an inner let rec',
+    identifiers: ['shortestPath'],
+    span: { file: 'Routing.fs', first: 29, last: 47 },
+  },
+  {
+    command: 'report',
+    shape: 'seq expressions grouped and summed, and a task {} builder',
+    identifiers: ['dailyTotals'],
+    span: { file: 'Reports.fs', first: 13, last: 47 },
+  },
+];
+
+/**
+ * Ground truth: the four pure-CPU stages of a mixed run, each entered through
+ * exactly one F# function, whose time FsPricingEngine measures itself and
+ * reports as `<stage>_us`. The report stage is left out: its task {} awaits
+ * Task.Yield, so its wall time includes waiting, which a CPU sampler rightly
+ * does not count.
+ */
+const GROUND_TRUTH = [
+  { stage: 'parse', identifier: 'parseAll', file: 'Csv.fs' },
+  { stage: 'price', identifier: 'basketTotal', file: 'Pricing.fs' },
+  { stage: 'search', identifier: 'rank', file: 'Search.fs' },
+  { stage: 'route', identifier: 'shortestPath', file: 'Routing.fs' },
+] as const;
+/** A stage that took at least this share of the measured time must be found. */
+const MAJOR_SHARE = 0.15;
+/** How far a sampled share may sit from the measured one. */
+const SHARE_TOLERANCE = 0.15;
+
+function pct(share: number): string {
+  return `${(share * 100).toFixed(1)}%`;
+}
+
+async function sessions(): Promise<ProfileSessionList['sessions']> {
+  return (await execute<ProfileSessionList>('cpu.list', {})).sessions;
+}
+
+async function delay(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** Both progress notifications opened and closed in order since `from`. */
+function assertProgressClosed(from: number): void {
+  const ops = recordedOperations().slice(from);
+  for (const title of ['SharpLsp: Starting CPU profiler', 'SharpLsp: Stopping profiler']) {
+    const begin = ops.indexOf(`begin:${title}`);
+    assert.ok(begin !== -1, `"${title}" shows progress: ${ops.join(' | ')}`);
+    assert.ok(ops.indexOf(`end:${title}`, begin) > begin, `"${title}" closes`);
+  }
+}
+
+suite('F# CPU profiling — FsPricingEngine, one F# shape at a time', () => {
+  const live = profilingSuite('profiler-fs-cpu-', ENGINE);
+  teardown(async function () {
+    this.timeout(STOP_MS * 2);
+    await endProfiling();
+    await setProfilerSetting('showInlineHeatMap', undefined);
+    disposeFlamegraphPanel();
+    await command(live.target, 'idle');
+  });
+
+  for (const workload of WORKLOADS) {
+    test(`${workload.shape}: Profile CPU from the F# program's row → live chrome → UI snapshot → stop → heat map, results panel and artifacts name ${workload.identifiers.join(', ')}`, async function () {
+      this.timeout(STOP_MS * 3);
+      const { target } = live;
+      const started = await command(target, `run ${workload.command}`);
+      await showSources(ENGINE, [workload.span.file, 'Program.fs']);
+
+      // The row the user clicks, before anything runs.
+      const row = await processRow(target.pid);
+      assertIdleRow(row, target.pid, ENGINE);
+      assert.equal(profilerStore().profiler.value.cpu, 'idle', 'nothing profiles yet');
+
+      // Click Profile CPU: the chrome, the keys and the wire agree on one session.
+      const opsBefore = recordedOperations().length;
+      const sessionId = await profileRow(row);
+      await assertCpuLive(target.pid);
+      const top = await awaitLiveProgress();
+      assert.ok(top.length > 0, 'the live readout names a top function');
+      const listed = (await sessions()).filter((s) => s.pid === target.pid);
+      assert.equal(listed.length, 1, 'exactly one server session for the program');
+      const [mine] = listed;
+      assert.ok(mine);
+      assert.equal(mine.session_id, sessionId, 'the UI drives the listed session');
+      assert.equal(mine.runtime, 'dotnet');
+      assert.ok(mine.runtime_version.length > 0, 'the runtime version is reported');
+      assert.ok(!Number.isNaN(Date.parse(mine.started_at)), `RFC 3339 start: ${mine.started_at}`);
+      assert.ok(mine.sample_count > 0, `the live count is real: ${mine.sample_count}`);
+
+      // A second click and a second wire start are both refused; the session survives.
+      await vscode.commands.executeCommand(uiCommand('profileProcess'), row);
+      assert.equal(profilerStore().profiler.value.cpuSessionId, sessionId, 'the click is a no-op');
+      const refused = await executeError('cpu.start', { pid: target.pid });
+      assert.equal(refused?.code, -32004, `ALREADY_PROFILING: ${refused?.message}`);
+      assert.equal((await sessions()).filter((s) => s.pid === target.pid).length, 1);
+
+      // A UI snapshot reports the F# code so far and the session keeps running.
+      await vscode.commands.executeCommand(uiCommand('profileSnapshot'));
+      const snapshot = await waitFor(
+        () => lastProfileResult(),
+        (result) => result?.sessionId === sessionId,
+        STOP_MS,
+        'the snapshot result of this session',
+      );
+      assert.ok(snapshot);
+      assertRanked(snapshot);
+      for (const identifier of workload.identifiers) {
+        assert.ok(
+          hotFunction(snapshot, identifier, workload.span.file),
+          `the snapshot already names ${identifier} in ${workload.span.file}: ${snapshot.hotFunctions.map((f) => f.name).join(', ')}`,
+        );
+      }
+      assert.equal(profilerStore().profiler.value.cpu, 'active', 'a snapshot never ends it');
+      await delay(SAMPLE_MS);
+
+      // Stop: the session ends everywhere, and the result covers the whole run.
+      await stopProfiling(STOP_MS);
+      await assertCpuIdle(target.pid);
+      assert.deepEqual(
+        (await sessions()).filter((s) => s.pid === target.pid),
+        [],
+        'the stopped session leaves the list',
+      );
+      const result = lastProfileResult();
+      assert.ok(result);
+      assert.equal(result.sessionId, sessionId, 'the stop result is this session’s');
+      assert.ok(
+        result.totalSamples > snapshot.totalSamples,
+        `sampling went on past the snapshot: ${result.totalSamples} > ${snapshot.totalSamples}`,
+      );
+      assertRanked(result);
+      for (const identifier of workload.identifiers) {
+        const fn = hotFunction(result, identifier, workload.span.file);
+        assert.ok(fn, `${identifier} is hot in ${workload.span.file}`);
+        assert.ok((fn.line ?? 0) >= 1, `${identifier} carries its F# line`);
+      }
+      assert.ok(
+        result.hotLines.some((line) => within(workload.span, line.file, line.line)),
+        `a hot line sits in ${workload.span.file} ${workload.span.first}-${workload.span.last}`,
+      );
+      assert.equal(
+        heatOn('Program.fs').length > 0,
+        result.hotLines.some((l) => l.file.endsWith('Program.fs')),
+        'Program.fs is painted exactly when it has hot lines',
+      );
+      assertHeatMap(result, workload.span);
+      assertResultsPanel(result, workload.identifiers);
+      assertArtifacts(result, workload.identifiers[0] ?? '', workload.span.file);
+      assertProgressClosed(opsBefore);
+
+      // Closing the panel never strands the result: Show Profile Results re-opens it.
+      disposeFlamegraphPanel();
+      assert.equal(flamegraphPanelOpen(), false);
+      await vscode.commands.executeCommand(uiCommand('profileShowResults'));
+      await waitFor(
+        () => flamegraphPanelOpen(),
+        (open) => open,
+        5_000,
+        'the panel re-opens',
+      );
+      assertResultsPanel(result, workload.identifiers);
+
+      // Attaching was never invasive: the program kept working throughout.
+      const after = await command(target, 'stats');
+      assert.ok(
+        count(after, 'iterations') > count(started, 'iterations'),
+        `the F# program kept running under the profiler: ${JSON.stringify(after)}`,
+      );
+    });
+  }
+
+  test('one session, two phases: parse → snapshot → switch to search → snapshot → stop paints both files; heat map off, then a mixed run paints every module', async function () {
+    this.timeout(STOP_MS * 5);
+    const { target } = live;
+    const [parse, search, route] = WORKLOADS.filter((w) =>
+      ['parse', 'search', 'route'].includes(w.command),
+    );
+    assert.ok(parse && search && route);
+    await command(target, 'run parse');
+    await showSources(ENGINE, ['Csv.fs', 'Search.fs']);
+    const sessionId = await profileRow(await processRow(target.pid));
+    await awaitLiveProgress();
+
+    // Phase one: only CSV parsing has run, so search cannot be hot yet.
+    await vscode.commands.executeCommand(uiCommand('profileSnapshot'));
+    const first = await waitFor(
+      () => lastProfileResult(),
+      (r) => r?.sessionId === sessionId,
+      STOP_MS,
+      'phase-one snapshot',
+    );
+    assert.ok(first && hotFunction(first, 'parseAll', 'Csv.fs'), 'parsing is hot in phase one');
+    assert.equal(hotFunction(first, 'distance', 'Search.fs'), undefined, 'search never ran yet');
+
+    // Phase two: the same session sees the switch.
+    await command(target, 'run search');
+    await delay(SAMPLE_MS * 2);
+    await vscode.commands.executeCommand(uiCommand('profileSnapshot'));
+    const second = await waitFor(
+      () => lastProfileResult(),
+      (r) =>
+        r !== first &&
+        r?.sessionId === sessionId &&
+        hotFunction(r, 'distance', 'Search.fs') !== undefined,
+      STOP_MS,
+      'phase-two snapshot naming distance',
+    );
+    assert.ok(second);
+    assert.ok(second.totalSamples > first.totalSamples, 'the second snapshot covers more');
+    assert.ok(hotFunction(second, 'parseAll', 'Csv.fs'), 'phase one is still in the session');
+    await stopProfiling(STOP_MS);
+    const both = lastProfileResult();
+    assert.ok(both && both.totalSamples >= second.totalSamples, 'the stop covers both phases');
+    assertHeatMap(both, parse.span);
+    assertHeatMap(both, search.span);
+
+    // Heat map off: the result still lands in the panel, but no tint is painted.
+    await setProfilerSetting('showInlineHeatMap', false);
+    await command(target, 'run route');
+    await showSources(ENGINE, ['Routing.fs']);
+    const routed = await profileRow(await processRow(target.pid));
+    await awaitLiveProgress();
+    await stopProfiling(STOP_MS);
+    const quiet = lastProfileResult();
+    assert.ok(quiet?.sessionId === routed, 'a second session on the same program');
+    assert.ok(hotFunction(quiet, 'shortestPath', 'Routing.fs'), 'routing is hot');
+    assert.deepEqual(heatOn('Routing.fs'), [], 'the setting turns the tint off');
+    assertResultsPanel(quiet, ['shortestPath']);
+
+    // Give every workload a full sampling window in ONE session. A mixed loop's
+    // stages have unequal cost; merely executing a stage does not make it a 2% hotspot.
+    await setProfilerSetting('showInlineHeatMap', true);
+    await command(target, 'run mixed');
+    const files = WORKLOADS.map((w) => w.span.file);
+    await showSources(ENGINE, files);
+    await profileRow(await processRow(target.pid));
+    await awaitLiveProgress();
+    for (const workload of WORKLOADS) {
+      await command(target, `run ${workload.command}`);
+      await delay(SAMPLE_MS);
+    }
+    await stopProfiling(STOP_MS);
+    const mixed = lastProfileResult();
+    assert.ok(mixed);
+    assertRanked(mixed);
+    for (const workload of WORKLOADS) {
+      const identifier = workload.identifiers[0] ?? '';
+      assert.ok(hotFunction(mixed, identifier, workload.span.file), `mixed: ${identifier} is hot`);
+      assertHeatMap(mixed, workload.span);
+    }
+    assertResultsPanel(
+      mixed,
+      WORKLOADS.map((w) => w.identifiers[0] ?? ''),
+    );
+    await command(target, 'idle');
+  });
+
+  test('the profiler tells the truth about four sustained F# workloads: sampled shares match the fixture’s Stopwatch and materially different stages rank in the same order', async function () {
+    this.timeout(STOP_MS * 3);
+    const { target } = live;
+    await command(target, 'run parse');
+    await showSources(ENGINE, ['Csv.fs', 'Search.fs', 'Routing.fs']);
+    await profileRow(await processRow(target.pid));
+    await awaitLiveProgress();
+    // [PROF-AGGREGATION-LOGIC]: shares are of the profiled window, so the Stopwatch
+    // window opens once samples flow, never while the profiler is still attaching.
+    const before = await command(target, 'stats');
+    for (const stage of GROUND_TRUTH) {
+      await command(target, `run ${stage.stage}`);
+      await delay(SAMPLE_MS);
+    }
+    await stopProfiling(STOP_MS);
+    const after = await command(target, 'stats');
+    const result = lastProfileResult();
+    assert.ok(result);
+    assertRanked(result);
+
+    // The four pure-CPU stages, each entered through exactly one F# function.
+    const stages = GROUND_TRUTH.map((stage) => ({
+      ...stage,
+      micros: count(after, `${stage.stage}_us`) - count(before, `${stage.stage}_us`),
+      sampled: hotFunction(result, stage.identifier, stage.file)?.percentage ?? 0,
+    }));
+    const measuredTotal = stages.reduce((sum, s) => sum + s.micros, 0);
+    const sampledTotal = stages.reduce((sum, s) => sum + s.sampled, 0);
+    assert.ok(measuredTotal > 0, `the program measured its own stages: ${JSON.stringify(after)}`);
+    assert.ok(sampledTotal > 0, 'the profiler attributed samples to the stages');
+    const shares = stages.map((s) => ({
+      ...s,
+      truth: s.micros / measuredTotal,
+      seen: s.sampled / sampledTotal,
+    }));
+    const major = shares.filter((s) => s.truth >= MAJOR_SHARE);
+    assert.ok(major.length >= 2, `at least two stages carry real time: ${JSON.stringify(shares)}`);
+    for (const stage of shares) {
+      assert.ok(stage.micros > 0, `the fixture actually exercised ${stage.identifier}`);
+      assert.ok(
+        Math.abs(stage.seen - stage.truth) <= SHARE_TOLERANCE,
+        `${stage.identifier}: sampled ${pct(stage.seen)}, measured ${pct(stage.truth)}`,
+      );
+    }
+    for (const stage of major) {
+      assert.ok(stage.sampled > 0, `${stage.identifier} took ${pct(stage.truth)} and must be hot`);
+      assert.ok(
+        Math.abs(stage.seen - stage.truth) <= SHARE_TOLERANCE,
+        `${stage.identifier}: the profiler says ${pct(stage.seen)}, the Stopwatch ${pct(stage.truth)}`,
+      );
+    }
+    const ranked = [...major].sort((a, b) => b.truth - a.truth);
+    for (const [index, higher] of ranked.entries()) {
+      const lower = ranked[index + 1];
+      if (lower !== undefined && higher.truth >= lower.truth * 1.5) {
+        assert.ok(
+          higher.sampled > lower.sampled,
+          `${higher.identifier} (${pct(higher.truth)}) must outrank ${lower.identifier} (${pct(lower.truth)})`,
+        );
+      }
+    }
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-e2e.test.ts
index 66b5b803..30f1ecfb 100644
--- a/src/editors/vscode/src/test/suite/profiler-fsharp-e2e.test.ts
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-e2e.test.ts
@@ -46,6 +46,16 @@ const SPIN_LINES = { first: 26, last: 31 };
 const RECORD = { type: 'HotLeakAppFs.LeakedPayload', line: 23 };
 const UNION_CASE = { type: 'HotLeakAppFs.PayloadKind+Small', line: 21 };
 const GENERIC_RECORD = { type: 'HotLeakAppFs.Tagged`1[System.Int32]', line: 22 };
+/** The rest of lspkit's F# heap zoo, each at the line that constructs it. */
+const ORDER = { type: 'HotLeakAppFs.Order', line: 77 };
+const ORDER_LINE = { type: 'HotLeakAppFs.OrderLine', line: 75 };
+const CUSTOMER = { type: 'HotLeakAppFs.CustomerId', line: 73 };
+const EXPRESS = { type: 'HotLeakAppFs.Priority+Express', line: 76 };
+const QUOTE = { type: 'HotLeakAppFs.Quote', line: 82 };
+const NODE = { type: 'HotLeakAppFs.Node', line: 88 };
+/** The subscription closure F# builds for `Event.Publish.Add`. */
+const CLOSURE_LINE = 97;
+type DashboardSite = NonNullable<ReturnType<typeof lastMemorySnapshot>>['topAllocations'][number];
 
 const inSpin = (line: number): boolean => line >= SPIN_LINES.first && line <= SPIN_LINES.last;
 const isProgramFs = (file: string | undefined): boolean => file?.endsWith('Program.fs') ?? false;
@@ -140,6 +150,99 @@ suite('F# profiling — real end-to-end', () => {
     assert.equal(memoryStatusText(), undefined, 'the status bar hides once idle');
   });
 
+  test('the F# heap zoo: grow orders, quotes, closures, a cycle and arrays → every shape anchors at its constructing line, arrays never do → the growing record reaches Low → stop clears the track', async function () {
+    this.timeout(STEP_MS * 3);
+    const { target } = live;
+    // A fresh, deterministic heap: no background growth, then one shape at a time.
+    for (const line of ['work off', 'release all', 'payload 100', 'grow 200', 'blob 4']) {
+      const reply = await target.send(line);
+      assert.ok(reply.startsWith(`OK ${line}`), `the fixture accepts "${line}": ${reply}`);
+    }
+    await openSource(fixtureSource(FIXTURE));
+    await trackMemory(target.pid);
+    await vscode.commands.executeCommand(uiCommand('memorySnapshot'));
+    const snapshot = await waitFor(
+      () => lastMemorySnapshot(),
+      (snap) => snap?.topAllocations.some((site) => site.typeName === ORDER.type) ?? false,
+      STEP_MS,
+      'a snapshot naming the F# order record',
+    );
+    assert.ok(snapshot, 'the dashboard holds the snapshot');
+    for (const { type, line } of [
+      RECORD,
+      UNION_CASE,
+      GENERIC_RECORD,
+      ORDER,
+      ORDER_LINE,
+      CUSTOMER,
+      EXPRESS,
+      QUOTE,
+      NODE,
+    ]) {
+      const foundSite: DashboardSite | undefined = snapshot.topAllocations.find(
+        (entry) => entry.typeName === type,
+      );
+      assert.ok(
+        foundSite,
+        `${type} is a site: ${snapshot.topAllocations.map((entry) => entry.typeName).join(', ')}`,
+      );
+      assert.equal(foundSite.line, line, `${type} anchors where the program constructs it`);
+      assert.ok(isProgramFs(foundSite.file), `${type} resolves to Program.fs: ${foundSite.file}`);
+      assert.ok(foundSite.size > 0, `${type} has bytes`);
+      assert.ok(foundSite.count > 0, `${type} has live instances`);
+    }
+    assert.equal(
+      snapshot.topAllocations.find((site) => site.typeName === ORDER.type)?.count,
+      200,
+      'every live order is counted',
+    );
+    assert.equal(
+      snapshot.topAllocations.find((site) => site.typeName === NODE.type)?.count,
+      202,
+      'the cycle plus one node per order',
+    );
+    assert.ok(
+      snapshot.topAllocations.some(
+        (site) => site.line === CLOSURE_LINE && site.typeName?.startsWith('HotLeakAppFs.Shapes'),
+      ),
+      'the event-handler closure is a site at its own line',
+    );
+    // [PROF-DOTNET-SOURCE] an array is the runtime's own type and is never anchored.
+    for (const type of ['System.Byte[]', 'HotLeakAppFs.Order[]', 'HotLeakAppFs.LeakedPayload[]']) {
+      const foundSite: DashboardSite | undefined = snapshot.topAllocations.find(
+        (entry) => entry.typeName === type,
+      );
+      assert.ok(foundSite, `${type} is a site`);
+      assert.equal(foundSite.file, undefined, `${type} has no source file`);
+      assert.equal(foundSite.line, undefined, `${type} has no line`);
+    }
+    const painted = appliedMemoryDecorations().filter((entry) => isProgramFs(entry.file));
+    for (const { line } of [ORDER, ORDER_LINE, CUSTOMER, EXPRESS, QUOTE, NODE]) {
+      assert.ok(
+        painted.some((entry) => entry.line === line),
+        `the memory track paints line ${line}`,
+      );
+    }
+    assert.ok(
+      memoryDashboardState()?.html.includes('HotLeakAppFs.Order'),
+      'the dashboard names the F# record',
+    );
+
+    await target.send('payload 100');
+    await vscode.commands.executeCommand(uiCommand('memoryDiff'));
+    const leaks = await waitFor(
+      () => embeddedLeaks(memoryDashboardState()?.html ?? ''),
+      (found) => found.length > 0,
+      STEP_MS,
+      'suspected leaks after the growth',
+    );
+    const record = leaks.find((leak) => leak.typeName === RECORD.type);
+    assert.ok(record, `the growing F# record is a leak: ${JSON.stringify(leaks)}`);
+    assert.equal(record.confidence, 'low', '[PROF-MEMORY-CONFIDENCE] one growth is Low');
+    await stopTracking();
+    assert.deepEqual(appliedMemoryDecorations(), [], 'stop clears the memory track');
+  });
+
   test('the leaked F# record is held by the module value `static items`, and its union case is found by its full name', async function () {
     this.timeout(STEP_MS * 3);
     const { target } = live;
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-kit.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-kit.ts
new file mode 100644
index 00000000..aae3377c
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-kit.ts
@@ -0,0 +1,490 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on F#. See docs/specs/PROFILER-SPEC.md#PROFILER-SHARED-LIBRARY-VSCODE
+//
+// The F# profiler suites drive SharpLsp's two real-world F# programs
+// (src/sharplsp/tests/fixtures/fsharp-profiling) through the extension's own UI
+// over the real LSP. This kit owns what every F# suite shares:
+//   - the fixtures' stdin protocol and the exact live counts they report;
+//   - the exact source lines each F# shape lands on;
+//   - the spec checks every suite repeats on what the editor shows: the live
+//     chrome, the heat map, the results panel, the exported artifacts and the
+//     memory track (lspkit's [PROF-UI-CPU], [PROF-UI-HEATMAP], [PROF-EXPORT],
+//     [PROF-UI-MEMORY], [PROF-AGGREGATION-THRESHOLD]).
+import * as assert from 'node:assert/strict';
+import * as path from 'node:path';
+import * as vscode from 'vscode';
+import {
+  appliedMemoryDecorations,
+  appliedProfileDecorations,
+  contextKeyValues,
+  flamegraphPanelState,
+  processesViewState,
+  profilerStatusText,
+  type ProcessTreeItem,
+  type ProfileResult,
+} from '@nimblesite/lsp-profiler-ui';
+import type { AppliedDecoration } from '@nimblesite/lsp-profiler-ui/out/src/profiler-decorations';
+import type { MemoryDashboardSnapshot } from '@nimblesite/lsp-profiler-ui/out/src/memory-dashboard';
+import type {
+  HeapDiff,
+  MemoryStep,
+  ProfileSessionList,
+  SuspectedLeak,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  completed,
+  execute,
+  fixtureFile,
+  profilerStore,
+  rowOf,
+  stopProfiling,
+  stopTracking,
+  type Target,
+  tooltipText,
+  uiCommand,
+  waitFor,
+} from './profiler-kit';
+import { isFile } from './profiler-fsharp-artifacts';
+export { isFile, assertArtifacts } from './profiler-fsharp-artifacts';
+import { LSP_RESPONSE_MS, PROCESS_START_MS } from './test-timeouts';
+
+export const ENGINE = 'FsPricingEngine';
+export const LEDGER = 'FsOrderLedger';
+
+/** The CPU heat palette, critical to cool ([PROF-UI-WEBVIEW]: orange/amber for CPU). */
+export const CPU_PALETTE = ['#e8500a', '#f97316', '#fbbf24', '#4a5468'];
+/** The purple memory-allocation palette ([PROF-UI-WEBVIEW]: purple for memory). */
+export const MEMORY_PALETTE = ['#c084fc', '#a78bfa', '#8b5cf6', '#7c3aed'];
+/** The leak-confidence palette ([PROF-UI-WEBVIEW]: red for leaks). */
+export const LEAK_PALETTE = ['#ef4444', '#f87171', '#fb923c', '#a78bfa'];
+/** How long one profiler step may take: an attach, a stop with symbolization, a heap capture. */
+export const STOP_MS = 90_000;
+/** A leak badge names its confidence in its after-line text. */
+const BADGE = /\b(LOW|MEDIUM|HIGH|DEFINITE)\b/;
+
+// ── The fixtures' stdin protocol ─────────────────────────────────────────────
+
+/** The exact live counts a fixture reports after every command. */
+export type Counts = Readonly<Record<string, number>>;
+
+/** Send `line`; assert the fixture accepted it; return the integer counts it reported. */
+export async function command(target: Target, line: string): Promise<Counts> {
+  const reply = await target.send(line);
+  assert.ok(reply.startsWith(`OK ${line}`), `the fixture must accept "${line}": ${reply}`);
+  const pairs = reply
+    .split(' ')
+    .filter((word) => word.includes('='))
+    .map((word) => word.split('=') as [string, string])
+    .filter(([, value]) => Number.isInteger(Number(value)));
+  return Object.fromEntries(pairs.map(([key, value]) => [key, Number(value)]));
+}
+
+/** One count from a reply; fails when the fixture did not report it. */
+export function count(counts: Counts, key: string): number {
+  const value = counts[key];
+  assert.ok(value !== undefined, `the reply carries ${key}: ${JSON.stringify(counts)}`);
+  return value;
+}
+
+// ── Where each F# shape lands ────────────────────────────────────────────────
+
+/** A 1-based line range inside one fixture file. */
+export interface Span {
+  readonly file: string;
+  readonly first: number;
+  readonly last: number;
+}
+
+/** True when `line` of `file` falls inside `span`. */
+export function within(span: Span, file: string | undefined, line: number): boolean {
+  return isFile(file, span.file) && line >= span.first && line <= span.last;
+}
+
+/** The absolute path of a fixture file, as the editor and the server name it. */
+export function sourceOf(fixture: string, file: string): string {
+  return fixtureFile(fixture, file);
+}
+
+/** Open fixture files side by side, so decorations have editors to land on. */
+export async function showSources(fixture: string, files: readonly string[]): Promise<void> {
+  await vscode.commands.executeCommand('workbench.action.closeAllEditors');
+  for (const [index, file] of files.entries()) {
+    const document = await vscode.workspace.openTextDocument(sourceOf(fixture, file));
+    await vscode.window.showTextDocument(document, {
+      preview: false,
+      viewColumn: index === 0 ? vscode.ViewColumn.One : vscode.ViewColumn.Beside,
+    });
+  }
+  const visible = vscode.window.visibleTextEditors.map((e) => path.basename(e.document.fileName));
+  for (const file of files) {
+    assert.ok(visible.includes(file), `${file} is visible: ${visible.join(', ')}`);
+  }
+}
+
+// ── The processes panel row of a live F# program ─────────────────────────────
+
+/** Refresh the panel and return the real row the user would click for `pid`. */
+export async function processRow(pid: number): Promise<ProcessTreeItem> {
+  await vscode.commands.executeCommand(uiCommand('refreshProcesses'));
+  const row = await waitFor(
+    () => rowOf(pid),
+    (item) => item !== undefined,
+    LSP_RESPONSE_MS,
+    `the processes panel row of PID ${pid}`,
+  );
+  assert.ok(row && 'process' in row, `PID ${pid} renders as a process row`);
+  return row as ProcessTreeItem;
+}
+
+/** [PROF-UI-PROCESSES] + [PROF-UI-CAPABILITIES]: what an idle F# program's row shows. */
+export function assertIdleRow(row: ProcessTreeItem, pid: number, name: string): void {
+  assert.equal(row.id, `process:${pid}`, 'a stable row id');
+  const tip = tooltipText(row);
+  for (const needle of [`PID ${pid}`, '.NET: ', 'CPU: ', 'Memory: ', 'Runtime: ']) {
+    assert.ok(tip.includes(needle), `the tooltip carries "${needle}": ${tip}`);
+  }
+  assert.equal(row.process.pid, pid);
+  assert.equal(row.process.runtime, 'dotnet', 'an F# program is classified as .NET');
+  assert.ok(row.process.name.includes(name), `the row names the program: ${row.process.name}`);
+  assert.equal(row.process.debuggable, true, 'a live F# program is attachable');
+  assert.ok(row.process.runtimeVersion, 'the runtime version is resolved');
+  assert.equal(row.contextValue, 'processDebuggee', 'direct memory: Track Memory is offered');
+  assert.equal(row.command, undefined, 'an assembly entry is never opened as source');
+  assert.ok(
+    !(row.iconPath instanceof vscode.ThemeIcon && row.iconPath.id === 'flame'),
+    'an idle row does not flame',
+  );
+}
+
+/** Profile CPU from the real row, exactly as its inline button does. */
+export async function profileRow(row: ProcessTreeItem): Promise<string> {
+  await vscode.commands.executeCommand(uiCommand('profileProcess'), row);
+  await waitFor(
+    () => profilerStore().profiler.value.cpu,
+    (cpu) => cpu === 'active',
+    PROCESS_START_MS,
+    `CPU session on PID ${row.process.pid}`,
+  );
+  const id = profilerStore().profiler.value.cpuSessionId;
+  assert.ok(id, 'a live session id');
+  return id;
+}
+
+// ── Live chrome ([PROF-UI-STATE], [PROF-UI-PROCESSES]) ───────────────────────
+
+/** The `sharplsp.profiler.*` gating keys the library last wrote. */
+export function keys(): Record<string, unknown> {
+  const values = contextKeyValues();
+  const read = (name: string) => values.get(`sharplsp.profiler.${name}`);
+  return {
+    profiling: read('profiling'),
+    cpuBusy: read('cpuBusy'),
+    memoryTracking: read('memoryTracking'),
+    memoryBusy: read('memoryBusy'),
+    profilerBusy: read('profilerBusy'),
+  };
+}
+
+/** Everything a live CPU session on `pid` paints, with no memory session running. */
+export async function assertCpuLive(pid: number): Promise<void> {
+  const session = profilerStore().profiler.value;
+  assert.equal(session.cpuPid, pid, 'the session profiles the clicked program');
+  assert.ok(profilerStatusText()?.includes('Profiling'), `status: ${profilerStatusText()}`);
+  assert.deepEqual(
+    { profiling: keys().profiling, cpuBusy: keys().cpuBusy, profilerBusy: keys().profilerBusy },
+    { profiling: true, cpuBusy: true, profilerBusy: true },
+    'the CPU gating keys follow the session',
+  );
+  assert.equal(processesViewState().badge, 1, 'a badge while busy');
+  assert.ok(
+    processesViewState().message?.startsWith(`🔥 Profiling PID ${pid}`) === true,
+    `the panel message names the PID: ${processesViewState().message}`,
+  );
+  const row = await waitFor(
+    () => rowOf(pid),
+    (item) => item?.contextValue === 'processProfiling',
+    LSP_RESPONSE_MS,
+    'the profiled row to swap to its Stop action',
+  );
+  assert.ok(
+    row?.iconPath instanceof vscode.ThemeIcon && row.iconPath.id === 'flame',
+    'the profiled row flames',
+  );
+}
+
+/** Wait for live progress: elapsed time, a sample count and a top function. */
+export async function awaitLiveProgress(): Promise<string> {
+  const store = profilerStore();
+  const live = await waitFor(
+    () => store.profiler.value,
+    (s) => s.durationSecs >= 1 && s.sampleCount > 0 && (s.topFunction ?? '').length > 0,
+    LSP_RESPONSE_MS * 2,
+    'live progress: elapsed time, samples and a top function',
+  );
+  await waitFor(
+    () => profilerStatusText() ?? '',
+    (text) => /[1-9][\d.]* ?K? samples/.test(text),
+    LSP_RESPONSE_MS,
+    'the live sample count in the status bar',
+  );
+  return live.topFunction ?? '';
+}
+
+/** Nothing is profiling CPU: store, status bar, keys and the row agree. */
+export async function assertCpuIdle(pid: number): Promise<void> {
+  assert.equal(profilerStore().profiler.value.cpu, 'idle');
+  assert.equal(profilerStore().profiler.value.cpuSessionId, undefined, 'no stale session id');
+  assert.equal(profilerStatusText(), undefined, 'the CPU status bar hides');
+  assert.equal(keys().profiling, false);
+  assert.equal(keys().cpuBusy, false);
+  const row = await waitFor(
+    () => rowOf(pid),
+    (item) => item !== undefined && item.contextValue !== 'processProfiling',
+    LSP_RESPONSE_MS,
+    'the row to drop its profiling marker',
+  );
+  assert.equal(row?.contextValue, 'processDebuggee');
+}
+
+// ── The CPU result as the editor shows it ────────────────────────────────────
+
+/** The heat tier a share paints with, including its exact threshold. */
+export function cpuTier(percentage: number): string | undefined {
+  const tiers: readonly [number, string][] = [
+    [20, '#e8500a'],
+    [10, '#f97316'],
+    [5, '#fbbf24'],
+    [0, '#4a5468'],
+  ];
+  return tiers.find(([floor]) => percentage >= floor)?.[1];
+}
+
+/** [PROF-AGGREGATION-LOGIC] + [PROF-AGGREGATION-THRESHOLD]: shares are sane and ranked. */
+export function assertRanked(result: ProfileResult): void {
+  assert.ok(result.totalSamples > 0, `samples: ${result.totalSamples}`);
+  const shares = result.hotFunctions.map((fn) => fn.percentage);
+  assert.deepEqual(
+    shares,
+    [...shares].sort((a, b) => b - a),
+    'hot functions arrive ranked',
+  );
+  for (const fn of result.hotFunctions) {
+    assert.ok(fn.percentage <= 100 && fn.percentage >= 2, `${fn.name}: ${fn.percentage}%`);
+    assert.ok(fn.selfPercentage <= fn.percentage + 1e-9, `${fn.name}: self within inclusive`);
+    assert.ok(fn.samples <= result.totalSamples, `${fn.name}: never more samples than ticks`);
+  }
+  for (const line of result.hotLines) {
+    assert.ok(
+      line.percentage <= 100 && line.percentage >= 1,
+      `line ${line.line}: ${line.percentage}%`,
+    );
+    assert.ok(line.line >= 1, 'lines are 1-based in the editor');
+  }
+}
+
+/** A hot function whose name contains `identifier` and that resolves to `file`. */
+export function hotFunction(result: ProfileResult, identifier: string, file: string) {
+  return result.hotFunctions.find((fn) => fn.name.includes(identifier) && isFile(fn.file, file));
+}
+
+/** The heat map as painted on `file`. */
+export function heatOn(file: string): AppliedDecoration[] {
+  return appliedProfileDecorations().filter((d) => isFile(d.file, file));
+}
+
+/** [PROF-UI-HEATMAP]: `span` is painted, in the CPU palette, graded by each line's share. */
+export function assertHeatMap(result: ProfileResult, span: Span): void {
+  const painted = heatOn(span.file);
+  assert.ok(
+    painted.some((d) => within(span, d.file, d.line)),
+    `${span.file} ${span.first}-${span.last} is painted: ${JSON.stringify(painted.map((d) => d.line))}`,
+  );
+  for (const decoration of painted) {
+    assert.ok(CPU_PALETTE.includes(decoration.color), `CPU track colour: ${decoration.color}`);
+    assert.ok(/\d%/.test(decoration.contentText), `a share is shown: ${decoration.contentText}`);
+    const hot =
+      result.hotLines.find((l) => isFile(l.file, span.file) && l.line === decoration.line) ??
+      result.hotFunctions.find((fn) => isFile(fn.file, span.file) && fn.line === decoration.line);
+    assert.ok(hot, `line ${decoration.line} is painted from a reported hot line or function`);
+    assert.ok(
+      decoration.contentText.includes(`${hot.percentage.toFixed(1)}%`),
+      'the decoration displays the reported share at that source location',
+    );
+    const tier = cpuTier(hot.percentage);
+    if (tier !== undefined) {
+      assert.equal(decoration.color, tier, `line ${hot.line} at ${hot.percentage}% wears its tier`);
+    }
+  }
+}
+
+/**
+ * [PROF-UI-WEBVIEW]: an open SharpLsp panel titled `title`, branded `brand`,
+ * naming no other product, behind a nonce-gated script. Returns its HTML.
+ */
+export function assertBrandedPanel(
+  panel: { readonly title: string; readonly html: string } | undefined,
+  title: string,
+  brand: string,
+): string {
+  assert.ok(panel, `the ${title} panel is open`);
+  assert.equal(panel.title, title);
+  assert.ok(panel.html.includes(`<span class="accent">SHARPLSP</span> ${brand}`), 'brand');
+  assert.ok(!/basilisk/i.test(panel.html), 'no other product named');
+  assert.ok(panel.html.includes('<script nonce="'), 'a nonce-gated script ([PROF-UI-WEBVIEW])');
+  return panel.html;
+}
+
+/** [PROF-UI-CPU]: the branded results panel lists `identifiers` and links to source. */
+export function assertResultsPanel(result: ProfileResult, identifiers: readonly string[]): void {
+  const html = assertBrandedPanel(flamegraphPanelState(), 'SharpLsp Profiler', 'PROFILER');
+  assert.ok(html.includes('navigateToSource'), 'rows navigate to their F# source');
+  assert.ok(html.includes(String(result.totalSamples)), 'the summary shows the samples');
+  for (const identifier of identifiers) {
+    assert.ok(html.includes(identifier), `the panel lists the F# function ${identifier}`);
+  }
+}
+
+// ── Memory, as the editor and the wire show it ───────────────────────────────
+
+/** One F# heap type and the exact line that constructs it. */
+export interface Constructed {
+  readonly type: string;
+  readonly file: string;
+  readonly line: number;
+}
+
+/**
+ * FsOrderLedger's heap shapes, each at the exact line that constructs it
+ * ([PROF-DOTNET-SOURCE]: F# records and union cases have only hidden sequence
+ * points, so they anchor where they are built, never at their declaration in
+ * Domain.fs). The count key names the reply count of live instances.
+ */
+export const SHAPES = {
+  order: { type: 'FsOrderLedger.Order', file: 'Ledger.fs', line: 43, live: 'orders' },
+  customer: { type: 'FsOrderLedger.CustomerId', file: 'Ledger.fs', line: 33, live: 'orders' },
+  line: { type: 'FsOrderLedger.OrderLine', file: 'Ledger.fs', line: 41, live: 'orders' },
+  paid: { type: 'FsOrderLedger.OrderStatus+Paid', file: 'Ledger.fs', line: 37, live: 'paid' },
+  shipped: {
+    type: 'FsOrderLedger.OrderStatus+Shipped',
+    file: 'Ledger.fs',
+    line: 38,
+    live: 'shipped',
+  },
+  cancelled: {
+    type: 'FsOrderLedger.OrderStatus+Cancelled',
+    file: 'Ledger.fs',
+    line: 39,
+    live: 'cancelled',
+  },
+  quote: { type: 'FsOrderLedger.Quote', file: 'Quotes.fs', line: 32, live: 'quotes' },
+  audit: { type: 'FsOrderLedger.AuditEntry', file: 'Audit.fs', line: 53, live: 'audits' },
+  rejected: {
+    type: 'FsOrderLedger.OrderRejected',
+    file: 'Rejections.fs',
+    line: 13,
+    live: 'rejections',
+  },
+} as const satisfies Record<string, Constructed & { live: string }>;
+
+/** The never-removed Bus handler: an F# closure built at Bus.fs:16, one per subscription. */
+export const HANDLER = { file: 'Bus.fs', line: 16 } as const;
+/** History's generic record, closed over its Map argument ([PROF-DOTNET-HEAP-GRAPH]). */
+export const VERSIONED =
+  'FsOrderLedger.Versioned`1[Microsoft.FSharp.Collections.FSharpMap`2[System.Int32,FsOrderLedger.Order]]';
+/** Ledger.priceAll, the `burn on` loop: where the ledger's CPU time lands. */
+export const PRICE_ALL: Span = { file: 'Ledger.fs', first: 63, last: 70 };
+/** Every file of FsOrderLedger a shape is constructed in. */
+export const LEDGER_FILES = ['Ledger.fs', 'Bus.fs', 'Quotes.fs', 'Audit.fs', 'Rejections.fs'];
+
+/** The handler closure's site: the F# closure type built at Bus.fs:16. */
+export function handlerSite(snapshot: MemoryDashboardSnapshot | undefined) {
+  const site = snapshot?.topAllocations.find(
+    (s) => isFile(s.file, HANDLER.file) && s.line === HANDLER.line,
+  );
+  assert.ok(
+    site?.typeName,
+    `the subscribe closure is a site at Bus.fs:16: ${JSON.stringify(snapshot?.topAllocations.map((s) => [s.typeName, s.file, s.line]))}`,
+  );
+  assert.ok(site.typeName.startsWith('FsOrderLedger.Bus'), `named in its module: ${site.typeName}`);
+  return site;
+}
+
+/** The snapshot site of `type`, asserted present. */
+export function siteOf(snapshot: MemoryDashboardSnapshot | undefined, type: string) {
+  const site = snapshot?.topAllocations.find((s) => s.typeName === type);
+  assert.ok(
+    site,
+    `${type} is a site: ${snapshot?.topAllocations.map((s) => s.typeName).join(', ')}`,
+  );
+  return site;
+}
+
+/** [PROF-DOTNET-SOURCE]: `shape` anchors at its constructing line and is painted there. */
+export function assertAnchored(
+  snapshot: MemoryDashboardSnapshot | undefined,
+  shape: Constructed,
+  live?: number,
+): void {
+  const site = siteOf(snapshot, shape.type);
+  assert.ok(isFile(site.file, shape.file), `${shape.type} resolves to ${shape.file}: ${site.file}`);
+  assert.equal(site.line, shape.line, `${shape.type} anchors where the program constructs it`);
+  assert.ok(site.size > 0, `${shape.type} has bytes`);
+  if (live !== undefined) assert.equal(site.count, live, `${shape.type}: every live instance`);
+  const painted = memoryTrackOn(shape.file).filter((d) => d.line === shape.line);
+  assert.ok(
+    painted.some((d) => MEMORY_PALETTE.includes(d.color)),
+    `the memory track paints ${shape.file}:${shape.line} purple: ${JSON.stringify(painted)}`,
+  );
+}
+
+/** The memory track (allocations and leak badges) as painted on `file`. */
+export function memoryTrackOn(file: string): AppliedDecoration[] {
+  return appliedMemoryDecorations().filter((d) => isFile(d.file, file));
+}
+
+/** The leak badge painted at `file`:`line`, if any. */
+export function leakBadge(file: string, line: number): AppliedDecoration | undefined {
+  return memoryTrackOn(file).find((d) => d.line === line && BADGE.test(d.contentText));
+}
+
+/** A wire diff on its own session: the heap diff and its suspected leaks. */
+export async function wireDiff(session: {
+  memory_session_id: string;
+}): Promise<{ diff: HeapDiff; leaks: SuspectedLeak[] }> {
+  const result = completed(await execute<MemoryStep>('memory.diff', session));
+  assert.equal(result.outcome.kind, 'Diff', 'a diff answers with a diff');
+  const { diff, leaks } = result.outcome as { diff: HeapDiff; leaks: SuspectedLeak[] };
+  assert.equal(diff.net_growth, diff.total_growth - diff.total_freed, 'net = grown - freed');
+  assert.ok(diff.total_growth >= 0 && diff.total_freed >= 0, 'totals are magnitudes');
+  return { diff, leaks };
+}
+
+/** The wire leak of `type`, if suspected. */
+export function wireLeak(leaks: readonly SuspectedLeak[], type: string): SuspectedLeak | undefined {
+  return leaks.find((leak) => leak.type_name === type);
+}
+
+/**
+ * Stop the ledger's background work and drain its mailbox. Its retained state
+ * is left as the test made it: later tests start from a dirty heap on purpose,
+ * and read every count they assert from the fixture's own replies.
+ */
+export async function settleLedger(target: Target): Promise<void> {
+  for (const line of ['burn off', 'drip off', 'audit resume', 'release blobs']) {
+    await command(target, line);
+  }
+}
+
+/**
+ * End everything a test left running: the UI's CPU and memory sessions and any
+ * wire CPU session. Every F# suite runs it after each test, so one failure
+ * never leaves a session that fails the next test for the wrong reason.
+ */
+export async function endProfiling(): Promise<void> {
+  const session = profilerStore().profiler.value;
+  if (session.cpu !== 'idle') await stopProfiling(STOP_MS);
+  if (session.memory !== 'idle') await stopTracking();
+  const listed = await execute<ProfileSessionList>('cpu.list', {});
+  for (const running of listed.sessions) {
+    await execute('cpu.stop', { session_id: running.session_id });
+  }
+}
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-memory-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-memory-e2e.test.ts
new file mode 100644
index 00000000..1583f079
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-memory-e2e.test.ts
@@ -0,0 +1,463 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on F#. See docs/specs/PROFILER-SPEC.md#PROFILER-SHARED-LIBRARY-VSCODE
+//
+// Memory tracking and leak detection on a real F# service, FsOrderLedger: an
+// event-sourced order ledger with the leaks F# code really has —
+//   - event handlers that are never removed (closures held by an F# Event);
+//   - a memoize cache that never evicts;
+//   - an unbounded MailboxProcessor queue;
+//   - an undo history that keeps every immutable Map.
+// Its heap is the shapes only F# emits: records, a single-case union, union
+// cases as nested classes, a nullary case with no class at all, struct records
+// and struct unions stored inline, an F# exception, and a generic record closed
+// over FSharpMap. The fixture reports the exact live count of every shape after
+// each command, so every snapshot, diff and confidence step is checked exactly,
+// through the UI and over the wire at once. lspkit's [PROF-MEMORY-OUTCOME],
+// [PROF-MEMORY-COMPARE], [PROF-MEMORY-CONFIDENCE], [PROF-MEMORY-TIMELINE],
+// [PROF-MEMORY-HEAPPROFILE], [PROF-DOTNET-SOURCE], [PROF-UI-MEMORY], [PROF-UI-HEATMAP].
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as vscode from 'vscode';
+import {
+  appliedMemoryDecorations,
+  lastMemorySnapshot,
+  lastProfileResult,
+  memoryDashboardState,
+  memoryStatusText,
+  processesViewState,
+  profilerStatusText,
+  recordedOperations,
+} from '@nimblesite/lsp-profiler-ui';
+import { memStartTitle } from '@nimblesite/lsp-profiler-ui/out/src/memory-capture';
+import { referenceTypeCandidates } from '@nimblesite/lsp-profiler-ui/out/src/memory-ref-picker';
+import type { MemoryDashboardSnapshot } from '@nimblesite/lsp-profiler-ui/out/src/memory-dashboard';
+import type { MemoryStep } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  completed,
+  embeddedLeaks,
+  execute,
+  executeError,
+  profilerStore,
+  profilingSuite,
+  snapshotSession,
+  stopProfiling,
+  stopTracking,
+  trackMemory,
+  uiCommand,
+  waitFor,
+} from './profiler-kit';
+import {
+  assertAnchored,
+  assertBrandedPanel,
+  assertHeatMap,
+  assertIdleRow,
+  awaitLiveProgress,
+  command,
+  count,
+  type Counts,
+  handlerSite,
+  heatOn,
+  hotFunction,
+  isFile,
+  keys,
+  LEAK_PALETTE,
+  leakBadge,
+  LEDGER,
+  LEDGER_FILES,
+  memoryTrackOn,
+  PRICE_ALL,
+  processRow,
+  profileRow,
+  SHAPES,
+  settleLedger,
+  showSources,
+  STOP_MS,
+  endProfiling,
+  wireDiff,
+  wireLeak,
+} from './profiler-fsharp-kit';
+
+const SEEDED = { orders: 12_000, quotes: 4_000, rejections: 1_500 };
+
+/** Take a UI snapshot and wait until the dashboard holds a newer one. */
+async function uiSnapshot(previous?: MemoryDashboardSnapshot): Promise<MemoryDashboardSnapshot> {
+  await vscode.commands.executeCommand(uiCommand('memorySnapshot'));
+  const snapshot = await waitFor(
+    () => lastMemorySnapshot(),
+    (snap) => snap !== undefined && snap.snapshotId !== previous?.snapshotId,
+    STOP_MS,
+    'a new snapshot in the dashboard',
+  );
+  assert.ok(snapshot);
+  return snapshot;
+}
+
+/** Every F# shape is a site at its constructing line, with every live instance counted. */
+function assertZoo(snapshot: MemoryDashboardSnapshot, counts: Counts): void {
+  for (const shape of Object.values(SHAPES)) {
+    if (count(counts, shape.live) > 0) assertAnchored(snapshot, shape, count(counts, shape.live));
+  }
+  assert.equal(handlerSite(snapshot).count, count(counts, 'handlers'), 'one closure per handler');
+  const names = snapshot.topAllocations.map((s) => s.typeName ?? '');
+  for (const absent of [
+    'FsOrderLedger.OrderStatus+Pending',
+    'FsOrderLedger.Address',
+    'FsOrderLedger.Money',
+  ]) {
+    assert.ok(
+      !names.includes(absent),
+      `${absent} is never a heap type: nullary cases have no class, struct records and struct unions live inline`,
+    );
+  }
+  assert.ok(
+    !snapshot.topAllocations.some((s) => isFile(s.file, 'Domain.fs')),
+    'no F# record or union anchors at its declaration: they anchor where they are built',
+  );
+  for (const site of snapshot.topAllocations) {
+    if (site.typeName?.startsWith('Microsoft.FSharp.') === true) {
+      assert.ok(
+        !LEDGER_FILES.some((file) => isFile(site.file, file)),
+        `FSharp.Core's ${site.typeName} is never placed in the ledger's code`,
+      );
+    }
+  }
+}
+
+/** [PROF-UI-MEMORY]: the dashboard's own numbers are coherent and branded. */
+function assertDashboard(snapshot: MemoryDashboardSnapshot, types: readonly string[]): void {
+  const html = assertBrandedPanel(memoryDashboardState(), 'SharpLsp Memory Dashboard', 'MEMORY');
+  assert.ok(html.includes('Generation sizes'), 'heap regions are labelled as bytes');
+  assert.deepEqual(snapshot.gcCounts, [], 'generation bytes are never shown as counts');
+  for (const type of types) assert.ok(html.includes(type), `the dashboard names ${type}`);
+  assert.ok(snapshot.peakMemory >= snapshot.currentMemory, 'peak is never below current');
+  const listed = snapshot.topAllocations.reduce((sum, site) => sum + site.size, 0);
+  assert.ok(listed <= snapshot.currentMemory, `top sites (${listed}) fit in the live heap`);
+  assert.ok(snapshot.gcObjects > 0, 'live objects are counted');
+  assert.ok(
+    snapshot.heapProfilePath.length > 0 && fs.existsSync(snapshot.heapProfilePath),
+    `each snapshot writes a .heapprofile: ${snapshot.heapProfilePath}`,
+  );
+  const profile = JSON.parse(fs.readFileSync(snapshot.heapProfilePath, 'utf8')) as {
+    head?: unknown;
+  };
+  assert.ok(profile.head !== undefined, 'the .heapprofile has a call tree head');
+}
+
+/** Every painted memory decoration on a ledger file stands on a reported site. */
+function assertNoPhantomPaint(snapshot: MemoryDashboardSnapshot): void {
+  for (const file of LEDGER_FILES) {
+    for (const decoration of memoryTrackOn(file)) {
+      if (leakBadge(file, decoration.line) === decoration) continue;
+      assert.ok(
+        snapshot.topAllocations.some((s) => isFile(s.file, file) && s.line === decoration.line),
+        `${file}:${decoration.line} is painted only because a site is there`,
+      );
+    }
+  }
+}
+
+suite('F# memory — FsOrderLedger through the UI and the wire', () => {
+  const live = profilingSuite('profiler-fs-mem-', LEDGER);
+  teardown(async function () {
+    this.timeout(STOP_MS * 2);
+    await endProfiling();
+    await settleLedger(live.target);
+  });
+
+  test('the F# heap zoo: seed every leak → Track Memory from the row → snapshot anchors every shape at its line with every instance counted → drain the mailbox → snapshot again → release → only the true leaks survive → stop clears everything', async function () {
+    this.timeout(STOP_MS * 6);
+    const { target } = live;
+    await command(target, 'audit pause');
+    const seeded = await command(target, `place ${SEEDED.orders}`);
+    assert.equal(count(seeded, 'orders'), SEEDED.orders);
+    assert.equal(count(seeded, 'audits'), SEEDED.orders, 'a paused mailbox queues every entry');
+    for (const status of ['pending', 'paid', 'shipped', 'cancelled']) {
+      assert.equal(count(seeded, status), SEEDED.orders / 4, `ids cycle evenly: ${status}`);
+    }
+    await command(target, `quote ${SEEDED.quotes}`);
+    await command(target, `reject ${SEEDED.rejections}`);
+    await command(target, 'history');
+    const counts = await command(target, 'history');
+    assert.equal(count(counts, 'snapshots'), 2);
+    await showSources(LEDGER, LEDGER_FILES);
+
+    // Track Memory: the chrome, the keys and the progress notification follow.
+    const row = await processRow(target.pid);
+    assertIdleRow(row, target.pid, LEDGER);
+    const opsBefore = recordedOperations().length;
+    await trackMemory(target.pid);
+    assert.ok(memoryStatusText()?.includes('tracking'), `status: ${memoryStatusText()}`);
+    assert.equal(profilerStatusText(), undefined, 'no CPU status while only memory runs');
+    assert.deepEqual(keys(), {
+      profiling: false,
+      cpuBusy: false,
+      memoryTracking: true,
+      memoryBusy: true,
+      profilerBusy: true,
+    });
+    assert.deepEqual(processesViewState(), {
+      message: '🗄️ Tracking memory allocations…',
+      badge: 1,
+    });
+    const ops = recordedOperations().slice(opsBefore);
+    assert.ok(ops.includes(`begin:${memStartTitle()}`) && ops.includes(`end:${memStartTitle()}`));
+    const session = profilerStore().profiler.value.memorySessionId;
+    assert.ok(session, 'a memory session id');
+
+    // Snapshot one: every shape, exactly, at its line; nothing invented.
+    const first = await uiSnapshot();
+    assertZoo(first, counts);
+    assertDashboard(
+      first,
+      Object.values(SHAPES).map((s) => s.type),
+    );
+    assertNoPhantomPaint(first);
+    assert.equal(first.timeline.length, 1, 'the first point of the timeline');
+    const offered = referenceTypeCandidates(first);
+    const typed = first.topAllocations.flatMap((s) => (s.typeName ? [s.typeName] : []));
+    assert.ok(
+      offered.length > 0 && offered.every((t) => typed.includes(t)),
+      'the picker offers only reported types',
+    );
+    const positions = offered.map((t) => typed.indexOf(t));
+    assert.deepEqual(
+      positions,
+      [...positions].sort((a, b) => a - b),
+      'in the server’s rank order',
+    );
+    for (const shape of [SHAPES.order, SHAPES.shipped, SHAPES.quote]) {
+      assert.ok(offered.includes(shape.type), `the picker offers ${shape.type}`);
+    }
+
+    // A second Track Memory is refused and keeps the session.
+    await vscode.commands.executeCommand(uiCommand('memoryStart'), target.pid);
+    assert.equal(profilerStore().profiler.value.memorySessionId, session);
+
+    // Drain the mailbox and place more: the next snapshot follows exactly.
+    await command(target, 'audit resume');
+    const grown = await command(target, 'place 400');
+    assert.equal(count(grown, 'audits'), 0, 'the mailbox drained');
+    const second = await uiSnapshot(first);
+    assertZoo(second, grown);
+    assert.ok(
+      !second.topAllocations.some((s) => s.typeName === SHAPES.audit.type),
+      'drained audit entries are gone from the live heap',
+    );
+    assert.equal(second.timeline.length, 2, 'one timeline point per snapshot');
+    const [p1, p2] = second.timeline;
+    assert.ok(p1 && p2 && p2.timestamp >= p1.timestamp, 'points run forward in time');
+
+    // Release the ledger: orders die; the handler and memoize leaks survive exactly.
+    const released = await command(target, 'release all');
+    assert.deepEqual(
+      [count(released, 'orders'), count(released, 'rejections'), count(released, 'snapshots')],
+      [0, 0, 0],
+    );
+    const third = await uiSnapshot(second);
+    for (const dead of [
+      SHAPES.order,
+      SHAPES.customer,
+      SHAPES.line,
+      SHAPES.shipped,
+      SHAPES.rejected,
+    ]) {
+      assert.ok(
+        !third.topAllocations.some((s) => s.typeName === dead.type),
+        `${dead.type} died with the ledger`,
+      );
+    }
+    assert.equal(handlerSite(third).count, count(released, 'handlers'), 'handlers still leak');
+    assertAnchored(third, SHAPES.quote, count(released, 'quotes'));
+    assert.ok(third.currentMemory < second.currentMemory, 'releasing the ledger shrinks the heap');
+    assert.equal(third.timeline.length, 3);
+    assertNoPhantomPaint(third);
+    assert.equal(
+      memoryTrackOn('Ledger.fs').filter((d) => d.line === SHAPES.order.line).length,
+      0,
+      'the Order line is no longer painted once no Order lives',
+    );
+
+    // Stop: the session ends everywhere.
+    await stopTracking();
+    assert.equal(memoryStatusText(), undefined);
+    assert.deepEqual(keys(), {
+      profiling: false,
+      cpuBusy: false,
+      memoryTracking: false,
+      memoryBusy: false,
+      profilerBusy: false,
+    });
+    assert.deepEqual(processesViewState(), { message: undefined, badge: undefined });
+    assert.deepEqual(appliedMemoryDecorations(), [], 'the memory track is cleared');
+    assert.equal(lastMemorySnapshot(), undefined, 'per-session state is dropped');
+  });
+
+  test('leak confidence, exactly as specified, on two sessions at once: Low → Medium → High on three growths, reset by a flat diff, Low again, freed by a release, Medium on one growth over 10 MiB → High; the dashboard and the wire agree at every step', async function () {
+    this.timeout(STOP_MS * 10);
+    const { target } = live;
+    await showSources(LEDGER, ['Ledger.fs']);
+    await trackMemory(target.pid);
+    await uiSnapshot();
+    const wire = await snapshotSession(target.pid);
+
+    /** Diff on both sessions; return the wire leaks and the dashboard's leaks. */
+    async function bothDiff() {
+      await vscode.commands.executeCommand(uiCommand('memoryDiff'));
+      const html = await waitFor(
+        () => memoryDashboardState()?.html ?? '',
+        (h) => h.includes('const leaks = '),
+        STOP_MS,
+        'the dashboard leak analysis',
+      );
+      const shown = embeddedLeaks(html);
+      return { ...(await wireDiff(wire)), shown };
+    }
+
+    /** One growth round: place, diff both, and check the Order leak at `level`. */
+    async function grow(level: 'Low' | 'Medium' | 'High') {
+      const before = profilerStore().profiler.value.memorySessionId;
+      const counts = await command(target, 'place 1000');
+      const { leaks, shown, diff } = await bothDiff();
+      assert.equal(profilerStore().profiler.value.memorySessionId, before, 'one UI session');
+      assert.ok(diff.total_growth > 0, 'the heap grew');
+      const order = wireLeak(leaks, SHAPES.order.type);
+      assert.ok(
+        order,
+        `Order is suspected after a growth: ${JSON.stringify(leaks.map((l) => l.type_name))}`,
+      );
+      assert.equal(order.confidence.kind, level, `${level} on this growth`);
+      assert.equal(order.count_growth, 1000, 'exactly the orders placed');
+      assert.equal(order.current_count, count(counts, 'orders'), 'every live order');
+      assert.ok(order.size_growth > 0 && order.current_size > 0);
+      assert.ok(isFile(order.file, 'Ledger.fs') && order.line === SHAPES.order.line, 'at its line');
+      assert.ok(order.reason.length > 0, 'the reason is said');
+      for (const [shape, each] of [
+        [SHAPES.shipped, 250],
+        [SHAPES.customer, 1000],
+      ] as const) {
+        assert.equal(
+          wireLeak(leaks, shape.type)?.count_growth,
+          each,
+          `${shape.type} grew by ${each}`,
+        );
+      }
+      const ui = shown.find((leak) => leak.typeName === SHAPES.order.type);
+      assert.ok(ui, 'the dashboard lists the Order leak');
+      assert.equal(
+        ui.confidence,
+        level.toLowerCase(),
+        'the dashboard shows the server’s confidence',
+      );
+      assert.equal(ui.countGrowth, 1000);
+      assert.equal(ui.line, SHAPES.order.line);
+      const badge = leakBadge('Ledger.fs', SHAPES.order.line);
+      assert.ok(
+        badge,
+        `the Order line wears a leak badge: ${JSON.stringify(memoryTrackOn('Ledger.fs'))}`,
+      );
+      assert.ok(
+        badge.contentText.includes(level.toUpperCase()),
+        `a ${level} badge: ${badge.contentText}`,
+      );
+      assert.ok(LEAK_PALETTE.includes(badge.color), `leak colour: ${badge.color}`);
+    }
+
+    await grow('Low');
+    await grow('Medium');
+    await grow('High');
+
+    // A flat diff resets the streak on both surfaces, and the badge goes.
+    const flat = await bothDiff();
+    assert.equal(wireLeak(flat.leaks, SHAPES.order.type), undefined, 'no growth, no suspicion');
+    assert.ok(!flat.shown.some((l) => l.typeName === SHAPES.order.type), 'the dashboard agrees');
+    assert.equal(leakBadge('Ledger.fs', SHAPES.order.line), undefined, 'the badge is gone');
+    await grow('Low');
+
+    // Releasing frees: counted as freed and net, never as a leak.
+    await command(target, 'release orders');
+    const freed = await bothDiff();
+    assert.ok(freed.diff.total_freed > 0, 'freed bytes are counted');
+    assert.ok(freed.diff.net_growth < 0, 'the heap shrank on net');
+    assert.ok(
+      freed.diff.freed.some((site) => site.type_name === SHAPES.order.type),
+      'the released orders are listed as freed',
+    );
+    assert.equal(wireLeak(freed.leaks, SHAPES.order.type), undefined, 'freed is never a leak');
+
+    // One growth over 10 MiB is Medium at once; two more growths make it High.
+    const blobLevels = [
+      ['blob 12', 'Medium'],
+      ['blob 1', 'Medium'],
+      ['blob 1', 'High'],
+    ] as const;
+    for (const [line, level] of blobLevels) {
+      await command(target, line);
+      const { leaks, shown } = await bothDiff();
+      const bytes = wireLeak(leaks, 'System.Byte[]');
+      assert.ok(bytes, `byte arrays are suspected after "${line}"`);
+      assert.equal(bytes.confidence.kind, level, `"${line}" → ${level}`);
+      assert.equal(bytes.file, undefined, 'a framework type has no location');
+      const ui = shown.find((leak) => leak.typeName === 'System.Byte[]');
+      assert.equal(ui?.confidence, level.toLowerCase(), 'shown in the dashboard all the same');
+      assert.ok(bytes.size_growth >= 1_048_576, `at least the retained MiB: ${bytes.size_growth}`);
+    }
+
+    await command(target, 'release blobs');
+    await stopTracking();
+    completed(await execute<MemoryStep>('memory.stop', wire));
+    for (const step of ['memory.snapshot', 'memory.diff', 'memory.stop']) {
+      assert.equal((await executeError(step, wire))?.code, -32000, `${step} after stop is refused`);
+    }
+  });
+
+  test('two tracks on one F# file: Track Memory and Profile CPU on the same program at once → both painted on Ledger.fs → stopping CPU keeps the memory track → stopping memory keeps the heat map', async function () {
+    this.timeout(STOP_MS * 5);
+    const { target } = live;
+    await command(target, 'place 3000');
+    await command(target, 'burn on');
+    await showSources(LEDGER, ['Ledger.fs']);
+    await trackMemory(target.pid);
+    const snapshot = await uiSnapshot();
+    assertAnchored(snapshot, SHAPES.order);
+
+    const row = await processRow(target.pid);
+    await profileRow(row);
+    assert.deepEqual(keys(), {
+      profiling: true,
+      cpuBusy: true,
+      memoryTracking: true,
+      memoryBusy: true,
+      profilerBusy: true,
+    });
+    assert.ok(profilerStatusText()?.includes('Profiling'), 'the CPU status shows');
+    assert.ok(memoryStatusText()?.includes('tracking'), 'the memory status still shows');
+    assert.equal(processesViewState().badge, 1, 'one badge for a busy profiler');
+    await awaitLiveProgress();
+    await stopProfiling(STOP_MS);
+
+    const result = lastProfileResult();
+    assert.ok(result && hotFunction(result, 'priceAll', 'Ledger.fs'), 'pricing the ledger is hot');
+    assertHeatMap(result, PRICE_ALL);
+    const memoryTrack = memoryTrackOn('Ledger.fs');
+    assert.ok(
+      memoryTrack.some((d) => d.line === SHAPES.order.line),
+      'the memory track survives',
+    );
+    assert.deepEqual(
+      {
+        profiling: keys().profiling,
+        memoryTracking: keys().memoryTracking,
+        busy: keys().profilerBusy,
+      },
+      { profiling: false, memoryTracking: true, busy: true },
+      'stopping CPU leaves memory running',
+    );
+    assert.ok(memoryStatusText()?.includes('tracking'));
+
+    const heat = heatOn('Ledger.fs');
+    await stopTracking();
+    assert.deepEqual(memoryTrackOn('Ledger.fs'), [], 'the memory track clears');
+    assert.deepEqual(heatOn('Ledger.fs'), heat, 'the CPU heat map is another track and stays');
+    assert.equal(keys().profilerBusy, false);
+    await command(target, 'burn off');
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-retention-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-retention-e2e.test.ts
new file mode 100644
index 00000000..57f9ccb4
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-retention-e2e.test.ts
@@ -0,0 +1,486 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on F#. See docs/specs/PROFILER-SPEC.md#PROFILER-SHARED-LIBRARY-VSCODE
+//
+// What keeps each F# leak alive, on FsOrderLedger. Each leak has its own root,
+// and each root is an F# module value, which the compiler stores in a mangled
+// `name@line` field. The tests check:
+//   - the retention graph names every root by its source name, under every
+//     depth and node budget, keeping the budget rules of lspkit's
+//     [PROF-DOTNET-HEAP-MARK];
+//   - objects-by-type counts every live F# instance exactly, largest first,
+//     from the snapshot it was asked about ([PROF-DOTNET-MEMORY]);
+//   - the UI's retention graph and type picker show the same F# names;
+//   - an induced GC frees what the program released;
+//   - a cancelled request, a dead target and steps with no snapshot fail
+//     honestly ([PROF-HOST-CANCEL], [PROF-ERRORS]).
+import * as assert from 'node:assert/strict';
+import * as vscode from 'vscode';
+import { CancellationTokenSource } from 'vscode-languageclient/node';
+import {
+  lastMemorySnapshot,
+  memoryDashboardState,
+  refGraphState,
+} from '@nimblesite/lsp-profiler-ui';
+import {
+  referenceTypeCandidates,
+  walkReferences,
+} from '@nimblesite/lsp-profiler-ui/out/src/memory-ref-picker';
+import type {
+  GcResult,
+  MemoryStartResult,
+  MemoryStep,
+  ObjectList,
+  RefGraph,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  completed,
+  execute,
+  executeError,
+  lspClient,
+  lspCommand,
+  profilerStore,
+  profilingSuite,
+  retentionGraph,
+  snapshotSession,
+  stopTracking,
+  Target,
+  trackMemory,
+  uiCommand,
+  waitFor,
+} from './profiler-kit';
+import { captureToasts } from './profiler-ui-helpers';
+import { installUiStubs } from './ui-stubs';
+import {
+  command,
+  count,
+  type Counts,
+  endProfiling,
+  handlerSite,
+  LEDGER,
+  processRow,
+  settleLedger,
+  SHAPES,
+  STOP_MS,
+  VERSIONED,
+} from './profiler-fsharp-kit';
+
+interface Session {
+  readonly memory_session_id: string;
+}
+
+/** Each leak's type, the module value that roots it, and the depth its path needs. */
+const ROOTS = [
+  { type: SHAPES.order.type, root: 'static orders', depth: 6 },
+  { type: SHAPES.quote.type, root: 'static quote', depth: 8 },
+  { type: SHAPES.audit.type, root: 'static auditor', depth: 10 },
+  { type: SHAPES.rejected.type, root: 'static rejected', depth: 6 },
+  { type: VERSIONED, root: 'static snapshots', depth: 6 },
+] as const;
+
+/** Budgets the graph must respect: a deep, roomy walk and a tight one. */
+const BUDGETS = [
+  { maxDepth: 10, limit: 80 },
+  { maxDepth: 3, limit: 12 },
+] as const;
+
+/** [PROF-DOTNET-HEAP-MARK] + [PROF-DOTNET-HEAP-GRAPH]: every rule of a retention graph. */
+function assertGraphRules(graph: RefGraph, type: string, maxDepth: number, limit: number): void {
+  const ids = new Set(graph.nodes.map((n) => n.id));
+  assert.equal(ids.size, graph.nodes.length, 'node ids are unique');
+  assert.ok(graph.nodes.length <= limit, `${graph.nodes.length} nodes within the budget ${limit}`);
+  const targets = graph.nodes.filter((n) => n.is_target);
+  assert.ok(targets.length > 0, `${type} has target nodes`);
+  assert.ok(
+    targets.every((n) => n.type_name === type),
+    'targets are the type asked about',
+  );
+  assert.ok(targets.length <= Math.ceil(limit / 4), 'targets take at most a quarter of the budget');
+  assert.ok(
+    graph.nodes.every((n) => n.depth >= 0 && n.depth <= maxDepth),
+    `depth ≤ ${maxDepth}`,
+  );
+  assert.ok(
+    graph.nodes.every((n) => n.size_bytes >= 0),
+    'sizes are bytes',
+  );
+  for (const edge of graph.edges) {
+    assert.ok(ids.has(edge.from) && ids.has(edge.to), `edge ${edge.from}→${edge.to} joins nodes`);
+  }
+  for (const root of graph.nodes.filter((n) => n.is_root)) {
+    assert.ok(root.root_kind, `root ${root.label} says what kind of root it is`);
+    assert.ok(
+      !root.label.includes('@'),
+      `no compiler-mangled F# name reaches a root: ${root.label}`,
+    );
+  }
+}
+
+/** The objects of `type` in the session's latest snapshot. */
+async function objectsOf(session: Session, type: string, limit: number): Promise<ObjectList> {
+  const step = completed(
+    await execute<MemoryStep>('memory.objectsByType', { ...session, type_name: type, limit }),
+  );
+  assert.equal(step.outcome.kind, 'Objects', 'objects answer with objects');
+  return (step.outcome as { objects: ObjectList }).objects;
+}
+
+/** [PROF-DOTNET-MEMORY] objects: exact totals, the limit, largest first, one type. */
+function assertObjects(objects: ObjectList, type: string, live: number, limit: number): void {
+  assert.equal(objects.type_name, type);
+  assert.equal(objects.total_count, live, `every live ${type} is counted`);
+  assert.equal(objects.objects.length, Math.min(limit, live), `limit ${limit} is honoured`);
+  const sizes = objects.objects.map((o) => o.size_bytes);
+  assert.deepEqual(
+    sizes,
+    [...sizes].sort((a, b) => b - a),
+    'largest first',
+  );
+  assert.ok(
+    objects.objects.every((o) => o.type_name === type),
+    'only objects of the type',
+  );
+  assert.ok(objects.total_bytes >= sizes.reduce((a, b) => a + b, 0), 'the total covers the listed');
+  if (live > 0) {
+    const own = objects.type_summary.find((entry) => entry.type_name === type);
+    assert.ok(own, '[PROF-DOTNET-MEMORY] the summary always includes the requested live type');
+    assert.equal(own.count, live, 'the requested summary row counts every live F# instance');
+    assert.equal(
+      own.size_bytes,
+      objects.total_bytes,
+      'its summary bytes match the full type total',
+    );
+  }
+  if (live <= limit)
+    assert.equal(
+      objects.total_bytes,
+      sizes.reduce((sum, size) => sum + size, 0),
+      'an exhaustive object list accounts for every byte of the requested F# type',
+    );
+  const ranked = objects.type_summary.map((entry) => entry.size_bytes);
+  assert.deepEqual(
+    ranked,
+    [...ranked].sort((a, b) => b - a),
+    'the heap summary ranks by bytes',
+  );
+}
+
+/** Seed one of every leak, deterministically. */
+async function seed(target: Target): Promise<Counts> {
+  await command(target, 'audit pause');
+  await command(target, 'place 2000');
+  await command(target, 'quote 600');
+  await command(target, 'reject 300');
+  await command(target, 'history');
+  return command(target, 'history');
+}
+
+suite('F# retention, objects, GC and refusals — FsOrderLedger', () => {
+  const live = profilingSuite('profiler-fs-retain-', LEDGER);
+  teardown(async function () {
+    this.timeout(STOP_MS * 2);
+    await endProfiling();
+    await settleLedger(live.target);
+  });
+
+  test('every F# leak is held by its module value under its source name, under every depth and node budget; the event-handler closure by `static published`, byte arrays by both the ledger and the blob store', async function () {
+    this.timeout(STOP_MS * 6);
+    const { target } = live;
+    await seed(target);
+    await command(target, 'blob 2');
+    const session = await snapshotSession(target.pid);
+
+    for (const { type, root, depth } of ROOTS) {
+      const graph = await retentionGraph(session, type, depth, 80);
+      assertGraphRules(graph, type, depth, 80);
+      const roots = graph.nodes.filter((n) => n.is_root);
+      assert.ok(
+        roots.some((n) => n.label === root && n.root_kind === 'Static'),
+        `${type} is held by ${root}: ${JSON.stringify(roots.map((r) => [r.label, r.root_kind]))}`,
+      );
+      assert.ok(graph.edges.length > 0, `${type}: the holders are linked`);
+      for (const { maxDepth, limit } of BUDGETS) {
+        const bounded = await retentionGraph(session, type, maxDepth, limit);
+        assertGraphRules(bounded, type, maxDepth, limit);
+      }
+      const tight = await retentionGraph(session, type, 2, 8);
+      assertGraphRules(tight, type, 2, 8);
+      const exhausted = await retentionGraph(session, type, 2, 1);
+      assertGraphRules(exhausted, type, 2, 1);
+      assert.equal(
+        exhausted.truncated,
+        true,
+        `${type}: one node cannot hold the target and its holder`,
+      );
+    }
+
+    // The never-removed handler: an F# closure, rooted at the event's module value.
+    const ui = await snapshotSession(target.pid);
+    completed(await execute<MemoryStep>('memory.stop', ui));
+    await trackMemory(target.pid);
+    await vscode.commands.executeCommand(uiCommand('memorySnapshot'));
+    const snapshot = await waitFor(
+      () => lastMemorySnapshot(),
+      (s) => s !== undefined,
+      STOP_MS,
+      'snapshot',
+    );
+    const closure = handlerSite(snapshot).typeName ?? '';
+    const handlers = await retentionGraph(session, closure, 12, 120);
+    assertGraphRules(handlers, closure, 12, 120);
+    assert.ok(
+      handlers.nodes.some((n) => n.is_root && n.label === 'static published'),
+      `the subscribe closures are kept alive by the Bus event: ${JSON.stringify(handlers.nodes.filter((n) => n.is_root).map((n) => n.label))}`,
+    );
+
+    // Byte arrays have two owners: each order's payload and the retained blob.
+    const bytes = await retentionGraph(session, 'System.Byte[]', 6, 120);
+    const byteRoots = bytes.nodes.filter((n) => n.is_root).map((n) => n.label);
+    for (const root of ['static orders', 'static blobs']) {
+      assert.ok(
+        byteRoots.includes(root),
+        `byte arrays are held by ${root}: ${byteRoots.join(', ')}`,
+      );
+    }
+    await stopTracking();
+    completed(await execute<MemoryStep>('memory.stop', session));
+    await command(target, 'release all');
+    await command(target, 'audit resume');
+  });
+
+  test('objects by type: every F# shape counted exactly at every limit, largest first; the count is the snapshot’s, not the live heap’s, until the next snapshot', async function () {
+    this.timeout(STOP_MS * 5);
+    const { target } = live;
+    const counts = await seed(target);
+    const session = await snapshotSession(target.pid);
+    const exact: readonly [string, number][] = [
+      [SHAPES.order.type, count(counts, 'orders')],
+      [SHAPES.customer.type, count(counts, 'orders')],
+      [SHAPES.line.type, count(counts, 'orders')],
+      [SHAPES.paid.type, count(counts, 'paid')],
+      [SHAPES.shipped.type, count(counts, 'shipped')],
+      [SHAPES.cancelled.type, count(counts, 'cancelled')],
+      [SHAPES.quote.type, count(counts, 'quotes')],
+      [SHAPES.audit.type, count(counts, 'audits')],
+      [SHAPES.rejected.type, count(counts, 'rejections')],
+      [VERSIONED, count(counts, 'snapshots')],
+    ];
+    for (const [type, liveCount] of exact) {
+      for (const limit of [1, 7, 50]) {
+        assertObjects(await objectsOf(session, type, limit), type, liveCount, limit);
+      }
+    }
+    // [PROF-DOTNET-MEMORY] every summary row agrees with that type's exhaustive totals.
+    const summary = (await objectsOf(session, SHAPES.order.type, 1)).type_summary;
+    assert.ok(summary.length > 0, 'the real heap produces a ranked type summary');
+    for (const entry of summary) {
+      const actual = await objectsOf(session, entry.type_name, 1);
+      assert.equal(
+        entry.count,
+        actual.total_count,
+        `${entry.type_name}: summary count matches objects`,
+      );
+      assert.equal(
+        entry.size_bytes,
+        actual.total_bytes,
+        `${entry.type_name}: summary bytes match objects`,
+      );
+    }
+    for (const absent of [
+      'FsOrderLedger.OrderStatus+Pending',
+      'FsOrderLedger.Address',
+      'No.Such.Type',
+    ]) {
+      assertObjects(await objectsOf(session, absent, 5), absent, 0, 5);
+    }
+
+    // The live heap moves on; the answer stays the snapshot's until the next one.
+    const more = await command(target, 'place 400');
+    const stale = await objectsOf(session, SHAPES.order.type, 5);
+    assert.equal(stale.total_count, count(counts, 'orders'), 'objects read the latest snapshot');
+    completed(await execute<MemoryStep>('memory.snapshot', session));
+    const fresh = await objectsOf(session, SHAPES.order.type, 5);
+    assert.equal(fresh.total_count, count(more, 'orders'), 'a new snapshot sees the new orders');
+    assert.equal(fresh.total_count - stale.total_count, 400);
+
+    completed(await execute<MemoryStep>('memory.stop', session));
+    await command(target, 'release all');
+    await command(target, 'audit resume');
+  });
+
+  test('the UI retention graph and picker speak F#: walk Order, then a union case, in one panel; the picker’s first type opens; an induced GC after a release frees bytes and keeps tracking', async function () {
+    this.timeout(STOP_MS * 5);
+    const { target } = live;
+    await seed(target);
+    await processRow(target.pid);
+    await trackMemory(target.pid);
+    await vscode.commands.executeCommand(uiCommand('memorySnapshot'));
+    const snapshot = await waitFor(
+      () => lastMemorySnapshot(),
+      (s) => s !== undefined,
+      STOP_MS,
+      'snapshot',
+    );
+    const store = profilerStore();
+
+    for (const [type, root] of [
+      [SHAPES.order.type, 'static orders'],
+      [SHAPES.shipped.type, 'static orders'],
+    ] as const) {
+      await walkReferences(store, type);
+      const panel = await waitFor(
+        () => refGraphState(),
+        (state) => state?.title === `Retention Graph — ${type}`,
+        STOP_MS,
+        `the retention graph of ${type}`,
+      );
+      assert.ok(panel);
+      assert.ok(panel.html.includes(type), `the graph names ${type}`);
+      assert.ok(panel.html.includes(root), `the graph shows the module value ${root}`);
+      assert.ok(panel.html.includes('<script nonce="'), 'a nonce-gated script');
+      assert.ok(!/basilisk/i.test(panel.html), 'no other product named');
+    }
+
+    const offered = referenceTypeCandidates(snapshot);
+    assert.ok(offered[0], 'the snapshot supplies a real first type to select');
+    const input = installUiStubs().queuePick(0);
+    try {
+      await vscode.commands.executeCommand(uiCommand('memoryReferences'));
+      await waitFor(
+        () => refGraphState()?.title,
+        (title) => title === `Retention Graph — ${offered[0]}`,
+        STOP_MS,
+        'the first runtime-ranked type opens through the real retention command',
+      );
+      assert.equal(input.log.quickPickItems.length, 1, 'one user choice');
+      const items = input.log.quickPickItems[0] as vscode.QuickPickItem[];
+      assert.deepEqual(
+        items.slice(0, offered.length).map((item) => item.label),
+        offered,
+        '[PROF-UI-REFGRAPH] the actual picker preserves the server’s ranked runtime names',
+      );
+      assert.equal(items.length, offered.length + 1, 'reported types plus the free-text option');
+      assert.equal(
+        input.log.inputBoxOptions.length,
+        0,
+        'a reported type never needs guessed input',
+      );
+      assert.deepEqual(input.log.errorMessages, [], 'the real retention walk succeeds');
+    } finally {
+      input.restore();
+    }
+
+    // Release, then collect: the bytes come back and the session keeps tracking.
+    const wire = await snapshotSession(target.pid);
+    await command(target, 'release all');
+    await command(target, 'audit resume');
+    const gc = completed(await execute<MemoryStep>('memory.gcCollect', wire));
+    assert.equal(gc.outcome.kind, 'Gc', 'a collection result');
+    const { gc: collected } = gc.outcome as { gc: GcResult };
+    assert.equal(collected.collected, 1, 'a collection was observed');
+    assert.ok(collected.freed_bytes > 0, `the released ledger is freed: ${collected.freed_bytes}`);
+    assert.equal(collected.uncollectable_count, 0, '.NET reports no uncollectable objects');
+    assert.deepEqual(collected.uncollectable, []);
+    completed(await execute<MemoryStep>('memory.stop', wire));
+
+    const toasts = await captureToasts(() =>
+      vscode.commands.executeCommand(uiCommand('memoryGcCollect')),
+    );
+    assert.equal(store.profiler.value.memory, 'active', 'an induced GC keeps tracking');
+    const said = [
+      ...toasts.info.map((t) => t.message),
+      ...toasts.warning,
+      memoryDashboardState()?.html ?? '',
+    ];
+    assert.ok(
+      said.some((text) => /freed/i.test(text)),
+      `the GC reports what it freed: ${JSON.stringify(toasts)}`,
+    );
+    assert.ok(
+      !toasts.info.some((t) => /\b1 objects?\b/.test(t.message)),
+      '`collected` is never an object count',
+    );
+    await stopTracking();
+  });
+
+  test('honest failures on F#: inspection before a snapshot says to take one; a cancelled snapshot answers -32800 and leaves the program alive; a killed program fails every later step and the UI says so', async function () {
+    this.timeout(STOP_MS * 4);
+    const { target } = live;
+    const started = await execute<MemoryStartResult>('memory.start', { pid: target.pid });
+    assert.equal(started.runtime, 'dotnet');
+    assert.deepEqual(started.mode, { kind: 'Direct' });
+    const session = { memory_session_id: started.memory_session_id };
+    for (const step of ['memory.references', 'memory.objectsByType']) {
+      const error = await executeError(step, {
+        ...session,
+        type_name: SHAPES.order.type,
+        limit: 5,
+        max_depth: 3,
+      });
+      assert.equal(error?.code, -32000, `${step}: ${error?.message}`);
+      assert.ok(
+        error.message.includes('take a snapshot'),
+        `${step} says what to do: ${error.message}`,
+      );
+    }
+
+    const source = new CancellationTokenSource();
+    const pending = lspClient().sendRequest(
+      'workspace/executeCommand',
+      { command: lspCommand('memory.snapshot'), arguments: [session] },
+      source.token,
+    );
+    setTimeout(() => {
+      source.cancel();
+    }, 50);
+    const code = await pending.then(
+      () => undefined,
+      (e: unknown) => (e as { code?: unknown }).code,
+    );
+    assert.equal(code, -32800, 'the cancelled snapshot is answered as cancelled');
+    assert.doesNotThrow(() => process.kill(target.pid, 0), 'the F# program survives the cancel');
+    assert.ok((await command(target, 'place 10')).orders !== undefined, 'and still answers');
+    assert.equal(
+      completed(await execute<MemoryStep>('memory.snapshot', session)).outcome.kind,
+      'Snapshot',
+    );
+
+    // A second program, tracked from the UI, then killed under it.
+    const victim = await Target.start(LEDGER);
+    await command(victim, 'place 200');
+    await trackMemory(victim.pid);
+    const doomed = await snapshotSession(victim.pid);
+    const killed = await execute<{ pid: number; killed: boolean }>('kill', { pid: victim.pid });
+    assert.deepEqual(killed, { pid: victim.pid, killed: true });
+    await waitFor(
+      () => {
+        try {
+          process.kill(victim.pid, 0);
+          return false;
+        } catch {
+          return true;
+        }
+      },
+      (gone) => gone,
+      STOP_MS,
+      'the program to die',
+    );
+    const before = lastMemorySnapshot();
+    const toasts = await captureToasts(() =>
+      vscode.commands.executeCommand(uiCommand('memorySnapshot')),
+    );
+    assert.ok(
+      toasts.error.length + toasts.warning.length > 0,
+      `the UI says the snapshot failed: ${JSON.stringify(toasts)}`,
+    );
+    assert.equal(lastMemorySnapshot(), before, 'no snapshot is invented for a dead program');
+    assert.equal(
+      (await executeError('memory.snapshot', doomed))?.code,
+      -32001,
+      'PROCESS_NOT_FOUND',
+    );
+    assert.equal((await executeError('memory.start', { pid: victim.pid }))?.code, -32001);
+    assert.equal((await executeError('kill', { pid: victim.pid }))?.code, -32001);
+    await stopTracking();
+    victim.stop();
+    completed(await execute<MemoryStep>('memory.stop', session));
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-soak-cpu-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-soak-cpu-e2e.test.ts
new file mode 100644
index 00000000..9f548a0a
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-soak-cpu-e2e.test.ts
@@ -0,0 +1,449 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on F#. See docs/specs/PROFILER-SPEC.md#PROFILER-SHARED-LIBRARY-VSCODE.
+//
+// CPU soak suites: long sessions over SharpLsp's two real F# programs, with the CPU and memory
+// tracks live at the same time. Every assertion comes from a spec section:
+//
+//   [PROF-CPU-START]          a second CPU session on the same PID is ALREADY_PROFILING.
+//   [PROF-CPU-SESSIONS]       cpu.list carries the session's identity for its lifetime.
+//   [PROF-CPU-SNAPSHOT]       a snapshot returns a report without ending the session.
+//   [PROF-CPU-PROGRESS]       progress begins and ends around the session.
+//   [PROF-CPU-REPORT]         samples, rate, hot functions, hot lines, artifacts.
+//   [PROF-AGGREGATION-LOGIC]  shares stay 0–100 and ranked; mixed keeps every stage hot.
+//   [PROF-AGGREGATION-THRESHOLD] functions hot at 2%, lines at 1%.
+//   [PROF-EXPORT]             artifacts exist and validate; an export error is reported, not thrown.
+//   [PROF-UI-HEATMAP]         CPU and memory never share a colour; the setting controls tint.
+//   [PROF-UI-MEMORY]          the memory dashboard stays coherent while CPU profiles.
+//   [PROF-UI-STATE]           the store, not the webview, says what is running.
+//   [PROF-MEMORY-SESSION]     stopping CPU leaves memory tracking.
+//   [PROF-DOTNET-SOURCE]      F# functions anchor in their own file at 1-based lines.
+import * as assert from 'node:assert/strict';
+import * as vscode from 'vscode';
+import {
+  formatSampleCount,
+  formatProfileDuration,
+} from '@nimblesite/lsp-profiler-ui/out/src/profiler-format';
+import {
+  appliedMemoryDecorations,
+  appliedProfileDecorations,
+  flamegraphPanelState,
+  lastProfileResult,
+  memoryStatusText,
+  processesViewState,
+  profilerStatusText,
+  recordedOperations,
+} from '@nimblesite/lsp-profiler-ui';
+import {
+  execute,
+  executeError,
+  completed,
+  profilerStore,
+  profilingSuite,
+  setProfilerSetting,
+  snapshotSession,
+  stopProfiling,
+  stopTracking,
+  trackMemory,
+  uiCommand,
+  waitFor,
+} from './profiler-kit';
+import {
+  assertAnchored,
+  assertArtifacts,
+  assertCpuIdle,
+  assertCpuLive,
+  assertHeatMap,
+  assertIdleRow,
+  assertRanked,
+  assertResultsPanel,
+  awaitLiveProgress,
+  command,
+  count,
+  endProfiling,
+  ENGINE,
+  handlerSite,
+  heatOn,
+  hotFunction,
+  isFile,
+  keys,
+  LEDGER,
+  memoryTrackOn,
+  PRICE_ALL,
+  processRow,
+  profileRow,
+  SHAPES,
+  showSources,
+  STOP_MS,
+  within,
+  wireLeak,
+} from './profiler-fsharp-kit';
+import type { MemoryStep } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  assertConfidence,
+  assertDashboard,
+  assertEveryShape,
+  assertNoPhantomMemoryPaint,
+  assertPaletteDiscipline,
+  assertSitesCoherent,
+  assertStoreCoherent,
+  assertTimelineCoherent,
+  compareMemory,
+  delay,
+  SAMPLE_MS,
+  uiSnapshot,
+} from './profiler-fsharp-soak-kit';
+
+/** The wire `cpu.list` entry, as [PROF-CPU-SESSIONS] requires it. */
+interface SessionInfo {
+  readonly session_id: string;
+  readonly pid: number;
+  readonly runtime: string;
+  readonly started_at?: string;
+}
+
+/** The live sessions the server lists. */
+async function sessions(): Promise<readonly SessionInfo[]> {
+  return (await execute<{ sessions: SessionInfo[] }>('cpu.list', {})).sessions;
+}
+
+suite('F# soak — FsPricingEngine through five workloads in one long CPU session', () => {
+  const live = profilingSuite('profiler-fs-soak-engine-', ENGINE, { stopping: endProfiling });
+
+  test('five stages, one program, one row: each stage is attributed to its own F# file with ranked shares, the artifacts validate, a second session is refused, and the heat map follows its setting', async function () {
+    this.timeout(STOP_MS * 12);
+    const { target } = live;
+    const stages = [
+      { command: 'run parse', identifier: 'parseAll', file: 'Csv.fs', first: 14, last: 39 },
+      { command: 'run price', identifier: 'applyRules', file: 'Pricing.fs', first: 10, last: 68 },
+      { command: 'run search', identifier: 'distance', file: 'Search.fs', first: 9, last: 28 },
+      { command: 'run route', identifier: 'shortestPath', file: 'Routing.fs', first: 29, last: 47 },
+      { command: 'run report', identifier: 'dailyTotals', file: 'Reports.fs', first: 13, last: 47 },
+    ] as const;
+    await showSources(
+      ENGINE,
+      stages.map((stage) => stage.file),
+    );
+
+    for (const stage of stages) {
+      // ── Interaction: switch the workload, then profile this stage from the real row.
+      const started = await command(target, stage.command);
+      assert.ok(count(started, 'iterations') >= 0, 'the workload switch is acknowledged');
+      const row = await processRow(target.pid);
+      assertIdleRow(row, target.pid, ENGINE);
+      const before = recordedOperations().length;
+      const sessionId = await profileRow(row);
+      await assertCpuLive(target.pid);
+      const top = await awaitLiveProgress();
+      assert.ok(top.length > 0, '[PROF-CPU-PROGRESS] a live top function while profiling');
+      const state = profilerStore().profiler.value;
+      assert.ok(
+        profilerStatusText()?.includes(`${formatSampleCount(state.sampleCount)} samples`),
+        '[PROF-CPU-PROGRESS] the live status shows this session’s sample count',
+      );
+      assert.ok(
+        profilerStatusText()?.includes(formatProfileDuration(state.durationSecs)),
+        '[PROF-CPU-PROGRESS] the live status shows this session’s elapsed time',
+      );
+      assert.equal(state.cpuSessionId, sessionId, 'the counters belong to the clicked F# process');
+      assertStoreCoherent();
+      assert.deepEqual(keys(), {
+        profiling: true,
+        cpuBusy: true,
+        memoryTracking: false,
+        memoryBusy: false,
+        profilerBusy: true,
+      });
+
+      // ── [PROF-CPU-SESSIONS] the live session is listed with its identity.
+      const listed = await sessions();
+      const session = listed.find((entry) => entry.session_id === sessionId);
+      assert.ok(session, 'the running session is in cpu.list');
+      assert.equal(session.pid, target.pid);
+      assert.equal(session.runtime, 'dotnet', '[PROF-RUNTIME] the F# program classifies as .NET');
+      assert.ok((session.started_at ?? '').length > 0, 'a start time is reported');
+      assert.equal(
+        listed.filter((entry) => entry.pid === target.pid).length,
+        1,
+        'one session per PID',
+      );
+
+      // ── [PROF-CPU-START] a second session on the same PID is refused, not silently stacked.
+      const refused = await executeError('cpu.start', { pid: target.pid });
+      assert.ok(refused, 'the second start fails');
+      assert.notEqual(refused.code, 0, `an error code is returned: ${JSON.stringify(refused)}`);
+      assert.equal(
+        (await sessions()).filter((entry) => entry.pid === target.pid).length,
+        1,
+        'exactly one session exists after the refusal',
+      );
+
+      // ── [PROF-CPU-SNAPSHOT] a snapshot returns a report without ending the session.
+      await delay(SAMPLE_MS);
+      await vscode.commands.executeCommand(uiCommand('profileSnapshot'));
+      const snapshot = await waitFor(
+        () => lastProfileResult(),
+        (result) => result?.sessionId === sessionId && result.totalSamples > 0,
+        STOP_MS,
+        'a mid-session snapshot',
+      );
+      assert.ok(snapshot, 'the snapshot is a full report');
+      assert.equal(
+        profilerStore().profiler.value.cpu,
+        'active',
+        'the session survived the snapshot',
+      );
+      assert.ok(snapshot.totalSamples > 0, 'the snapshot carries samples');
+      assert.ok(
+        snapshot.hotFunctions.every((fn) => fn.selfPercentage <= fn.percentage),
+        '[PROF-AGGREGATION-LOGIC] self never exceeds inclusive on every snapshot row',
+      );
+      assert.ok(
+        snapshot.hotLines.every((line) => line.line >= 1 && line.percentage > 0),
+        '[PROF-DOTNET-SOURCE] every snapshot hot line is 1-based and non-zero',
+      );
+      assert.equal(
+        (await sessions()).some((entry) => entry.session_id === sessionId),
+        true,
+        '[PROF-CPU-SNAPSHOT] the session is still active after a snapshot',
+      );
+
+      // ── [PROF-CPU-STOP] + [PROF-CPU-REPORT] + [PROF-EXPORT]: stop publishes the full report.
+      await stopProfiling(STOP_MS);
+      await assertCpuIdle(target.pid);
+      assertStoreCoherent();
+      const ops = recordedOperations().slice(before);
+      assert.ok(
+        ops.some((op) => op.startsWith('begin:')),
+        '[PROF-CPU-PROGRESS] progress began',
+      );
+      assert.ok(
+        ops.some((op) => op.startsWith('end:')),
+        '[PROF-CPU-PROGRESS] progress ended',
+      );
+      const result = lastProfileResult();
+      assert.ok(result, `a result for ${stage.command}`);
+      assert.equal(result.sessionId, sessionId, 'the result belongs to its own session');
+      assert.ok(
+        result.totalSamples >= snapshot.totalSamples,
+        '[PROF-CPU-STOP] stop includes every tick from this session’s snapshot',
+      );
+      assertRanked(result);
+      const fn = hotFunction(result, stage.identifier, stage.file);
+      assert.ok(
+        fn,
+        `[PROF-AGGREGATION-LOGIC] ${stage.identifier} is hot in ${stage.file}: ${result.hotFunctions.map((f) => f.name).join(', ')}`,
+      );
+      assert.ok(fn.percentage >= 2, '[PROF-AGGREGATION-THRESHOLD] a function is hot at 2%');
+      assert.ok(fn.percentage <= 100, 'a share is 0–100');
+      assert.ok(
+        within({ file: stage.file, first: stage.first, last: stage.last }, fn.file, fn.line ?? 0),
+        `[PROF-DOTNET-SOURCE] ${stage.identifier} anchors in its stage: ${fn.line}`,
+      );
+      assert.ok(
+        result.hotLines.some(
+          (line) =>
+            isFile(line.file, stage.file) &&
+            line.line >= stage.first &&
+            line.line <= stage.last &&
+            line.percentage >= 1,
+        ),
+        '[PROF-AGGREGATION-THRESHOLD] a hot line sits in the stage at 1% or more',
+      );
+      assertHeatMap(result, { file: stage.file, first: stage.first, last: stage.last });
+      assertResultsPanel(result, [stage.identifier]);
+      for (const fn of result.hotFunctions) {
+        assert.ok(fn.percentage >= 0 && fn.percentage <= 100, `share in range: ${fn.name}`);
+        assert.ok(fn.selfPercentage <= fn.percentage, `self ≤ inclusive: ${fn.name}`);
+        assert.ok(fn.name.length > 0, 'a hot function has a name');
+        if (fn.file !== undefined) assert.ok(fn.file.length > 0, `${fn.name} names a file`);
+      }
+      for (const line of result.hotLines) {
+        assert.ok(line.line >= 1, '[PROF-DOTNET-SOURCE] 1-based line');
+        assert.ok(line.percentage > 0 && line.percentage <= 100, 'share in range');
+        assert.ok(line.file.length > 0, 'a hot line names its file');
+      }
+      assert.ok(
+        result.hotFunctions.length > 0 && result.hotLines.length > 0,
+        '[PROF-CPU-REPORT] a hot report has both tables',
+      );
+      assertArtifacts(result, stage.identifier, stage.file);
+      assert.equal(result.exportError, undefined, '[PROF-EXPORT] no export error');
+      assert.deepEqual(
+        await sessions(),
+        [],
+        '[PROF-CPU-SESSIONS] no session is active after a stop',
+      );
+
+      // ── The program never stopped: attaching is not invasive.
+      const after = await command(target, 'stats');
+      assert.ok(count(after, 'iterations') > count(started, 'iterations'), 'the F# program ran on');
+    }
+
+    // ── [PROF-UI-HEATMAP] the setting controls tint without losing results.
+    await setProfilerSetting('showInlineHeatMap', false);
+    await command(target, 'run route');
+    await profileRow(await processRow(target.pid));
+    await awaitLiveProgress();
+    await delay(SAMPLE_MS);
+    await stopProfiling(STOP_MS);
+    const quiet = lastProfileResult();
+    assert.ok(quiet, 'a result with the heat map off');
+    assert.deepEqual(heatOn('Routing.fs'), [], 'the setting wins over the tint');
+    assertResultsPanel(quiet, ['shortestPath']);
+
+    await setProfilerSetting('showInlineHeatMap', true);
+    await command(target, 'run mixed');
+    await profileRow(await processRow(target.pid));
+    await awaitLiveProgress();
+    for (const stage of stages) {
+      await command(target, stage.command);
+      await delay(SAMPLE_MS);
+    }
+    await stopProfiling(STOP_MS);
+    const loud = lastProfileResult();
+    assert.ok(loud, 'a result with the heat map on');
+    assert.ok(heatOn('Routing.fs').length > 0, 'the tint returns with the setting');
+    assertPaletteDiscipline();
+    for (const stage of stages) {
+      assert.ok(
+        hotFunction(loud, stage.identifier, stage.file),
+        `[PROF-AGGREGATION-LOGIC] mixed keeps ${stage.identifier} hot`,
+      );
+      assertHeatMap(loud, { file: stage.file, first: stage.first, last: stage.last });
+    }
+    assert.equal(flamegraphPanelState()?.title, 'SharpLsp Profiler', 'one panel for the results');
+    assert.deepEqual(
+      appliedProfileDecorations().filter((decoration) => decoration.color === undefined),
+      [],
+      '[PROF-UI-HEATMAP] every CPU decoration carries a palette colour',
+    );
+    await command(target, 'idle');
+  });
+});
+
+suite('F# soak — FsOrderLedger with CPU and memory tracking at once', () => {
+  const live = profilingSuite('profiler-fs-soak-joint-', LEDGER, { stopping: endProfiling });
+
+  test('the burn loop is the hotspot while memory tracks the same program: both tracks paint at once in different colours, stopping CPU leaves memory live, and the diff is taken on a running program', async function () {
+    this.timeout(STOP_MS * 8);
+    const { target } = live;
+
+    // ── Interaction 1: the burn loop and the first batch, with both sources on screen.
+    const warm = await command(target, 'burn on');
+    assert.equal(count(warm, 'orders'), 0, 'a fresh burn starts from nothing');
+    const batch = await command(target, 'place 300');
+    assert.equal(count(batch, 'handlers'), 300, 'one handler per order');
+    await showSources(LEDGER, ['Ledger.fs', 'Bus.fs', 'History.fs']);
+
+    // ── Interaction 2: [PROFILER-SHARED-LIBRARY-VSCODE] both one-click flows on one program.
+    await trackMemory(target.pid);
+    assert.equal(profilerStore().profiler.value.memory, 'active', 'memory is tracking first');
+    const row = await processRow(target.pid);
+    const sessionId = await profileRow(row);
+    await assertCpuLive(target.pid);
+    assert.equal(
+      keys().memoryTracking,
+      true,
+      '[PROF-MEMORY-SESSION] memory survives the CPU start',
+    );
+    await awaitLiveProgress();
+
+    // ── Interaction 3: [PROF-CPU-REPORT] the burn loop is the hotspot of this session.
+    await delay(SAMPLE_MS * 2);
+    await vscode.commands.executeCommand(uiCommand('profileSnapshot'));
+    const liveResult = await waitFor(
+      () => lastProfileResult(),
+      (result) => result?.sessionId === sessionId && result.totalSamples > 0,
+      STOP_MS,
+      'a CPU snapshot of the burning F# program',
+    );
+    assert.ok(liveResult, 'a snapshot exists');
+    assertRanked(liveResult);
+    assertStoreCoherent();
+    assert.ok(
+      liveResult.hotFunctions.some((fn) => within(PRICE_ALL, fn.file, fn.line ?? 0)),
+      `the burn loop is hot: ${liveResult.hotFunctions.map((f) => f.name).join(', ')}`,
+    );
+    assertHeatMap(liveResult, PRICE_ALL);
+    await vscode.commands.executeCommand(uiCommand('profileShowResults'));
+    assertResultsPanel(liveResult, ['priceAll']);
+    assert.ok(liveResult.totalSamples > 0, 'samples were recorded');
+    assert.equal(profilerStore().profiler.value.memory, 'active', 'memory kept tracking');
+
+    // ── Interaction 4: [PROF-UI-HEATMAP] the memory track paints during the CPU session too.
+    const snap = await uiSnapshot();
+    const wire = await snapshotSession(target.pid);
+    assertAnchored(snap, SHAPES.order, 300);
+    assert.equal(handlerSite(snap).count, 300, 'the handler closures are all reachable');
+    assertDashboard(snap, 1, [SHAPES.order.type]);
+    assertNoPhantomMemoryPaint(snap);
+    assertSitesCoherent(snap);
+    assertTimelineCoherent(snap);
+    assertPaletteDiscipline();
+    assertEveryShape(snap, batch);
+    assert.ok(memoryStatusText()?.includes('tracking'), 'memory still tracks during the burn');
+    assert.ok(heatOn('Ledger.fs').length > 0, 'the CPU heat map paints Ledger.fs');
+    assert.ok(memoryTrackOn('Ledger.fs').length > 0, 'the memory track paints Ledger.fs');
+    for (const cpuLine of heatOn('Ledger.fs')) {
+      assert.ok(
+        memoryTrackOn('Ledger.fs').every((memoryLine) => cpuLine.color !== memoryLine.color),
+        'CPU and memory never share a colour on one file',
+      );
+    }
+
+    // ── Interaction 5: more work in the same session grows the heap, not the sample count alone.
+    const grew = await command(target, 'place 200');
+    assert.equal(count(grew, 'orders'), 500, 'the second batch lands in the same session');
+    const growth = await compareMemory(wire);
+    assertConfidence(growth.leaks, SHAPES.order.type, 'Low', ['Ledger.fs']);
+    assert.equal(
+      wireLeak(growth.leaks, SHAPES.order.type)?.count_growth,
+      200,
+      '[PROF-MEMORY-COMPARE] exactly the new F# orders grew',
+    );
+    const after = await uiSnapshot(snap);
+    assert.ok(after.currentMemory >= snap.currentMemory, 'the heap grew under the CPU session');
+    assertAnchored(after, SHAPES.order, 500);
+    assert.equal(after.timeline.length, 2, '[PROF-MEMORY-TIMELINE] one point per snapshot');
+    assertSitesCoherent(after);
+    assertTimelineCoherent(after);
+    assertPaletteDiscipline();
+    assertEveryShape(after, grew);
+
+    // ── Interaction 6: stopping CPU leaves memory tracking and clears only the heat map.
+    await stopProfiling(STOP_MS);
+    await assertCpuIdle(target.pid);
+    assert.equal(keys().memoryTracking, true, 'stopping CPU never stops memory');
+    assert.equal(profilerStore().profiler.value.memory, 'active', 'the memory session is intact');
+    assert.ok(memoryStatusText()?.includes('tracking'), `memory chrome: ${memoryStatusText()}`);
+    assert.equal(profilerStatusText(), undefined, 'the CPU chrome is gone');
+    assert.ok(memoryTrackOn('Ledger.fs').length > 0, 'the memory track stays painted');
+
+    // ── Interaction 7: the process still answers after CPU stop, while memory tracks it.
+    assert.equal(count(await command(target, 'burn off'), 'orders'), 500);
+
+    // ── Interaction 8: stop everything; nothing survives.
+    await command(target, 'burn off');
+    await command(target, 'release all');
+    await stopTracking();
+    assert.equal(memoryStatusText(), undefined, 'the memory chrome hides');
+    assert.deepEqual(appliedMemoryDecorations(), [], 'the memory track clears');
+    assert.ok(heatOn('Ledger.fs').length > 0, 'the completed CPU report remains painted');
+    assert.equal(
+      flamegraphPanelState() !== undefined,
+      true,
+      '[PROF-UI-STATE] the results stay readable',
+    );
+    assert.deepEqual(keys(), {
+      profiling: false,
+      cpuBusy: false,
+      memoryTracking: false,
+      memoryBusy: false,
+      profilerBusy: false,
+    });
+    assert.equal(processesViewState().badge, undefined, 'no badge once idle');
+    completed(await execute<MemoryStep>('memory.stop', wire));
+    assert.deepEqual(await sessions(), [], 'no CPU session is left running');
+    assertStoreCoherent();
+    assertPaletteDiscipline();
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-soak-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-soak-e2e.test.ts
new file mode 100644
index 00000000..2a8804c9
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-soak-e2e.test.ts
@@ -0,0 +1,487 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on real F# processes.
+// Contracts: docs/specs/PROFILER-SPEC.md and lspkit/docs/specs/LSP-PROFILER-SPEC.md.
+// Each interaction cites the confidence, retention, source and UI requirements it enforces.
+import * as assert from 'node:assert/strict';
+import {
+  appliedMemoryDecorations,
+  memoryStatusText,
+  processesViewState,
+  profilerStatusText,
+  refGraphState,
+} from '@nimblesite/lsp-profiler-ui';
+import { walkReferences } from '@nimblesite/lsp-profiler-ui/out/src/memory-ref-picker';
+import type { MemoryStep } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import {
+  completed,
+  execute,
+  profilerStore,
+  profilingSuite,
+  snapshotSession,
+  stopTracking,
+  trackMemory,
+} from './profiler-kit';
+import {
+  assertAnchored,
+  assertIdleRow,
+  command,
+  count,
+  endProfiling,
+  handlerSite,
+  isFile,
+  keys,
+  LEDGER,
+  LEDGER_FILES,
+  LEAK_PALETTE,
+  leakBadge,
+  memoryTrackOn,
+  processRow,
+  SHAPES,
+  showSources,
+  STOP_MS,
+  VERSIONED,
+  wireLeak,
+} from './profiler-fsharp-kit';
+import {
+  assertConfidence,
+  assertDashboard,
+  assertEveryShape,
+  assertNoPhantomMemoryPaint,
+  assertPaletteDiscipline,
+  assertSitesCoherent,
+  assertStoreCoherent,
+  assertTimelineCoherent,
+  compareMemory,
+  MIB,
+  uiSnapshot,
+} from './profiler-fsharp-soak-kit';
+
+/** `lspProfiler/memory/start`, exactly as [PROF-MEMORY-START] shapes it. */
+interface MemoryStart {
+  readonly memory_session_id: string;
+  readonly runtime: string;
+  readonly mode: { readonly kind: string };
+  readonly step: MemoryStep;
+}
+
+suite('F# soak — FsOrderLedger: the leak-confidence ladder over one long session', () => {
+  const live = profilingSuite('profiler-fs-soak-confidence-', LEDGER, { stopping: endProfiling });
+
+  test('Low → Medium → High by consecutive growths, then a 12 MiB single growth as Medium, then release resets the streak to nothing — asserting the dashboard after every one of the ten interactions', async function () {
+    this.timeout(STOP_MS * 10);
+    const { target } = live;
+
+    // ── Interaction 1: [PROF-MEMORY-START] opens a Direct session; start acknowledges it.
+    await showSources(LEDGER, LEDGER_FILES);
+    const started = await execute<MemoryStart>('memory.start', { pid: target.pid });
+    assert.ok(started.memory_session_id.length > 0, 'a session id');
+    assert.equal(started.runtime, 'dotnet', '[PROF-RUNTIME] an F# program is a .NET runtime');
+    assert.equal(started.mode.kind, 'Direct', '[PROF-MEMORY-MODE] .NET reads the live heap itself');
+    assert.equal(started.step.kind, 'Completed', 'a Direct session needs no evaluation script');
+    if (started.step.kind === 'Completed') {
+      assert.equal(
+        started.step.result.memory_session_id,
+        started.memory_session_id,
+        'the first step belongs to its own session',
+      );
+      assert.equal(
+        started.step.result.outcome.kind,
+        'Ack',
+        '[PROF-DOTNET-MEMORY] a wire start does not capture a baseline',
+      );
+      assert.ok(
+        started.step.result.diagnostics.every((entry) => entry.uri.length > 0),
+        'a diagnostic always names its URI',
+      );
+    }
+    completed(
+      await execute<MemoryStep>('memory.stop', { memory_session_id: started.memory_session_id }),
+    );
+
+    // The UI starts its own session and owns exactly one.
+    await trackMemory(target.pid);
+    assert.equal(profilerStore().profiler.value.memory, 'active', 'the UI tracks the program');
+    assert.deepEqual(keys(), {
+      profiling: false,
+      cpuBusy: false,
+      memoryTracking: true,
+      memoryBusy: true,
+      profilerBusy: true,
+    });
+    assert.ok(memoryStatusText()?.includes('tracking'), `status: ${memoryStatusText()}`);
+    assert.equal(profilerStatusText(), undefined, 'no CPU chrome while only memory runs');
+
+    // ── Interaction 2: [PROF-UI-PROCESSES] + [PROF-UI-CAPABILITIES] — the row of a live program.
+    const row = await processRow(target.pid);
+    assertIdleRow(row, target.pid, LEDGER);
+    assert.equal(row.process.runtime, 'dotnet', 'classified as .NET');
+    assert.equal(row.contextValue, 'processDebuggee', 'direct mode offers Track Memory');
+    assert.equal(row.command, undefined, 'an assembly entry is never opened as source');
+
+    // ── Interaction 3: the baseline. [PROF-MEMORY-OUTCOME] snapshot = baseline + timeline point.
+    const seeded = await command(target, 'place 500');
+    assert.equal(count(seeded, 'orders'), 500, 'every order is live');
+    assert.equal(count(seeded, 'handlers'), 500, 'one never-removed handler per order');
+    for (const status of ['pending', 'paid', 'shipped', 'cancelled']) {
+      assert.equal(count(seeded, status), 125, `ids cycle evenly: ${status}`);
+    }
+    const baseline = await uiSnapshot();
+    const wire = await snapshotSession(target.pid);
+    assertDashboard(baseline, 1, [SHAPES.order.type, SHAPES.paid.type]);
+    for (const shape of [
+      SHAPES.order,
+      SHAPES.customer,
+      SHAPES.line,
+      SHAPES.paid,
+      SHAPES.shipped,
+      SHAPES.cancelled,
+    ]) {
+      assertAnchored(baseline, shape, count(seeded, shape.live));
+    }
+    assert.equal(handlerSite(baseline).count, 500, 'one handler closure per subscription');
+    assertNoPhantomMemoryPaint(baseline);
+    assertSitesCoherent(baseline);
+    assertTimelineCoherent(baseline);
+    assertPaletteDiscipline();
+    assertStoreCoherent();
+    assertEveryShape(baseline, seeded);
+
+    // ── Interaction 4: growth #1 → Low. [PROF-MEMORY-CONFIDENCE] one growth is Low.
+    const first = await command(target, 'place 500');
+    assert.equal(count(first, 'handlers'), 1_000, 'the handlers accumulate');
+    const low = await compareMemory(wire);
+    assertConfidence(low.leaks, SHAPES.order.type, 'Low', ['Ledger.fs']);
+    assertConfidence(low.leaks, handlerSite(baseline).typeName!, 'Low', ['Bus.fs']);
+    const lowSnap = await uiSnapshot(baseline);
+    assert.ok(lowSnap.currentMemory > baseline.currentMemory, 'the heap grew');
+    assertAnchored(lowSnap, SHAPES.order, 1_000);
+    assertNoPhantomMemoryPaint(lowSnap);
+    assertSitesCoherent(lowSnap);
+    assertTimelineCoherent(lowSnap);
+    assertPaletteDiscipline();
+    assertStoreCoherent();
+    assertEveryShape(lowSnap, first);
+
+    // ── Interaction 5: growth #2 → Medium (two consecutive growths).
+    const second = await command(target, 'place 500');
+    assertConfidence((await compareMemory(wire)).leaks, SHAPES.order.type, 'Medium', ['Ledger.fs']);
+    const mediumSnap = await uiSnapshot(lowSnap);
+    assert.ok(mediumSnap.currentMemory >= lowSnap.currentMemory, 'the heap only grew');
+    assert.equal(mediumSnap.timeline.length, 3, 'a third timeline point');
+    assertDashboard(mediumSnap, 3, [SHAPES.order.type]);
+    assertSitesCoherent(mediumSnap);
+    assertTimelineCoherent(mediumSnap);
+    assertPaletteDiscipline();
+    assertEveryShape(mediumSnap, second);
+
+    // ── Interaction 6: growth #3 → High (three consecutive growths).
+    const third = await command(target, 'place 500');
+    assertConfidence((await compareMemory(wire)).leaks, SHAPES.order.type, 'High', ['Ledger.fs']);
+    const highSnap = await uiSnapshot(mediumSnap);
+    assert.equal(handlerSite(highSnap).count, 2_000, 'two thousand never-removed handlers');
+    assertAnchored(highSnap, SHAPES.order, 2_000);
+    assertNoPhantomMemoryPaint(highSnap);
+    assertSitesCoherent(highSnap);
+    assertTimelineCoherent(highSnap);
+    assertPaletteDiscipline();
+    assertEveryShape(highSnap, third);
+    for (const decoration of memoryTrackOn('Ledger.fs').slice(0, 20)) {
+      assert.ok(
+        highSnap.topAllocations.some(
+          (site) => isFile(site.file, 'Ledger.fs') && site.line === decoration.line,
+        ),
+        `Ledger.fs:${decoration.line} is painted from a reported site`,
+      );
+    }
+
+    // ── Interaction 7: [PROF-MEMORY-CONFIDENCE] "one growth over 10 MiB → Medium", single growth.
+    const flat = await compareMemory(wire);
+    assert.equal(
+      wireLeak(flat.leaks, 'System.Byte[]'),
+      undefined,
+      'a flat comparison resets the earlier Order payload array growth streak',
+    );
+    const bloom = await command(target, 'blob 12');
+    assert.equal(count(bloom, 'blobs'), 1, 'one retained 12 MiB array');
+    assertConfidence((await compareMemory(wire)).leaks, 'System.Byte[]', 'Medium', []);
+    const bloomSnap = await uiSnapshot(highSnap);
+    assert.ok(
+      bloomSnap.currentMemory > highSnap.currentMemory + 8 * MIB,
+      `12 MiB of retained array shows up: ${bloomSnap.currentMemory - highSnap.currentMemory}`,
+    );
+    assert.equal(bloomSnap.timeline.length, 5, 'the blob snapshot is the fifth point');
+    assertSitesCoherent(bloomSnap);
+    assertTimelineCoherent(bloomSnap);
+    assertPaletteDiscipline();
+    const bigSite = bloomSnap.topAllocations.find((site) => site.typeName === 'System.Byte[]');
+    assert.ok(bigSite, 'the retained array is a top site');
+    assert.ok(bigSite.size > 8 * MIB, `the site is the 12 MiB array: ${bigSite.size}`);
+
+    // ── Interaction 8: a non-growing diff resets the streak and frees the blob.
+    const freed = await command(target, 'release all');
+    assert.equal(count(freed, 'blobs'), 0, 'release all drops the blob');
+    assert.equal(count(freed, 'handlers'), 2_000, 'release all never clears the Event handlers');
+    const afterRelease = await compareMemory(wire);
+    assert.equal(
+      leakBadge('Ledger.fs', SHAPES.order.line),
+      undefined,
+      'the old Order badge clears',
+    );
+    const resetSnap = await uiSnapshot(bloomSnap);
+    assert.ok(resetSnap.currentMemory < bloomSnap.currentMemory, 'the heap shrank');
+    assertSitesCoherent(resetSnap);
+    assertTimelineCoherent(resetSnap);
+    assertPaletteDiscipline();
+    assert.equal(
+      wireLeak(afterRelease.leaks, 'System.Byte[]'),
+      undefined,
+      '[PROF-MEMORY-CONFIDENCE] freed allocations are never suspected',
+    );
+    assert.equal(
+      wireLeak(afterRelease.leaks, SHAPES.order.type),
+      undefined,
+      'a non-growing diff resets the order streak',
+    );
+    assert.ok(
+      afterRelease.diff.total_freed >= 12 * MIB,
+      `the freed 12 MiB counts toward the freed total: ${afterRelease.diff.total_freed}`,
+    );
+
+    // ── Interaction 9: [PROF-UI-MEMORY] the bands reach the badges, in red and uppercase.
+    const badges = LEDGER_FILES.flatMap((file) =>
+      memoryTrackOn(file).filter((decoration) => leakBadge(file, decoration.line) === decoration),
+    );
+    for (const badge of badges) {
+      assert.ok(
+        LEAK_PALETTE.includes(badge.color),
+        `leak badges are red, never purple: ${badge.color}`,
+      );
+      assert.ok(
+        ['LOW', 'MEDIUM', 'HIGH', 'DEFINITE'].some((band) => badge.contentText.includes(band)),
+        `the badge spells a band: ${badge.contentText}`,
+      );
+    }
+
+    // ── Interaction 10: stop clears the track and every key, and leaves nothing running.
+    await stopTracking();
+    assert.equal(profilerStore().profiler.value.memory, 'idle');
+    assert.equal(memoryStatusText(), undefined, 'the memory status bar hides');
+    assert.deepEqual(keys(), {
+      profiling: false,
+      cpuBusy: false,
+      memoryTracking: false,
+      memoryBusy: false,
+      profilerBusy: false,
+    });
+    assert.deepEqual(appliedMemoryDecorations(), [], '[PROF-UI-HEATMAP] the memory track clears');
+    assert.equal(processesViewState().badge, undefined, 'no badge once idle');
+    completed(await execute<MemoryStep>('memory.stop', wire));
+    assertStoreCoherent();
+    assert.deepEqual(
+      (await execute<{ sessions: unknown[] }>('cpu.list', {})).sessions,
+      [],
+      '[PROF-MEMORY-SESSION] the memory session never created a CPU session',
+    );
+  });
+});
+
+suite('F# soak — FsOrderLedger: mailbox, cache and immutable history retention', () => {
+  const live = profilingSuite('profiler-fs-soak-retention-', LEDGER, { stopping: endProfiling });
+
+  test('a paused mailbox and a memoize cache in one session: the queue is a leak while paused and gone after resume, the cache never evicts, and the undo history is a closed generic record over FSharpMap', async function () {
+    this.timeout(STOP_MS * 8);
+    const { target } = live;
+    await showSources(LEDGER, [
+      'Audit.fs',
+      'Quotes.fs',
+      'History.fs',
+      'Ledger.fs',
+      'Rejections.fs',
+    ]);
+    await trackMemory(target.pid);
+
+    // ── Interaction 1: pause the auditor, then grow it. [PROF-MEMORY-OUTCOME] mailbox leak.
+    await command(target, 'audit pause');
+    const queued = await command(target, 'place 400');
+    assert.equal(count(queued, 'audits'), 400, 'a paused auditor retains every posted entry');
+    assert.equal(count(queued, 'orders'), 400, 'the orders still land');
+    const first = await uiSnapshot();
+    const wire = await snapshotSession(target.pid);
+    assertAnchored(first, SHAPES.audit, 400);
+    assert.equal(
+      handlerSite(first).count,
+      count(queued, 'handlers'),
+      'all retained handlers are counted',
+    );
+    assertSitesCoherent(first);
+    assertTimelineCoherent(first);
+    assertPaletteDiscipline();
+    assertStoreCoherent();
+
+    // ── Interaction 2: quote 400 distinct SKUs. [PROF-MEMORY-OUTCOME] memoize cache leak.
+    const quoted = await command(target, 'quote 400');
+    assert.equal(count(quoted, 'quotes'), 400, 'each new SKU is cached');
+    const growth = await compareMemory(wire);
+    assertConfidence(growth.leaks, SHAPES.quote.type, 'Low', ['Quotes.fs']);
+    const second = await uiSnapshot(first);
+    assertAnchored(second, SHAPES.quote, 400);
+    assert.ok(second.currentMemory >= first.currentMemory, 'the cache grows the heap');
+    assertSitesCoherent(second);
+    assertTimelineCoherent(second);
+    assertPaletteDiscipline();
+    assert.equal(second.timeline.length, 2, '[PROF-MEMORY-TIMELINE] a point per snapshot');
+
+    // ── Interaction 3: the undo history keeps every immutable Map, as a closed generic.
+    await command(target, 'history');
+    const historic = await command(target, 'history');
+    assert.equal(count(historic, 'snapshots'), 2, 'two versioned snapshots recorded');
+    const third = await uiSnapshot(second);
+    // A two-object type need not rank among the top 50 snapshot sites. Inspect it explicitly.
+    const versioned = completed(
+      await execute<MemoryStep>('memory.objectsByType', {
+        memory_session_id: third.memorySessionId,
+        type_name: VERSIONED,
+        limit: 2,
+      }),
+    );
+    assert.ok(versioned.outcome.kind === 'Objects', 'the generic type has an Objects result');
+    const objects = versioned.outcome.objects;
+    assert.equal(objects.total_count, 2, 'both closed generic history records are live');
+    assert.equal(objects.objects.length, 2, 'both records are returned at limit two');
+    assert.ok(
+      objects.objects.every((item) => item.type_name === VERSIONED),
+      '[PROF-DOTNET-HEAP-GRAPH] each object carries the full closed FSharpMap type',
+    );
+    const site = objects.type_summary.find((entry) => entry.type_name === VERSIONED);
+    assert.ok(site, '[PROF-DOTNET-MEMORY] the requested generic type has its own summary row');
+    assert.equal(site.count, 2, 'the summary counts both live records');
+    assert.equal(site.size_bytes, objects.total_bytes, 'the summary agrees with the object total');
+    assert.ok(site.size_bytes > 0, 'the history records cost live bytes');
+    assertDashboard(third, 3, [SHAPES.order.type, SHAPES.quote.type]);
+    // Grow the undo history until the generic record is a ranked site as well.
+    for (let index = 2; index < 400; index += 1) await command(target, 'history');
+    const history = await uiSnapshot(third);
+    const anchored = history.topAllocations.find((entry) => entry.typeName === VERSIONED);
+    assert.ok(anchored, 'the grown F# history is a ranked allocation site');
+    assertAnchored(history, { type: VERSIONED, file: 'History.fs', line: 14 }, 400);
+    assert.ok(anchored.size > site.size_bytes, 'growing history increases its live bytes');
+    assertDashboard(history, 4, [VERSIONED]);
+    await walkReferences(profilerStore(), VERSIONED);
+    assert.equal(
+      refGraphState()?.title,
+      `Retention Graph — ${VERSIONED}`,
+      '[PROF-UI-REFGRAPH] the full F# generic name reaches the real retention panel',
+    );
+    assertSitesCoherent(third);
+    assertTimelineCoherent(third);
+    assertPaletteDiscipline();
+
+    // ── Interaction 4: a retained mailbox is not evidence of growth; add entries then compare.
+    const more = await command(target, 'place 400');
+    const queuedGrowth = await compareMemory(wire);
+    assertConfidence(queuedGrowth.leaks, SHAPES.audit.type, 'Low', ['Audit.fs']);
+    assert.equal(wireLeak(queuedGrowth.leaks, SHAPES.audit.type)?.count_growth, 400);
+    assert.equal(count(more, 'audits'), 800);
+    for (const shape of [SHAPES.quote, SHAPES.rejected, SHAPES.audit]) {
+      assert.equal(
+        memoryTrackOn(shape.file).some((decoration) => decoration.line === shape.line),
+        shape.type !== SHAPES.rejected.type,
+        `${shape.type} is painted only when it is a site`,
+      );
+    }
+
+    // ── Interaction 5: resume drains the queue; the next snapshot cannot see it.
+    const drained = await command(target, 'audit resume');
+    assert.equal(count(drained, 'audits'), 0, 'resuming drains every queued entry');
+    const fourth = await uiSnapshot(third);
+    assert.equal(
+      fourth.topAllocations.some((site) => site.typeName === SHAPES.audit.type),
+      false,
+      'drained audit entries are gone from the live heap',
+    );
+    assertAnchored(fourth, SHAPES.quote, 400);
+    assert.equal(
+      fourth.timeline.length,
+      5,
+      'one timeline point per snapshot, including history growth',
+    );
+    const firstPoint = fourth.timeline[0];
+    const latestPoint = fourth.timeline[fourth.timeline.length - 1];
+    assert.ok(firstPoint && latestPoint, 'the timeline carries its endpoints');
+    assert.ok(
+      latestPoint.peakMemory >= firstPoint.peakMemory,
+      '[PROF-MEMORY-TIMELINE] peak never falls below the first point',
+    );
+    for (const point of fourth.timeline) {
+      assert.ok(point.peakMemory >= point.currentMemory, 'peak is never below current');
+      assert.ok(point.gcObjects > 0, 'a point counts live objects');
+    }
+    assertNoPhantomMemoryPaint(fourth);
+    assertSitesCoherent(fourth);
+    assertTimelineCoherent(fourth);
+    assertPaletteDiscipline();
+
+    // ── Interaction 6: [PROF-MEMORY-COMPARE] sites match by location, so the cache site is stable.
+    const quotesBefore = fourth.topAllocations.find((site) => site.typeName === SHAPES.quote.type);
+    await command(target, 'quote 400');
+    const fifth = await uiSnapshot(fourth);
+    const quotesAfter = fifth.topAllocations.find((site) => site.typeName === SHAPES.quote.type);
+    assert.ok(quotesAfter, 'the cache is still a site');
+    assert.equal(quotesAfter.line, SHAPES.quote.line, 'the same location matches the earlier site');
+    assert.ok(quotesAfter.count > (quotesBefore?.count ?? 0), 'the cache grew in count');
+    assert.ok(quotesAfter.size > (quotesBefore?.size ?? 0), 'the cache grew in bytes');
+    assert.ok(quotesAfter.size >= (quotesBefore?.size ?? 0), 'growth is never negative here');
+    assertSitesCoherent(fifth);
+    assertTimelineCoherent(fifth);
+    assertPaletteDiscipline();
+
+    // ── Interaction 7: release orders leaves the true leaks standing.
+    const released = await command(target, 'release orders');
+    assert.equal(count(released, 'orders'), 0, 'the ledger holds no order');
+    assert.equal(count(released, 'quotes'), 800, 'the memoize cache still holds every SKU');
+    assert.equal(
+      count(released, 'handlers'),
+      count(more, 'handlers'),
+      'the handlers are never removed',
+    );
+    assert.equal(count(released, 'audits'), 0, 'the mailbox is still drained');
+    const sixth = await uiSnapshot(fifth);
+    assertAnchored(sixth, SHAPES.order, 400);
+    assert.equal(
+      count(released, 'snapshots'),
+      400,
+      'every history record still retains the first 400 orders',
+    );
+    assert.equal(
+      handlerSite(sixth).count,
+      count(released, 'handlers'),
+      'the closure leak survives',
+    );
+    assertAnchored(sixth, SHAPES.quote, 800);
+    assert.ok(sixth.currentMemory <= fifth.currentMemory, 'releasing orders shrank the heap');
+    assertNoPhantomMemoryPaint(sixth);
+    assertSitesCoherent(sixth);
+    assertTimelineCoherent(sixth);
+    assertPaletteDiscipline();
+    assertStoreCoherent();
+
+    // Only dropping history too makes the Orders unreachable ([PROF-DOTNET-HEAP-MARK]).
+    await command(target, 'release all');
+    const unrooted = await uiSnapshot(sixth);
+    assert.equal(
+      unrooted.topAllocations.some((site) => site.typeName === SHAPES.order.type),
+      false,
+    );
+    assertAnchored(unrooted, SHAPES.quote, 800);
+
+    // ── Interaction 8: stop.
+    await stopTracking();
+    completed(await execute<MemoryStep>('memory.stop', wire));
+    assert.equal(memoryStatusText(), undefined, 'the chrome hides');
+    assert.deepEqual(appliedMemoryDecorations(), [], 'no decorations survive the stop');
+    assert.deepEqual(
+      (await execute<{ sessions: unknown[] }>('cpu.list', {})).sessions,
+      [],
+      'no CPU session was ever opened by a memory test',
+    );
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-fsharp-soak-kit.ts b/src/editors/vscode/src/test/suite/profiler-fsharp-soak-kit.ts
new file mode 100644
index 00000000..f9e60e3d
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-fsharp-soak-kit.ts
@@ -0,0 +1,449 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on F#. See docs/specs/PROFILER-SPEC.md#PROFILER-SHARED-LIBRARY-VSCODE.
+//
+// Shared seams of the F# soak suites: dashboard reads, session identity, and the assertion groups
+// both files prove. Each helper names the spec section it enforces:
+//
+//   [PROF-UI-MEMORY]          dashboard contents: timeline, current/peak/objects, runtime type
+//                             names, growth table, suspected leaks with confidence.
+//   [PROF-MEMORY-OUTCOME]     a snapshot becomes the baseline, the timeline point, the heap profile.
+//   [PROF-MEMORY-TIMELINE]    one point per snapshot; peak never falls.
+//   [PROF-MEMORY-HEAPPROFILE] every snapshot writes a V8 .heapprofile.
+//   [PROF-MEMORY-COMPARE]     sites match by location; net = grown − freed.
+//   [PROF-MEMORY-CONFIDENCE]  the ladder arrives from the server; the UI spells it uppercase.
+//   [PROF-UI-WEBVIEW]         nonce-gated CSP, brand, palette discipline.
+//   [PROF-DOTNET-SOURCE]      anchors sit where the F# value is built.
+//   [PROF-INVARIANTS]         the backend supplies the order and the numbers; the UI never re-ranks.
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as vscode from 'vscode';
+import {
+  embeddedLeaks,
+  execute,
+  lspClient,
+  profilerStore,
+  uiCommand,
+  waitFor,
+} from './profiler-kit';
+import { captureToasts } from './profiler-ui-helpers';
+import {
+  lastMemorySnapshot,
+  memoryDashboardState,
+  processesViewState,
+} from '@nimblesite/lsp-profiler-ui';
+import {
+  isFile,
+  keys,
+  LEDGER_FILES,
+  LEAK_PALETTE,
+  leakBadge,
+  MEMORY_PALETTE,
+  memoryTrackOn,
+  SHAPES,
+  assertAnchored,
+  count,
+  type Counts,
+  STOP_MS,
+  wireDiff,
+} from './profiler-fsharp-kit';
+import type {
+  MemoryOutcome,
+  MemoryStep,
+  ProfileReport,
+  SuspectedLeak,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import type { MemoryDashboardSnapshot } from '@nimblesite/lsp-profiler-ui/out/src/memory-dashboard';
+
+export const SAMPLE_MS = 3_000;
+export const MIB = 1024 * 1024;
+/** [PROF-ERRORS] classified protocol failures. */
+export const CODE = {
+  OTHER: -32_000,
+  PROCESS_NOT_FOUND: -32_001,
+  UNSUPPORTED_RUNTIME: -32_002,
+  ALREADY_PROFILING: -32_004,
+  INVALID_PARAMS: -32_602,
+} as const;
+/** [PROF-MEMORY-CONFIDENCE] grades as the wire spells them ([PROF-WIRE-GEN]). */
+export const BANDS = ['Low', 'Medium', 'High', 'Definite'] as const;
+export type Band = (typeof BANDS)[number];
+/** The badge's band word, matching the kit's own leak-badge convention. */
+const BADGE = /\b(LOW|MEDIUM|HIGH|DEFINITE)\b/;
+const BAND_LABELS = ['LOW', 'MEDIUM', 'HIGH', 'DEFINITE'] as const;
+
+export async function delay(ms: number): Promise<void> {
+  await new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/** The UI snapshot after `previous`, through the real dashboard command. */
+export async function uiSnapshot(
+  previous?: MemoryDashboardSnapshot,
+): Promise<MemoryDashboardSnapshot> {
+  const before = previous ?? lastMemorySnapshot();
+  const session = trackedSession();
+  const toasts = await captureToasts(() =>
+    vscode.commands.executeCommand(uiCommand('memorySnapshot')),
+  );
+  assert.deepEqual(toasts.error, [], 'the F# snapshot succeeds');
+  assert.deepEqual(toasts.warning, [], 'the F# snapshot is not refused');
+  const snapshot = await waitFor(
+    () => lastMemorySnapshot(),
+    (snap) =>
+      snap?.memorySessionId === session.memory_session_id && snap.snapshotId !== before?.snapshotId,
+    STOP_MS,
+    'a newer snapshot in the dashboard',
+  );
+  assert.ok(snapshot, 'the dashboard holds a snapshot');
+  return snapshot;
+}
+
+/** The live memory session the UI is tracking; fails rather than inventing one. */
+export function trackedSession(): { memory_session_id: string } {
+  const id = profilerStore().profiler.value.memorySessionId;
+  assert.ok(id !== undefined && id.length > 0, 'the UI store holds a memory session id');
+  return { memory_session_id: id };
+}
+
+/**
+ * [PROF-UI-MEMORY] + [PROF-MEMORY-TIMELINE] + [PROF-MEMORY-HEAPPROFILE]: the dashboard is
+ * branded, its numbers are coherent, each snapshot added exactly one timeline point and wrote a
+ * .heapprofile, and F# type names reach it unmodified.
+ */
+export function assertDashboard(
+  snapshot: MemoryDashboardSnapshot,
+  points: number,
+  types: readonly string[],
+): void {
+  const dashboard = memoryDashboardState();
+  assert.ok(dashboard, 'the dashboard is open');
+  assert.equal(dashboard.title, 'SharpLsp Memory Dashboard');
+  assert.ok(dashboard.html.includes('<span class="accent">SHARPLSP</span> MEMORY'), 'branded');
+  assert.ok(!/basilisk/i.test(dashboard.html), 'no other product is named');
+  assert.ok(dashboard.html.includes('<script nonce="'), '[PROF-UI-WEBVIEW] nonce-gated CSP');
+  assert.equal(snapshot.timeline.length, points, 'one timeline point per snapshot');
+  assert.ok(snapshot.peakMemory >= snapshot.currentMemory, 'peak is never below current');
+  assert.ok(snapshot.gcObjects > 0, 'live objects are counted');
+  assert.deepEqual(snapshot.gcCounts, [], 'generation bytes are never shown as counts');
+  const listed = snapshot.topAllocations.reduce((sum, site) => sum + site.size, 0);
+  assert.ok(listed <= snapshot.currentMemory, `top sites (${listed}) fit in the live heap`);
+  assert.ok(
+    fs.existsSync(snapshot.heapProfilePath),
+    `[PROF-MEMORY-HEAPPROFILE] the .heapprofile is written: ${snapshot.heapProfilePath}`,
+  );
+  for (const type of types) assert.ok(dashboard.html.includes(type), `the dashboard names ${type}`);
+  const ordered = snapshot.topAllocations.map((site) => site.size);
+  assert.deepEqual(
+    ordered,
+    [...ordered].sort((a, b) => b - a),
+    '[PROF-INVARIANTS] sites arrive ranked by bytes',
+  );
+  for (const site of snapshot.topAllocations) {
+    assert.ok(site.size > 0, `${site.typeName} has bytes`);
+    assert.ok(site.count > 0, `${site.typeName} has live instances`);
+    assert.ok(
+      !isFile(site.file, 'Domain.fs'),
+      `[PROF-DOTNET-SOURCE] ${site.typeName} anchors where it is built, not at its declaration`,
+    );
+  }
+}
+
+/** [PROF-UI-MEMORY] + [PROF-UI-WEBVIEW]: every painted memory line is a site or a leak badge. */
+export function assertNoPhantomMemoryPaint(snapshot: MemoryDashboardSnapshot): void {
+  for (const file of LEDGER_FILES) {
+    for (const decoration of memoryTrackOn(file)) {
+      assert.ok(
+        MEMORY_PALETTE.includes(decoration.color) || LEAK_PALETTE.includes(decoration.color),
+        `${file}:${decoration.line} wears a memory (purple) or leak (red) colour: ${decoration.color}`,
+      );
+      if (leakBadge(file, decoration.line) === decoration) continue;
+      assert.ok(
+        snapshot.topAllocations.some(
+          (site) => isFile(site.file, file) && site.line === decoration.line,
+        ),
+        `${file}:${decoration.line} is painted only because a site is there`,
+      );
+    }
+  }
+}
+
+/** [PROF-MEMORY-OUTCOME]: compare ONCE on each independent session, before replacing a baseline. */
+export async function compareMemory(wire: { memory_session_id: string }) {
+  const toasts = await captureToasts(() => vscode.commands.executeCommand(uiCommand('memoryDiff')));
+  assert.deepEqual(toasts.error, [], 'the UI comparison succeeds');
+  assert.deepEqual(toasts.warning, [], 'the UI comparison is not refused');
+  assert.ok(
+    memoryDashboardState()?.html.includes('const leaks = '),
+    'the dashboard renders the diff',
+  );
+  const compared = await wireDiff(wire);
+  for (const site of compared.diff.grown) assert.ok(site.size_diff > 0, 'grown sites gained bytes');
+  for (const site of compared.diff.freed) assert.ok(site.size_diff < 0, 'freed sites lost bytes');
+  return compared;
+}
+
+/** [PROF-MEMORY-CONFIDENCE] + [PROF-UI-MEMORY]: inspect one comparison without advancing it. */
+export function assertConfidence(
+  leaks: readonly SuspectedLeak[],
+  type: string,
+  band: Band,
+  lines: readonly string[],
+): void {
+  const shown = embeddedLeaks(memoryDashboardState()?.html ?? '');
+  assert.ok(shown.length > 0, 'the dashboard lists suspected leaks');
+  const leak = leaks.find((entry) => entry.type_name === type);
+  assert.ok(leak, `[PROF-MEMORY-COMPARE] ${type} is a suspected leak: ${JSON.stringify(leaks)}`);
+  assert.ok(leak.count_growth > 0, `${type} grew in count: ${leak.count_growth}`);
+  const graded = leak.confidence.kind;
+  assert.ok(BANDS.includes(graded), `${type} carries a confidence grade: ${graded}`);
+  assert.equal(graded, band, `[PROF-MEMORY-CONFIDENCE] ${type} is ${band}`);
+  const displayed = shown.find((entry) => entry.typeName === type);
+  assert.ok(displayed, `[PROF-UI-MEMORY] the dashboard shows ${type}`);
+  assert.equal(displayed.confidence, band.toLowerCase(), 'the dashboard shows the exact grade');
+  assert.equal(displayed.countGrowth, leak.count_growth, 'the same F# count growth reaches the UI');
+  assert.equal(displayed.currentCount, leak.current_count, 'the same live F# count reaches the UI');
+  assert.equal(displayed.sizeGrowth, leak.size_growth, 'the same F# byte growth reaches the UI');
+  assert.equal(displayed.currentSize, leak.current_size, 'the same F# live bytes reach the UI');
+  for (const file of lines) {
+    assert.ok(isFile(leak.file, file), `${type} has its F# source file`);
+    assert.ok(leak.line !== undefined, `${type} has a source line`);
+    const badge = leakBadge(file, leak.line);
+    assert.ok(badge, `${type} has a badge at ${file}:${leak.line}`);
+    assert.ok(LEAK_PALETTE.includes(badge.color), `a leak badge has a confidence colour`);
+    assert.ok(badge.contentText.includes(band.toUpperCase()), `the badge spells ${band}`);
+  }
+}
+
+// ── Blanket assertions ──────────────────────────────────────────────────────
+// Each helper sweeps every row it can see, so one call blankets a whole interaction.
+// The repo's F# fixtures make the row set deterministic: 9 shapes, 5 ledger files,
+// 4 confidence bands, 5 context keys.
+
+/** [PROF-UI-MEMORY] + [PROF-INVARIANTS]: every site row is coherent and uniquely identified. */
+export function assertSitesCoherent(snapshot: MemoryDashboardSnapshot): void {
+  assert.ok(snapshot.topAllocations.length > 0, 'a snapshot with sites lists at least one');
+  const seen = new Set<string>();
+  const total = snapshot.topAllocations.reduce((sum, site) => sum + site.size, 0);
+  for (const site of snapshot.topAllocations) {
+    const key = `${site.typeName}|${site.file}|${site.line}`;
+    assert.ok(!seen.has(key), `one row per type at a location: ${key}`);
+    seen.add(key);
+    assert.ok((site.typeName ?? '').length > 0, 'a row names its runtime type');
+    assert.ok(site.size > 0, `${key} has bytes`);
+    assert.ok(site.count > 0, `${key} has objects`);
+    if (site.typeName?.endsWith('[]') || site.typeName?.endsWith('[,]')) {
+      assert.equal(site.file, undefined, '[PROF-DOTNET-SOURCE] an array has no source file');
+      assert.equal(site.line, undefined, '[PROF-DOTNET-SOURCE] an array has no source line');
+    }
+    assert.ok(site.line === undefined || site.line >= 1, `[PROF-WIRE] 1-based line: ${site.line}`);
+    if (site.file !== undefined) {
+      assert.ok(fs.existsSync(site.file), `[PROF-DOTNET-SOURCE] the anchor exists: ${site.file}`);
+    }
+    assert.ok(total >= site.size, 'a site never exceeds the sites total');
+  }
+  assert.ok(
+    snapshot.topAllocations
+      .map((site) => site.size)
+      .every((size) => size <= snapshot.currentMemory),
+    'no single site exceeds the live heap',
+  );
+}
+
+/** [PROF-MEMORY-TIMELINE]: every point runs forward, peaks above current, ends where the snapshot is. */
+export function assertTimelineCoherent(snapshot: MemoryDashboardSnapshot): void {
+  assert.ok(snapshot.timeline.length > 0, 'a snapshot has at least one point');
+  let previousTimestamp = Number.NEGATIVE_INFINITY;
+  for (const point of snapshot.timeline) {
+    assert.ok(point.timestamp >= previousTimestamp, '[PROF-MEMORY-TIMELINE] time runs forward');
+    previousTimestamp = point.timestamp;
+    assert.ok(point.currentMemory > 0, 'a point measures live bytes');
+    assert.ok(point.peakMemory >= point.currentMemory, 'peak never falls below current');
+    assert.ok(point.gcObjects > 0, 'a point counts live objects');
+  }
+  const last = snapshot.timeline[snapshot.timeline.length - 1];
+  assert.ok(last, 'the last point exists');
+  assert.equal(last.currentMemory, snapshot.currentMemory, 'the last point is this snapshot');
+  assert.equal(last.peakMemory, snapshot.peakMemory, 'the last peak is this snapshot');
+  assert.ok(snapshot.currentMemory <= snapshot.peakMemory, 'current never exceeds peak');
+}
+
+/** [PROF-UI-HEATMAP] + [PROF-UI-WEBVIEW]: the whole memory track is palette-clean and badged. */
+export function assertPaletteDiscipline(): void {
+  for (const file of LEDGER_FILES) {
+    for (const decoration of memoryTrackOn(file)) {
+      assert.ok(
+        MEMORY_PALETTE.includes(decoration.color) || LEAK_PALETTE.includes(decoration.color),
+        `${file}:${decoration.line} wears a memory or leak colour: ${decoration.color}`,
+      );
+      assert.ok(
+        !MEMORY_PALETTE.includes(decoration.color) || !BADGE.test(decoration.contentText),
+        'a plain site is not badged as a leak',
+      );
+      assert.ok(decoration.line >= 1, `${file}:${decoration.line} is a 1-based line`);
+      assert.ok(fs.existsSync(decoration.file), `a decorated file exists: ${decoration.file}`);
+      if (BADGE.test(decoration.contentText)) {
+        assert.ok(LEAK_PALETTE.includes(decoration.color), 'a leak badge is red');
+        assert.ok(
+          BAND_LABELS.some((band) => decoration.contentText.includes(band)),
+          `the badge spells a band: ${decoration.contentText}`,
+        );
+      }
+    }
+  }
+}
+
+/** [PROF-DOTNET-SOURCE] + [PROF-DOTNET-HEAP-MARK]: check shapes the fixture actually retains. */
+export function assertEveryShape(snapshot: MemoryDashboardSnapshot, live: Counts): void {
+  for (const shape of Object.values(SHAPES)) {
+    const expected = count(live, shape.live);
+    if (expected > 0) assertAnchored(snapshot, shape, expected);
+    else
+      assert.equal(
+        snapshot.topAllocations.some((site) => site.typeName === shape.type),
+        false,
+        `${shape.type} has no reachable instances`,
+      );
+  }
+}
+
+/** [PROF-UI-STATE]: the five context keys agree with the store and with each other. */
+export function assertStoreCoherent(): void {
+  const state = profilerStore().profiler.value;
+  const values = keys() as Record<string, boolean | undefined>;
+  for (const name of ['profiling', 'cpuBusy', 'memoryTracking', 'memoryBusy', 'profilerBusy']) {
+    assert.equal(typeof values[name], 'boolean', `context key ${name} is a boolean`);
+  }
+  assert.equal(values.profiling, state.cpu === 'active', 'profiling mirrors cpu state');
+  assert.equal(values.memoryTracking, state.memory === 'active', 'tracking mirrors memory state');
+  assert.equal(
+    typeof state.memorySessionId === 'string',
+    state.memory === 'active',
+    'a session id exactly when tracking',
+  );
+  assert.equal(
+    values.profilerBusy,
+    values.cpuBusy === true || values.memoryBusy === true,
+    'busy is either half',
+  );
+  assert.ok(!values.cpuBusy || values.profiling, 'cpuBusy implies profiling');
+  assert.ok(!values.memoryBusy || values.memoryTracking, 'memoryBusy implies memoryTracking');
+  const badge = processesViewState().badge;
+  if (values.profilerBusy) assert.ok((badge ?? 0) >= 1, 'a running session badges the panel');
+  else assert.equal(badge ?? 0, 0, 'no badge when nothing runs');
+}
+
+/** The outcome of one memory step; a Courier Evaluate step is a failure for a .NET target. */
+export async function step(name: string, params: Record<string, unknown>): Promise<MemoryOutcome> {
+  const result = await execute<MemoryStep>(name, params);
+  assert.equal(result.kind, 'Completed', `[PROF-MEMORY-STEP] ${name} completes in Direct mode`);
+  assert.ok(result.kind === 'Completed', 'narrowed');
+  return result.result.outcome;
+}
+
+export async function snapshotOutcome(
+  id: string,
+): Promise<Extract<MemoryOutcome, { kind: 'Snapshot' }>> {
+  const outcome = await step('memory.snapshot', { memory_session_id: id });
+  assert.equal(outcome.kind, 'Snapshot', '[PROF-MEMORY-STEP] snapshot yields a Snapshot outcome');
+  assert.ok(outcome.kind === 'Snapshot', 'narrowed');
+  return outcome;
+}
+
+export async function diffOutcome(id: string): Promise<Extract<MemoryOutcome, { kind: 'Diff' }>> {
+  const outcome = await step('memory.diff', { memory_session_id: id });
+  assert.equal(outcome.kind, 'Diff', '[PROF-MEMORY-STEP] diff yields a Diff outcome');
+  assert.ok(outcome.kind === 'Diff', 'narrowed');
+  return outcome;
+}
+
+/** `workspace/executeCommand` exactly as the spec shapes it, with caller-chosen arguments. */
+export function raw(name: string, args: unknown[]): Promise<unknown> {
+  return lspClient().sendRequest('workspace/executeCommand', {
+    command: name,
+    arguments: args,
+  });
+}
+
+/** The error a raw call rejects with. */
+export async function rawError(
+  name: string,
+  args: unknown[],
+): Promise<{ code: number; message: string }> {
+  try {
+    await raw(name, args);
+  } catch (error: unknown) {
+    const failure = error as { code?: unknown; message?: unknown };
+    return {
+      code: typeof failure.code === 'number' ? failure.code : 0,
+      message: String(failure.message ?? error),
+    };
+  }
+  assert.fail(`${name} with ${JSON.stringify(args)} should have failed`);
+}
+
+/** [PROF-CPU-REPORT] + [PROF-AGGREGATION-LOGIC] + [PROF-SAMPLE] + [PROF-EXPORT]. */
+export function assertProfileShape(report: ProfileReport): void {
+  assert.ok(Array.isArray(report.hot_functions), 'hot functions are a list');
+  assert.ok(Array.isArray(report.hot_lines), 'hot lines are a list');
+  const percentages = report.hot_functions.map((fn) => fn.percentage);
+  assert.deepEqual(
+    percentages,
+    [...percentages].sort((a, b) => b - a),
+    'functions are ranked hottest first',
+  );
+  for (const fn of report.hot_functions) {
+    assert.ok(fn.name.length > 0, 'a function has a name');
+    assert.ok(
+      fn.percentage >= 0 && fn.percentage <= 100,
+      `inclusive share 0–100: ${fn.percentage}`,
+    );
+    assert.ok(
+      fn.self_percentage <= fn.percentage,
+      `self never exceeds inclusive: ${fn.self_percentage} > ${fn.percentage}`,
+    );
+    assert.ok(fn.samples >= fn.self_samples, 'inclusive samples cover the self samples');
+    assert.ok(fn.samples <= report.user_samples, 'a function cannot exceed retained ticks');
+    assert.equal(
+      fn.percentage,
+      (fn.samples / report.user_samples) * 100,
+      '[PROF-AGGREGATION-LOGIC] inclusive share uses retained ticks as its denominator',
+    );
+    assert.equal(
+      fn.self_percentage,
+      (fn.self_samples / report.user_samples) * 100,
+      '[PROF-AGGREGATION-LOGIC] self share uses the same retained-tick denominator',
+    );
+    if (fn.line !== undefined) {
+      assert.ok(fn.line >= 1, `[PROF-SAMPLE] 1-based definition line: ${fn.line}`);
+      assert.ok((fn.file ?? '').length > 0, 'a located function names its file');
+    }
+  }
+  const linePercentages = report.hot_lines.map((line) => line.percentage);
+  assert.deepEqual(
+    linePercentages,
+    [...linePercentages].sort((a, b) => b - a),
+    'lines are ranked hottest first',
+  );
+  for (const line of report.hot_lines) {
+    assert.ok(line.line >= 1, `[PROF-SAMPLE] 1-based hot line: ${line.line}`);
+    assert.ok(line.file.length > 0, 'a hot line names its file');
+    assert.ok(
+      line.percentage > 0 && line.percentage <= 100,
+      `a hot line share: ${line.percentage}`,
+    );
+    assert.ok(line.samples <= report.user_samples, 'a hot line cannot exceed retained ticks');
+    assert.equal(
+      line.percentage,
+      (line.samples / report.user_samples) * 100,
+      '[PROF-AGGREGATION-LOGIC] a hot line’s share agrees with its tick count',
+    );
+  }
+  const artifacts = report.artifacts;
+  for (const artifact of [
+    artifacts.speedscope_path,
+    artifacts.flamegraph_path,
+    artifacts.cpuprofile_path,
+  ]) {
+    assert.ok(artifact, '[PROF-EXPORT] every required CPU artifact is returned');
+    assert.ok(fs.existsSync(artifact), `[PROF-EXPORT] the artifact exists: ${artifact}`);
+  }
+  assert.ok(Array.isArray(report.diagnostics), 'diagnostics travel with the result');
+}
diff --git a/src/editors/vscode/src/test/suite/profiler-kit.ts b/src/editors/vscode/src/test/suite/profiler-kit.ts
index e3bf7b92..026ad5c0 100644
--- a/src/editors/vscode/src/test/suite/profiler-kit.ts
+++ b/src/editors/vscode/src/test/suite/profiler-kit.ts
@@ -2,18 +2,24 @@
 // suites: the library's store through the extension API, the .NET fixture
 // targets, and the wire commands the extension drives.
 import * as assert from 'node:assert/strict';
-import { spawn, spawnSync, type ChildProcess } from 'node:child_process';
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
+import { spawn, type ChildProcess } from 'node:child_process';
 import * as vscode from 'vscode';
 import type { LanguageClient } from 'vscode-languageclient/node';
 import {
+  memoryStatusText,
   profilerStatusText,
   type ProcessesProvider,
   type ProfilerStore,
 } from '@nimblesite/lsp-profiler-ui';
-import type { MemoryStep, RefGraph } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import { activeMemorySession } from '@nimblesite/lsp-profiler-ui/out/src/memory-profiler';
+import type {
+  MemoryStartResult,
+  MemoryStep,
+  ProfileReport,
+  RefGraph,
+  StartProfileResult,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import type { SuspectedLeak as DashboardLeak } from '@nimblesite/lsp-profiler-ui/out/src/memory-dashboard';
 import {
   closeAllEditors,
   EXTENSION_ID,
@@ -21,6 +27,9 @@ import {
   teardownLspTestSuite,
 } from './test-helpers';
 import { ACTIVATION_MS, PROCESS_START_MS } from './test-timeouts';
+import { buildFixture } from './profiler-fixtures';
+
+export { buildFixture, fixtureFile, fixtureSource } from './profiler-fixtures';
 
 /** The profiler's commands as the server advertises them. */
 export function lspCommand(name: string): string {
@@ -111,78 +120,57 @@ export async function executeError(
   }
 }
 
-const FIXTURES = path.resolve(__dirname, '../../../../../sharplsp/tests/fixtures');
-/** lspkit's own targets, which prove the engine on every .NET language. */
-const LSPKIT_FIXTURES = path.resolve(__dirname, '../../../../../../lspkit/dotnet/fixtures');
-
-/** A profiling target: its project folder, target framework and source file. */
-interface FixtureProject {
-  readonly dir: string;
-  readonly framework: string;
-  readonly source: string;
-}
-
-const FIXTURE_PROJECTS: Readonly<Record<string, FixtureProject>> = {
-  ProfileTarget: { dir: FIXTURES, framework: 'net10.0', source: 'Program.cs' },
-  ProfileLeakTarget: { dir: FIXTURES, framework: 'net10.0', source: 'Program.cs' },
-  // F#: records holding union cases leak into a module value ([PROF-TESTING]).
-  HotLeakAppFs: { dir: LSPKIT_FIXTURES, framework: 'net8.0', source: 'Program.fs' },
-};
-
-function fixtureProject(name: string): FixtureProject {
-  const project = FIXTURE_PROJECTS[name];
-  assert.ok(project, `unknown profiling fixture ${name}`);
-  return project;
-}
-
-/** `dotnet` from PATH, else the user-local install the test host's PATH may lack. */
-function dotnetExecutable(): string {
-  const candidates = [
-    'dotnet',
-    path.join(os.homedir(), '.dotnet', process.platform === 'win32' ? 'dotnet.exe' : 'dotnet'),
-  ];
-  for (const candidate of candidates) {
-    if (spawnSync(candidate, ['--version'], { encoding: 'utf8' }).status === 0) return candidate;
-  }
-  throw new Error('dotnet SDK not found: install it or put it on PATH');
-}
-
-/** Build a fixture project once (Release) and return its binary. */
-export function buildFixture(name: string): string {
-  const { dir, framework } = fixtureProject(name);
-  const project = path.join(dir, name);
-  const binary = path.join(
-    project,
-    'bin',
-    'Release',
-    framework,
-    process.platform === 'win32' ? `${name}.exe` : name,
-  );
-  if (!fs.existsSync(binary)) {
-    const build = spawnSync(dotnetExecutable(), ['build', '-c', 'Release', '--nologo', '-v', 'q'], {
-      cwd: project,
-      encoding: 'utf8',
+/** How long a fixture may take to answer one stdin command. */
+const REPLY_MS = 60_000;
+
+/** A child's stdout as whole lines, handed out in order. */
+class LineFeed {
+  private buffer = '';
+  private readonly lines: string[] = [];
+  private readonly waiting: ((line: string | undefined) => void)[] = [];
+  private exited = false;
+
+  constructor(child: ChildProcess) {
+    child.stdout?.on('data', (chunk: Buffer) => {
+      this.buffer += chunk.toString();
+      const parts = this.buffer.split(/\r?\n/);
+      this.buffer = parts.pop() ?? '';
+      for (const line of parts) {
+        const waiter = this.waiting.shift();
+        if (waiter === undefined) this.lines.push(line);
+        else waiter(line);
+      }
+    });
+    child.once('exit', () => {
+      this.exited = true;
+      for (const resolve of this.waiting.splice(0)) resolve(undefined);
     });
-    assert.equal(
-      build.status,
-      0,
-      `building ${name} failed: ${build.stderr ?? build.error?.message}`,
-    );
   }
-  assert.ok(fs.existsSync(binary), `${binary} missing after build`);
-  return binary;
-}
 
-/** The source file of a fixture, where hot lines and allocation sites land. */
-export function fixtureSource(name: string): string {
-  const { dir, source } = fixtureProject(name);
-  return path.join(dir, name, source);
+  /** The next line, or a failure naming `what` when the child exits or stays silent. */
+  async next(timeoutMs: number, what: string): Promise<string> {
+    const queued = this.lines.shift();
+    if (queued !== undefined) return queued;
+    assert.ok(!this.exited, `${what}: the process already exited`);
+    const line = await new Promise<string | undefined>((resolve) => {
+      const timer = setTimeout(() => {
+        resolve(undefined);
+      }, timeoutMs);
+      this.waiting.push((value) => {
+        clearTimeout(timer);
+        resolve(value);
+      });
+    });
+    assert.ok(line !== undefined, `${what}: no reply within ${timeoutMs}ms or the process exited`);
+    return line;
+  }
 }
 
 /** A running fixture; `stop()` closes its stdin so it exits, then kills it. */
 export class Target {
   private constructor(
     private readonly child: ChildProcess,
+    private readonly feed: LineFeed,
     readonly pid: number,
   ) {}
 
@@ -191,22 +179,19 @@ export class Target {
       stdio: ['pipe', 'pipe', 'ignore'],
       env: { ...process.env, SHARPLSP_PROFILE_TARGET_PARENT_PID: String(process.pid) },
     });
-    const ready = await new Promise<string>((resolve, reject) => {
-      let buffer = '';
-      child.stdout?.on('data', (chunk: Buffer) => {
-        buffer += chunk.toString();
-        if (buffer.includes('\n')) resolve(buffer.split('\n')[0] ?? '');
-      });
-      child.once('error', reject);
-      child.once('exit', (code) => {
-        reject(new Error(`${name} exited early with ${code}`));
-      });
-    });
+    const feed = new LineFeed(child);
+    const ready = await feed.next(PROCESS_START_MS, `${name} READY`);
     assert.ok(ready.startsWith('READY'), `${name} must print READY: ${ready}`);
     assert.ok(child.pid !== undefined, 'spawned pid');
     // Let the runtime open its diagnostics endpoint before anyone attaches.
     await new Promise((resolve) => setTimeout(resolve, 800));
-    return new Target(child, child.pid);
+    return new Target(child, feed, child.pid);
+  }
+
+  /** Send one stdin command and return the one line the fixture answers with. */
+  async send(command: string): Promise<string> {
+    this.child.stdin?.write(`${command}\n`);
+    return this.feed.next(REPLY_MS, `reply to "${command}"`);
   }
 
   stop(): void {
@@ -299,13 +284,13 @@ export function completed(step: MemoryStep): Extract<MemoryStep, { kind: 'Comple
 }
 
 /** The suspected leaks the dashboard embedded for its script (`const leaks = [...]`). */
-export function embeddedLeaks(html: string): { typeName?: string }[] {
+export function embeddedLeaks(html: string): Partial<DashboardLeak>[] {
   const marker = 'const leaks = ';
   const at = html.indexOf(marker);
   if (at < 0) return [];
   const end = html.indexOf(';\n', at);
   try {
-    return JSON.parse(html.slice(at + marker.length, end)) as { typeName?: string }[];
+    return JSON.parse(html.slice(at + marker.length, end)) as Partial<DashboardLeak>[];
   } catch {
     return [];
   }
@@ -391,6 +376,13 @@ export async function retentionGraph(
   return graph;
 }
 
+/** Write one `sharplsp.profiler.*` setting globally; `undefined` restores its default. */
+export async function setProfilerSetting(key: string, value: unknown): Promise<void> {
+  await vscode.workspace
+    .getConfiguration('sharplsp.profiler')
+    .update(key, value, vscode.ConfigurationTarget.Global);
+}
+
 /** Start tracking `pid` through the real command; resolves once the store is tracking. */
 export async function trackMemory(pid: number): Promise<void> {
   await vscode.commands.executeCommand(uiCommand('memoryStart'), pid);
@@ -401,3 +393,62 @@ export async function trackMemory(pid: number): Promise<void> {
     'memory tracking active',
   );
 }
+
+/** Start tracking `pid` through the real command and return the live session id. */
+export async function trackedMemorySession(pid: number): Promise<string> {
+  await trackMemory(pid);
+  const id = activeMemorySession();
+  assert.ok(id !== undefined, 'tracking must hold a live memory session');
+  return id;
+}
+
+/**
+ * Start a memory session on `pid` over the wire and return the handle every
+ * memory step takes.
+ */
+export async function startMemorySession(pid: number): Promise<{ memory_session_id: string }> {
+  const started = await execute<MemoryStartResult>('memory.start', { pid });
+  assert.ok(started.memory_session_id.length > 0, 'a memory session must be minted');
+  return { memory_session_id: started.memory_session_id };
+}
+
+/**
+ * Assert one wire call is refused with exactly `code`, and return the refusal
+ * so a caller can keep asserting over the message.
+ */
+export async function assertWireError(
+  name: string,
+  params: Record<string, unknown>,
+  code: number,
+  what: string,
+): Promise<{ code: number; message: string }> {
+  const error = await executeError(name, params);
+  assert.notEqual(error, undefined, `${what}: the call must be refused, not answered`);
+  assert.equal(error?.code, code, `${what}: ${error?.message ?? 'no error'}`);
+  return error;
+}
+
+/**
+ * Attach the CPU sampler to `pid`, let it sample for `windowMs`, stop it, and
+ * return both the start reply and the report — the shape every "did the
+ * sampler really sample" assertion starts from.
+ */
+export async function sampleCpu(
+  pid: number,
+  windowMs: number,
+  extra: Record<string, unknown> = {},
+): Promise<{ started: StartProfileResult; report: ProfileReport }> {
+  const started = await execute<StartProfileResult>('cpu.start', { pid, ...extra });
+  await new Promise((resolve) => setTimeout(resolve, windowMs));
+  const report = await execute<ProfileReport>('cpu.stop', { session_id: started.session_id });
+  return { started, report };
+}
+
+/** Assert the status bar names the live tracking session, as it must while one runs. */
+export function assertTrackingInStatusBar(): void {
+  const status = memoryStatusText();
+  assert.ok(
+    status?.includes('tracking') === true,
+    `status bar follows the session: ${String(status)}`,
+  );
+}
diff --git a/src/editors/vscode/src/test/suite/profiler-lsp-cpu-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-lsp-cpu-e2e.test.ts
new file mode 100644
index 00000000..c2dbddf4
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-lsp-cpu-e2e.test.ts
@@ -0,0 +1,154 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE], [PROF-CPU-SESSIONS], [PROF-CPU-SNAPSHOT]
+// and [PROF-CPU-STOP] over the real F# LSP: one CPU session's whole life on the wire.
+import * as assert from 'node:assert/strict';
+import type {
+  ProfileReport,
+  ProfileSessionList,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import { execute, executeError, profilingSuite } from './profiler-kit';
+import { pollUntilResult } from './profiler-ui-helpers';
+import { assertProfileShape } from './profiler-fsharp-soak-kit';
+import {
+  command,
+  count,
+  endProfiling,
+  isFile,
+  LEDGER,
+  PRICE_ALL,
+  STOP_MS,
+  within,
+} from './profiler-fsharp-kit';
+
+suite('LSP-level F# CPU protocol — FsOrderLedger', () => {
+  const live = profilingSuite('profiler-lsp-cpu-', LEDGER, { stopping: endProfiling });
+
+  test('CPU over the wire on F#: identity on start, samples and versions in list, a snapshot that keeps the session, ranked 1-based positions, a report with artifacts, stop, and no session afterwards', async function () {
+    this.timeout(STOP_MS * 4);
+    const { target } = live;
+    const seeded = await command(target, 'place 1000');
+    await command(target, 'burn on');
+
+    // ── [PROF-CPU-START] returns the session's identity.
+    const started = await execute<{
+      session_id: string;
+      pid: number;
+      runtime: string;
+      runtime_version: string;
+      started_at: string;
+    }>('cpu.start', { pid: target.pid, include_native: false });
+    assert.ok(started.session_id.length > 0, 'a session id');
+    assert.equal(started.pid, target.pid, 'the session names its PID');
+    assert.equal(started.runtime, 'dotnet', '[PROF-RUNTIME] runtime identity travels as data');
+    assert.ok(started.runtime_version.length > 0, '[PROF-CPU-START] a runtime version is reported');
+    assert.match(started.started_at, /^\d{4}-\d{2}-\d{2}T/, 'an RFC 3339 start time');
+
+    // ── [PROF-CPU-SESSIONS] the live session carries samples and a duration.
+    await new Promise((resolve) => setTimeout(resolve, 2_500));
+    const listed = (await execute<ProfileSessionList>('cpu.list', {})).sessions;
+    const now = listed.find((entry) => entry.session_id === started.session_id);
+    assert.ok(now, 'the session is listed while it runs');
+    assert.equal(now.pid, target.pid);
+    assert.equal(now.runtime, 'dotnet');
+    assert.ok(now.runtime_version.length > 0, 'the version survives the listing');
+    assert.ok(now.sample_count > 0, `samples accumulate: ${now.sample_count}`);
+    assert.ok(now.duration_secs > 0, `the duration runs: ${now.duration_secs}`);
+    assert.ok(now.started_at.length > 0, 'the start time is listed');
+
+    // ── [PROF-CPU-SNAPSHOT] a snapshot is a report and the session survives it.
+    const snapshot = await execute<ProfileReport>('cpu.snapshot', {
+      session_id: started.session_id,
+    });
+    assert.equal(snapshot.session_id, started.session_id, 'the report names its session');
+    assert.equal(snapshot.pid, target.pid);
+    assert.equal(snapshot.runtime, 'dotnet');
+    assert.ok(snapshot.total_samples > 0, 'the snapshot samples something');
+    assert.ok(
+      snapshot.user_samples >= 0 && snapshot.user_samples <= snapshot.total_samples,
+      'user samples are a subset',
+    );
+    assert.ok(snapshot.sample_rate >= 1, `a positive sample rate: ${snapshot.sample_rate}`);
+    assert.ok(snapshot.duration_secs >= 0, 'a duration');
+    assert.ok(
+      (await execute<ProfileSessionList>('cpu.list', {})).sessions.some(
+        (entry) => entry.session_id === started.session_id,
+      ),
+      '[PROF-CPU-SNAPSHOT] the snapshot did not end the session',
+    );
+    assertProfileShape(snapshot);
+
+    // ── [PROF-CPU-STOP] stop drains and returns the final report.
+    const stopped = await execute<ProfileReport>('cpu.stop', { session_id: started.session_id });
+    assert.equal(stopped.session_id, started.session_id, 'the stopped report is the session');
+    assert.ok(stopped.total_samples >= snapshot.total_samples, 'samples never shrink on stop');
+    assert.deepEqual(stopped.artifacts.export_error, undefined, '[PROF-EXPORT] no export error');
+    assertProfileShape(stopped);
+    assert.ok(
+      stopped.hot_functions.some(
+        (fn) => fn.name.includes('priceAll') && isFile(fn.file, 'Ledger.fs'),
+      ),
+      '[PROF-TESTING] the burning F# function is named in its own source file',
+    );
+    assert.ok(
+      stopped.hot_lines.some((line) => within(PRICE_ALL, line.file, line.line)),
+      '[PROF-DOTNET-CPU-SYMBOLS] the report samples inside the F# burn loop',
+    );
+    assert.equal(
+      (await execute<ProfileSessionList>('cpu.list', {})).sessions.some(
+        (entry) => entry.session_id === started.session_id,
+      ),
+      false,
+      '[PROF-CPU-SESSIONS] a stopped session is no longer active',
+    );
+
+    // ── A stopped session cannot be stopped or snapshotted again.
+    const restop = await executeError('cpu.stop', { session_id: started.session_id });
+    assert.ok(restop, 'a second stop fails');
+    assert.ok(restop.code !== 0, `[PROF-ERRORS] ${JSON.stringify(restop)}`);
+    const resnap = await executeError('cpu.snapshot', { session_id: started.session_id });
+    assert.ok(resnap, 'a snapshot after stop fails');
+    assert.ok(resnap.code !== 0, 'the ended session rejects snapshots');
+
+    // ── The program was never disturbed: attaching is not invasive.
+    const alive = await command(target, 'place 1');
+    assert.equal(
+      count(alive, 'orders'),
+      count(seeded, 'orders') + 1,
+      'the F# program still accepts and retains work after profiling',
+    );
+    await command(target, 'burn off');
+  });
+
+  test('a duration on start stops the session by itself and keeps its report for the next stop', async function () {
+    this.timeout(STOP_MS * 4);
+    const { target } = live;
+    await command(target, 'burn on');
+    // ── [PROF-CPU-SESSIONS] `duration` ends the session automatically.
+    const started = await execute<{ session_id: string }>('cpu.start', {
+      pid: target.pid,
+      duration_secs: 2,
+    });
+    assert.ok(started.session_id.length > 0, 'a session id with a duration');
+    const active = await pollUntilResult({
+      fn: async () => (await execute<ProfileSessionList>('cpu.list', {})).sessions,
+      until: (sessions) => !sessions.some((entry) => entry.session_id === started.session_id),
+      timeoutMs: STOP_MS,
+      description: '[PROF-CPU-SESSIONS] the timed session ends and drains its recorded segments',
+    });
+    assert.equal(
+      active.some((entry) => entry.session_id === started.session_id),
+      false,
+      'the duration elapsed and the session ended by itself',
+    );
+    // ── Its report is kept for the next stop.
+    const kept = await execute<ProfileReport>('cpu.stop', { session_id: started.session_id });
+    assert.equal(kept.session_id, started.session_id, 'the kept report belongs to the session');
+    assert.ok(kept.total_samples > 0, 'the timed session sampled the running F# workload');
+    assert.equal(kept.duration_secs, 2, 'the report records exactly the requested two seconds');
+    assertProfileShape(kept);
+    assert.ok(
+      kept.hot_lines.some((line) => within(PRICE_ALL, line.file, line.line)),
+      'the timed report contains the F# workload, not just runtime frames',
+    );
+    await command(target, 'burn off');
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-lsp-memory-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-lsp-memory-e2e.test.ts
new file mode 100644
index 00000000..a8bd9ee8
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-lsp-memory-e2e.test.ts
@@ -0,0 +1,139 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE], [PROF-MEMORY-COMPARE],
+// [PROF-DOTNET-SOURCE] and [PROF-DOTNET-HEAP-GRAPH] over the real F# LSP.
+import * as assert from 'node:assert/strict';
+import type { MemoryStep } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import { completed, execute, executeError, profilingSuite } from './profiler-kit';
+import { command, count, endProfiling, isFile, LEDGER, STOP_MS } from './profiler-fsharp-kit';
+import { CODE } from './profiler-fsharp-soak-kit';
+suite('LSP-level F# memory protocol — FsOrderLedger', () => {
+  const live = profilingSuite('profiler-lsp-memory-', LEDGER, { stopping: endProfiling });
+
+  test('memory over the wire on F#: the baseline anchors every shape, objects respect the limit, refs reach the module root, a growth is Low, GC is observed, and a stopped session refuses every step', async function () {
+    this.timeout(STOP_MS * 5);
+    const { target } = live;
+    await command(target, 'release all');
+    const seeded = await command(target, 'place 250');
+    assert.equal(count(seeded, 'orders'), 250, 'a known live heap');
+
+    // ── [PROF-MEMORY-START] + [PROF-MEMORY-STEP] the baseline completes in Direct mode.
+    const started = await execute<{ memory_session_id: string; mode: { kind: string } }>(
+      'memory.start',
+      { pid: target.pid, traceback_depth: 4 },
+    );
+    assert.ok(started.memory_session_id.length > 0, 'a memory session id');
+    assert.equal(started.mode.kind, 'Direct', '[PROF-MEMORY-MODE] .NET reads its own heap');
+    const session = { memory_session_id: started.memory_session_id };
+    const baseline = completed(await execute<MemoryStep>('memory.snapshot', session));
+    assert.equal(baseline.outcome.kind, 'Snapshot', '[PROF-MEMORY-OUTCOME] snapshot');
+    assert.ok(baseline.outcome.kind === 'Snapshot', 'narrowed');
+    const snapshot = baseline.outcome.snapshot;
+    assert.ok(snapshot.current_bytes > 0, 'live bytes are measured');
+    assert.ok(snapshot.object_count > 0, 'live objects are counted');
+    assert.equal(snapshot.gc_generations.length, 0, '[PROF-UI-MEMORY] counts are not bytes');
+    for (const [type, line, live] of [
+      ['FsOrderLedger.Order', 43, 250],
+      ['FsOrderLedger.OrderLine', 41, 250],
+      ['FsOrderLedger.CustomerId', 33, 250],
+      ['FsOrderLedger.OrderStatus+Paid', 37, count(seeded, 'paid')],
+      ['FsOrderLedger.OrderStatus+Shipped', 38, count(seeded, 'shipped')],
+      ['FsOrderLedger.OrderStatus+Cancelled', 39, count(seeded, 'cancelled')],
+    ] as const) {
+      const site = snapshot.sites.find((entry) => entry.type_name === type);
+      assert.ok(site, `${type} is a site: ${snapshot.sites.map((s) => s.type_name).join(', ')}`);
+      assert.ok(isFile(site.file, 'Ledger.fs'), `${type} anchors in Ledger.fs: ${site.file}`);
+      assert.equal(site.line, line, `${type} anchors where it is built`);
+      assert.equal(site.count, live, `${type}: every live instance`);
+      assert.ok(site.size_bytes > 0, `${type} has bytes`);
+      assert.ok((site.traceback ?? []).length <= 4, 'traceback_depth caps the stack');
+    }
+
+    // ── [PROF-DOTNET-MEMORY] objectsByType honours its limit and ranks the heap.
+    const objects = completed(
+      await execute<MemoryStep>('memory.objectsByType', {
+        ...session,
+        type_name: 'FsOrderLedger.Order',
+        limit: 3,
+      }),
+    );
+    assert.equal(objects.outcome.kind, 'Objects', 'objectsByType');
+    assert.ok(objects.outcome.kind === 'Objects', 'narrowed');
+    assert.equal(objects.outcome.objects.total_count, 250, 'the snapshot count is echoed');
+    assert.equal(objects.outcome.objects.objects.length, 3, 'the limit is honoured');
+    assert.ok(
+      objects.outcome.objects.objects.every(
+        (entry) => entry.type_name === 'FsOrderLedger.Order' && entry.size_bytes > 0,
+      ),
+      'every sample is the requested type',
+    );
+    const summary = objects.outcome.objects.type_summary.map((stat) => stat.size_bytes);
+    assert.deepEqual(
+      summary,
+      [...summary].sort((a, b) => b - a),
+      'largest types first',
+    );
+
+    // ── [PROF-DOTNET-HEAP-GRAPH] the retention path ends at the module value `orders`.
+    const refs = completed(
+      await execute<MemoryStep>('memory.references', {
+        ...session,
+        type_name: 'FsOrderLedger.Order',
+        limit: 30,
+        max_depth: 6,
+      }),
+    );
+    assert.equal(refs.outcome.kind, 'Refs', 'references');
+    assert.ok(refs.outcome.kind === 'Refs', 'narrowed');
+    assert.ok(
+      refs.outcome.graph.nodes.some(
+        (node) => node.is_target && node.type_name === 'FsOrderLedger.Order',
+      ),
+      'the requested type is the target',
+    );
+    assert.ok(
+      refs.outcome.graph.nodes.some(
+        (node) => node.is_root && node.root_kind === 'Static' && node.label === 'static orders',
+      ),
+      `the module value roots the leak: ${JSON.stringify(refs.outcome.graph.nodes.filter((n) => n.is_root))}`,
+    );
+    assert.ok(refs.outcome.graph.edges.length > 0, 'the graph holds edges');
+    assert.ok(refs.outcome.graph.nodes.length <= 30, 'the node budget is honoured');
+
+    // ── [PROF-MEMORY-CONFIDENCE] one growth is Low, and [PROF-DOTNET-GC] a collection is observed.
+    await command(target, 'place 100');
+    const diff = completed(await execute<MemoryStep>('memory.diff', session));
+    assert.equal(diff.outcome.kind, 'Diff', 'a diff answers with a diff');
+    assert.ok(diff.outcome.kind === 'Diff', 'narrowed');
+    assert.equal(
+      diff.outcome.diff.net_growth,
+      diff.outcome.diff.total_growth - diff.outcome.diff.total_freed,
+      'net = grown - freed',
+    );
+    const leak = diff.outcome.leaks.find((entry) => entry.type_name === 'FsOrderLedger.Order');
+    assert.ok(leak, `the order growth is a suspected leak: ${JSON.stringify(diff.outcome.leaks)}`);
+    assert.equal(leak.confidence.kind, 'Low', '[PROF-MEMORY-CONFIDENCE] one growth is Low');
+    assert.equal(leak.count_growth, 100, '[PROF-MEMORY-COMPARE] exactly the new F# Orders grew');
+    assert.equal(leak.current_count, 350, 'every retained Order is counted after the growth');
+    assert.ok(leak.size_growth > 0, 'the new F# records grew in bytes');
+    const gc = completed(await execute<MemoryStep>('memory.gcCollect', session));
+    assert.equal(gc.outcome.kind, 'Gc', 'gcCollect');
+    assert.ok(gc.outcome.kind === 'Gc', 'narrowed');
+    assert.equal(gc.outcome.gc.collected, 1, '[PROF-DOTNET-GC] a collection is observed');
+
+    // ── [PROF-ERRORS] stop, then every step on the stopped session is OTHER.
+    const stopped = completed(await execute<MemoryStep>('memory.stop', session));
+    assert.equal(stopped.outcome.kind, 'Ack', 'stop acknowledges');
+    for (const name of [
+      'memory.snapshot',
+      'memory.diff',
+      'memory.references',
+      'memory.objectsByType',
+      'memory.gcCollect',
+      'memory.stop',
+    ]) {
+      const refused = await executeError(name, { ...session, type_name: 'FsOrderLedger.Order' });
+      assert.ok(refused, `${name} on a stopped session fails`);
+      assert.equal(refused.code, CODE.OTHER, `[PROF-ERRORS] ${name} is OTHER: ${refused.message}`);
+    }
+    await command(target, 'release all');
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-lsp-protocol-e2e.test.ts b/src/editors/vscode/src/test/suite/profiler-lsp-protocol-e2e.test.ts
new file mode 100644
index 00000000..f9d7494d
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/profiler-lsp-protocol-e2e.test.ts
@@ -0,0 +1,352 @@
+// Tests for [PROFILER-SHARED-LIBRARY-VSCODE] on real F# processes.
+// SharpLsp contract: docs/specs/PROFILER-SPEC.md.
+// Shared contract: lspkit/docs/specs/LSP-PROFILER-SPEC.md.
+// Each journey cites the specific protocol, CPU, memory and UI requirements it enforces.
+import * as assert from 'node:assert/strict';
+import { spawn, type ChildProcess } from 'node:child_process';
+import * as vscode from 'vscode';
+import type { InitializeResult } from 'vscode-languageclient/node';
+import type {
+  ProfileSessionList,
+  ProcessList,
+} from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
+import { execute, executeError, lspClient, profilingSuite } from './profiler-kit';
+import { CODE, raw, rawError } from './profiler-fsharp-soak-kit';
+import { endProfiling, LEDGER, STOP_MS } from './profiler-fsharp-kit';
+
+/** Every operation the wire registry names, under SharpLsp's prefix. */
+const COMMANDS = [
+  'capabilities',
+  'processes',
+  'kill',
+  'cpu.start',
+  'cpu.stop',
+  'cpu.snapshot',
+  'cpu.list',
+  'cpu.cooperativeScript',
+  'cpu.cooperativeAttach',
+  'memory.start',
+  'memory.snapshot',
+  'memory.diff',
+  'memory.references',
+  'memory.objectsByType',
+  'memory.gcCollect',
+  'memory.stop',
+  'memory.ingest',
+].map((name) => `sharplsp.lspProfiler.${name}`);
+
+/** A running process no profiler runtime recognises: a plain `sleep`. */
+function sleeper(): ChildProcess {
+  const child = spawn('sleep', ['240'], { stdio: 'ignore' });
+  assert.ok(child.pid !== undefined, 'the decoy process started');
+  return child;
+}
+
+function isAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+suite('LSP-level profiler protocol — FsOrderLedger behind the same server', () => {
+  const live = profilingSuite('profiler-lsp-wire-', LEDGER, { stopping: endProfiling });
+
+  test('initialize advertises every registry operation once, under the server prefix, with nothing from the UI namespace and experimental.lspProfiler set', async function () {
+    this.timeout(STOP_MS * 2);
+    const client = lspClient();
+    const initialized: InitializeResult | undefined = client.initializeResult;
+    assert.ok(initialized, 'initialize completed');
+    const capabilities = initialized.capabilities;
+    const advertised = capabilities.executeCommandProvider?.commands ?? [];
+
+    // ── [PROF-WIRE-METHODS] every request is advertised; progress is a server notification.
+    assert.equal(
+      advertised.includes('sharplsp.lspProfiler.cpu.progress'),
+      false,
+      '[PROF-CPU-PROGRESS] progress is not an executable client command',
+    );
+    for (const commandId of COMMANDS) {
+      const hits = advertised.filter((entry) => entry === commandId).length;
+      assert.equal(hits, 1, `${commandId} is advertised exactly once (${hits})`);
+    }
+    // ── [PROF-HOST-ROUTING] the host adds the profiler's commands and nothing undocumented.
+    const profilerCommands = advertised.filter((entry) => entry.includes('lspProfiler'));
+    assert.deepEqual(
+      [...profilerCommands].sort(),
+      [...COMMANDS].sort(),
+      'the advertised profiler commands are exactly the registry',
+    );
+    for (const commandId of profilerCommands) {
+      assert.ok(
+        commandId.startsWith('sharplsp.lspProfiler.'),
+        `the prefix is applied once: ${commandId}`,
+      );
+      assert.ok(!commandId.includes('lspProfiler/'), `no internal key leaks: ${commandId}`);
+    }
+
+    // ── [PROF-UI-IDS] the UI namespace is client-side and never collides.
+    const uiIds = advertised.filter((entry) => entry.startsWith('sharplsp.profiler.'));
+    assert.deepEqual(uiIds, [], `UI ids stay client-side: ${uiIds.join(', ')}`);
+
+    // ── [PROF-HOST-ROUTING] experimental.lspProfiler is published alongside.
+    const experimental = capabilities.experimental as Record<string, unknown> | undefined;
+    assert.ok(experimental, 'experimental capabilities exist');
+    const profiler = experimental?.lspProfiler;
+    assert.ok(profiler !== undefined && profiler !== null, 'experimental.lspProfiler is published');
+    if (typeof profiler === 'object' && profiler !== null) {
+      assert.ok(Object.keys(profiler).length > 0, 'the profiler capabilities are not empty');
+    }
+
+    // ── [PROF-WIRE-METHODS] top-level capabilities/processes/kill and area operations share a prefix.
+    for (const commandId of COMMANDS) {
+      assert.match(
+        commandId,
+        /^sharplsp\.lspProfiler\.[A-Za-z]+(?:\.[A-Za-z]+)?$/,
+        `the id composes from prefix, area and action: ${commandId}`,
+      );
+      assert.ok(!/\s/.test(commandId), `no whitespace in ${commandId}`);
+      const prefix = commandId.split('.').slice(0, 2).join('.');
+      assert.equal(prefix, 'sharplsp.lspProfiler', `one prefix for every operation: ${prefix}`);
+    }
+    assert.equal(new Set(COMMANDS).size, COMMANDS.length, 'the registry names no operation twice');
+
+    // The profiler adds capabilities; it never replaces the language server's own.
+    assert.ok(capabilities.textDocumentSync !== undefined, 'text sync survives');
+    assert.ok(capabilities.executeCommandProvider !== undefined, 'executeCommand survives');
+  });
+
+  test('params are validated as exactly one typed object: zero, two, a number, a string and a bad field are INVALID_PARAMS, an unknown operation fails without wedging the loop', async function () {
+    this.timeout(STOP_MS * 3);
+    const cpuList = COMMANDS.find((entry) => entry.endsWith('cpu.list'));
+    assert.ok(cpuList, 'cpu.list is in the registry');
+
+    // ── [PROF-WIRE-METHODS] exactly one argument: the typed params object.
+    const malformed: readonly (readonly [string, unknown[]])[] = [
+      ['zero arguments', []],
+      ['two arguments', [{}, {}]],
+      ['a number', [42]],
+      ['a string', ['pid=1']],
+      ['null', [null]],
+    ];
+    for (const [label, args] of malformed) {
+      const failure = await rawError('sharplsp.lspProfiler.cpu.start', args);
+      assert.equal(
+        failure.code,
+        CODE.INVALID_PARAMS,
+        `[PROF-ERRORS] ${label} is INVALID_PARAMS: ${JSON.stringify(failure)}`,
+      );
+      assert.ok(failure.message.length > 0, `${label} explains itself`);
+    }
+    const extra = await rawError(cpuList, [{}, {}]);
+    assert.equal(
+      extra.code,
+      CODE.INVALID_PARAMS,
+      '[PROF-WIRE-METHODS] two valid parameter objects are rejected for their argument count',
+    );
+    // A malformed field type is invalid parameters too.
+    const wrongType = await rawError('sharplsp.lspProfiler.cpu.start', [{ pid: 'not-a-pid' }]);
+    assert.equal(
+      wrongType.code,
+      CODE.INVALID_PARAMS,
+      `pid must be a number: ${JSON.stringify(wrongType)}`,
+    );
+    const noPid = await rawError('sharplsp.lspProfiler.memory.start', [{}]);
+    assert.equal(
+      noPid.code,
+      CODE.INVALID_PARAMS,
+      `[PROF-CPU-START] a missing PID is invalid: ${JSON.stringify(noPid)}`,
+    );
+
+    // ── [PROF-HOST-ROUTING] nothing was created, and the loop still answers.
+    const sessions = await raw(cpuList, [{}]);
+    assert.deepEqual(
+      (sessions as ProfileSessionList).sessions,
+      [],
+      'no session from a refused call',
+    );
+    assert.deepEqual(await execute<ProfileSessionList>('cpu.list', {}), { sessions: [] });
+
+    // ── An unknown operation fails, and the loop survives it.
+    const unknown = await rawError('sharplsp.lspProfiler.cpu.bogus', [{}]);
+    assert.ok(
+      unknown.message.length > 0,
+      `the unknown operation is reported: ${JSON.stringify(unknown)}`,
+    );
+    assert.deepEqual(
+      (await execute<ProfileSessionList>('cpu.list', {})).sessions,
+      [],
+      '[PROF-HOST-ROUTING] the message loop was never blocked',
+    );
+  });
+
+  test('all seventeen requests enforce their typed arguments with INVALID_PARAMS and leave the server responsive', async function () {
+    this.timeout(STOP_MS * 4);
+    for (const commandId of COMMANDS) {
+      // [PROF-WIRE-METHODS] only these two requests have no required object fields.
+      const empty = ['capabilities', 'cpu.list'].some(
+        (name) => commandId === `sharplsp.lspProfiler.${name}`,
+      );
+      if (empty) {
+        const result = await raw(commandId, [{}]);
+        assert.ok(
+          result !== null && typeof result === 'object',
+          `${commandId} accepts its empty params object`,
+        );
+      } else {
+        for (const args of [[{}], [{}]]) {
+          const failure = await rawError(commandId, args);
+          assert.equal(failure.code, CODE.INVALID_PARAMS, `${commandId} requires its typed fields`);
+        }
+      }
+      // ── [PROF-HOST-ROUTING] the loop still serves the next request.
+      const sessions = await execute<ProfileSessionList>('cpu.list', {});
+      assert.ok(Array.isArray(sessions.sessions), `the loop answered after ${commandId}`);
+      // ── [PROF-CPU-START] a refused call leaves nothing running.
+      assert.deepEqual(sessions.sessions, [], `${commandId} created no CPU session`);
+    }
+    // [PROF-WIRE-METHODS] exactly one typed object, for EVERY operation.
+    for (const commandId of COMMANDS) {
+      for (const args of [[], [{}, {}], [42], ['not-an-object']]) {
+        const failure = await rawError(commandId, args);
+        assert.equal(
+          failure.code,
+          CODE.INVALID_PARAMS,
+          `${commandId} rejects ${JSON.stringify(args)}`,
+        );
+      }
+      assert.deepEqual(
+        (await execute<ProfileSessionList>('cpu.list', {})).sessions,
+        [],
+        `${commandId} with zero arguments created no session`,
+      );
+    }
+    // ── The process table still reads after the whole sweep.
+    const processes = await execute<ProcessList>('processes', { workspace_roots: [] });
+    assert.ok(processes.processes.length > 0, '[PROF-PROCESSES] discovery still works');
+    for (const entry of processes.processes) {
+      assert.ok(entry.pid > 0, 'a discovered process has a PID');
+      assert.ok(entry.name.length > 0, 'a discovered process has a name');
+      assert.ok(typeof entry.attachable === 'boolean', 'attachable is a boolean');
+      assert.ok(entry.cpu_percent >= 0, 'CPU is never negative');
+      assert.ok(entry.memory_bytes >= 0, 'memory is never negative');
+      if (!entry.attachable) {
+        assert.ok((entry.unattachable_reason ?? '').length > 0, 'a refusal explains itself');
+      }
+    }
+  });
+
+  test('the error taxonomy: PROCESS_NOT_FOUND and UNSUPPORTED_RUNTIME, kill can never reach an unprofilable process, and processes sorts attachable first with a reason on every refusal', async function () {
+    this.timeout(STOP_MS * 3);
+    const { target } = live;
+    const decoy = sleeper();
+    try {
+      // ── [PROF-ERRORS] a PID that names no process.
+      const missing = await executeError('kill', { pid: 2_147_483_647 });
+      assert.ok(missing, 'killing a missing PID fails');
+      assert.equal(
+        missing.code,
+        CODE.PROCESS_NOT_FOUND,
+        `[PROF-ERRORS] ${JSON.stringify(missing)}`,
+      );
+      const missingStart = await executeError('cpu.start', { pid: 2_147_483_647 });
+      assert.ok(missingStart, 'starting on a missing PID fails');
+      assert.equal(missingStart.code, CODE.PROCESS_NOT_FOUND, 'the same code for start');
+
+      // ── [PROF-PROCESSES-KILL] kill never reaches a process no runtime recognises.
+      const decoyPid = decoy.pid;
+      assert.ok(decoyPid !== undefined, 'the decoy has a pid');
+      const decoyKill = await executeError('kill', { pid: decoyPid });
+      assert.ok(decoyKill, 'killing an unprofilable process fails');
+      assert.equal(
+        decoyKill.code,
+        CODE.UNSUPPORTED_RUNTIME,
+        `[PROF-PROCESSES-KILL] ${JSON.stringify(decoyKill)}`,
+      );
+      assert.equal(isAlive(decoyPid), true, 'the unprofilable process is still alive');
+
+      // ── [PROF-ERRORS] the editor itself is not a profiler target either.
+      const selfStart = await executeError('cpu.start', { pid: process.pid });
+      assert.ok(selfStart, 'starting on the extension host fails');
+      assert.equal(
+        selfStart.code,
+        CODE.UNSUPPORTED_RUNTIME,
+        `an Electron host is not profiled: ${JSON.stringify(selfStart)}`,
+      );
+
+      // ── [PROF-PROCESSES] the F# target is listed, attachable, with its identity.
+      const listedProcesses = await execute<ProcessList>('processes', { workspace_roots: [] });
+      const processes = listedProcesses.processes;
+      assert.ok(Array.isArray(processes), 'processes is a list');
+      assert.ok(processes.length > 0, 'the process table is read once');
+      const fsharp = processes.find((entry) => entry.pid === target.pid);
+      assert.ok(fsharp, `the F# target is discovered: ${processes.length} processes`);
+      assert.equal(fsharp.runtime, 'dotnet', '[PROF-RUNTIME] classified as .NET');
+      assert.equal(fsharp.attachable, true, 'the target is attachable');
+      assert.ok((fsharp.runtime_version ?? '').length > 0, 'a runtime version is reported');
+      assert.ok((fsharp.entry ?? '').length > 0, 'the assembly/entry is reported');
+      assert.ok(fsharp.cpu_percent >= 0, 'CPU is a percentage');
+      assert.ok(fsharp.memory_bytes > 0, 'resident memory is in bytes');
+      assert.ok(fsharp.runtime_secs >= 0, 'uptime is in seconds');
+      assert.equal(
+        fsharp.unattachable_reason,
+        undefined,
+        'an attachable process carries no refusal reason',
+      );
+
+      // ── [PROF-PROCESSES] attachable processes sort first; every refusal is explained.
+      const firstUnattachable = processes.findIndex((entry) => !entry.attachable);
+      if (firstUnattachable >= 0) {
+        const later = processes.slice(firstUnattachable);
+        assert.ok(
+          later.every((entry) => !entry.attachable),
+          'once a process is unattachable, every later row is too',
+        );
+        for (const entry of later) {
+          assert.ok(
+            (entry.unattachable_reason ?? '').length > 0,
+            `unattachable ${entry.pid} says why: ${entry.unattachable_reason}`,
+          );
+        }
+      }
+      for (const entry of processes.slice(0, Math.max(firstUnattachable, 0))) {
+        assert.ok(entry.cpu_percent >= 0, 'an attachable row has a CPU reading');
+      }
+      assert.ok(
+        !processes.some((entry) => entry.pid === decoyPid && entry.attachable),
+        'the decoy is never offered as attachable',
+      );
+
+      // ── [PROF-PROCESSES-SCOPE] workspace membership is a display attribute, not a filter:
+      // the same processes come back with a root as without one.
+      const roots = (vscode.workspace.workspaceFolders ?? []).map((folder) => folder.uri.fsPath);
+      const scoped = await execute<ProcessList>('processes', { workspace_roots: roots });
+      const scopedTarget = scoped.processes.find((entry) => entry.pid === target.pid);
+      assert.ok(scopedTarget, 'the F# target survives scoping');
+      assert.equal(
+        fsharp.in_workspace,
+        false,
+        'without roots the fixture is outside the workspace',
+      );
+      const fixtureRoot = fsharp.entry!;
+      const containing = await execute<ProcessList>('processes', {
+        workspace_roots: [fixtureRoot],
+      });
+      assert.equal(
+        containing.processes.find((entry) => entry.pid === target.pid)?.in_workspace,
+        true,
+        '[PROF-PROCESSES-SCOPE] membership follows the supplied root, without hiding the target',
+      );
+      assert.equal(typeof scopedTarget.in_workspace, 'boolean', 'membership is a boolean flag');
+      assert.deepEqual(
+        (await execute<ProfileSessionList>('cpu.list', {})).sessions,
+        [],
+        'no refused start left a session',
+      );
+    } finally {
+      decoy.kill();
+    }
+  });
+});
diff --git a/src/editors/vscode/src/test/suite/profiler-memory-integration.test.ts b/src/editors/vscode/src/test/suite/profiler-memory-integration.test.ts
index ee783c94..2fba50c8 100644
--- a/src/editors/vscode/src/test/suite/profiler-memory-integration.test.ts
+++ b/src/editors/vscode/src/test/suite/profiler-memory-integration.test.ts
@@ -71,7 +71,7 @@ function clearDecorations(): void {
 }
 
 async function listSessions(what: string): Promise<unknown[]> {
-  return sessionsOf(await runCommand(CPU('list')), what);
+  return sessionsOf(await runCommand(CPU('list'), {}), what);
 }
 
 function assertClientRunning(why: string): void {
diff --git a/src/editors/vscode/src/test/suite/profiler-process-explorer.test.ts b/src/editors/vscode/src/test/suite/profiler-process-explorer.test.ts
index 8617a631..b0901180 100644
--- a/src/editors/vscode/src/test/suite/profiler-process-explorer.test.ts
+++ b/src/editors/vscode/src/test/suite/profiler-process-explorer.test.ts
@@ -22,7 +22,14 @@ import {
   createProfilerStore,
   type ProfilerStore as Store,
 } from '@nimblesite/lsp-profiler-ui/out/src/store';
-import { seedSignal, fakeHost, toWireProcess, ungroup } from './profiler-ui-helpers';
+import {
+  seedSignal,
+  fakeHost,
+  toWireProcess,
+  ungroup,
+  rowPid as pidOf,
+  processFixture,
+} from './profiler-ui-helpers';
 import {
   numberField,
   rawField,
@@ -31,32 +38,9 @@ import {
 
 const MB = 1024 * 1024;
 
-/** A debuggable process row; each test overrides what it exercises. */
-function proc(pid: number, overrides: Partial<ProcessInfo> = {}): ProcessInfo {
-  return {
-    pid,
-    ppid: 1,
-    name: 'python3.12',
-    interpreterPath: '/usr/bin/python3.12',
-    script: null,
-    runtime: 'python',
-    runtimeVersion: '3.12.1',
-    cpuPercent: 0,
-    memoryBytes: MB,
-    runtimeSecs: 1,
-    user: null,
-    requiresElevation: false,
-    inWorkspace: false,
-    launcher: null,
-    debuggable: true,
-    undebuggableReason: null,
-    ...overrides,
-  };
-}
-
 /** A representative process table covering launchers, users, and versions. */
 const STUB_PROCESSES: readonly ProcessInfo[] = [
-  proc(100, {
+  processFixture(100, {
     script: '/app/web.py',
     cpuPercent: 5,
     memoryBytes: 50 * MB,
@@ -64,7 +48,7 @@ const STUB_PROCESSES: readonly ProcessInfo[] = [
     user: 'alice',
     inWorkspace: true,
   }),
-  proc(200, {
+  processFixture(200, {
     name: 'python3.11',
     interpreterPath: '/usr/bin/python3.11',
     script: '/app/worker.py',
@@ -75,7 +59,7 @@ const STUB_PROCESSES: readonly ProcessInfo[] = [
     user: 'bob',
     requiresElevation: true,
   }),
-  proc(300, {
+  processFixture(300, {
     ppid: 200,
     script: '/app/uvicorn.py',
     cpuPercent: 1,
@@ -159,7 +143,7 @@ function startPid(request: RecordedRequest): unknown {
 // assertion instead of handing the test an `undefined` it would compare away.
 
 /** Read the PID a process row carries (the arg passed to inline commands). */
-function pidOf(item: vscode.TreeItem): number | undefined {
+function rowPid(item: vscode.TreeItem): number | undefined {
   return numberField(rawField(item, 'process'), 'pid');
 }
 
@@ -202,7 +186,7 @@ function actionRows(rows: vscode.TreeItem[]): vscode.TreeItem[] {
 }
 
 /** A debugger-machinery row: listed, but non-debuggable (the 🚫 / grey / sunk case). */
-const MACHINERY: ProcessInfo = proc(900, {
+const MACHINERY: ProcessInfo = processFixture(900, {
   cpuPercent: 99,
   memoryBytes: 5 * MB,
   runtimeSecs: 3,
@@ -229,12 +213,12 @@ suite('Processes Panel', () => {
     const rows = processRows(provider.getChildren());
     for (const row of rows) {
       assert.strictEqual(
-        typeof pidOf(row),
+        typeof rowPid(row),
         'number',
         'row must carry a numeric pid for the command arg',
       );
     }
-    const worker = rows.find((r) => pidOf(r) === 200);
+    const worker = rows.find((r) => rowPid(r) === 200);
     assert.ok(worker, 'the worker process row must exist');
     assert.ok(
       String(worker.description).includes('PID 200'),
@@ -245,8 +229,8 @@ suite('Processes Panel', () => {
   test('rows needing elevation get a distinct contextValue for the lock affordance', async () => {
     provider = await loadedProvider(storeWith(STUB_PROCESSES));
     const rows = provider.getChildren();
-    const elevated = rows.find((r) => pidOf(r) === 200);
-    const normal = rows.find((r) => pidOf(r) === 100);
+    const elevated = rows.find((r) => rowPid(r) === 200);
+    const normal = rows.find((r) => rowPid(r) === 100);
     assert.strictEqual(elevated?.contextValue, 'processElevated');
     assert.strictEqual(normal?.contextValue, 'process');
   });
@@ -337,8 +321,8 @@ suite('Processes Panel — inline launch actions (#79)', () => {
     provider.refresh();
     const after = provider.getChildren();
 
-    const beforeRow = before.find((row) => pidOf(row) === 200);
-    const afterRow = after.find((row) => pidOf(row) === 200);
+    const beforeRow = before.find((row) => rowPid(row) === 200);
+    const afterRow = after.find((row) => rowPid(row) === 200);
     assert.ok(
       beforeRow !== undefined && afterRow !== undefined,
       'PID 200 row must exist in both passes',
@@ -356,7 +340,7 @@ suite('Processes Panel — inline launch actions (#79)', () => {
     const store = storeWith(STUB_PROCESSES, requests);
     provider = await loadedProvider(store);
     const rows = provider.getChildren();
-    const selectedRow = rows.find((row) => pidOf(row) === 200);
+    const selectedRow = rows.find((row) => rowPid(row) === 200);
     assert.ok(selectedRow !== undefined, 'PID 200 row must exist');
 
     const actions = createProcessRowActions(store, { selection: [selectedRow] });
@@ -377,8 +361,8 @@ suite('Processes Panel — inline launch actions (#79)', () => {
     const store = storeWith(STUB_PROCESSES, requests);
     provider = await loadedProvider(store);
     const rows = provider.getChildren();
-    const clicked = rows.find((row) => pidOf(row) === 300);
-    const selected = rows.find((row) => pidOf(row) === 200);
+    const clicked = rows.find((row) => rowPid(row) === 300);
+    const selected = rows.find((row) => rowPid(row) === 200);
     assert.ok(clicked !== undefined && selected !== undefined, 'both rows must exist');
 
     const actions = createProcessRowActions(store, { selection: [selected] });
@@ -420,7 +404,7 @@ suite('Processes Panel — Track Memory routing', () => {
     const store = storeWith(STUB_PROCESSES, requests);
     arrange(store);
     const rows = (await loadedProvider(store)).getChildren();
-    const selectedRow = rows.find((row) => pidOf(row) === 100);
+    const selectedRow = rows.find((row) => rowPid(row) === 100);
     assert.ok(selectedRow !== undefined, 'PID 100 row must exist');
 
     const actions = createProcessRowActions(
@@ -497,7 +481,7 @@ suite('Processes Panel — zero-filter display cues', () => {
   test('launchers are always listed and carry a framework chip (zero filters)', async () => {
     provider = await loadedProvider(storeWith(STUB_PROCESSES));
     const rows = provider.getChildren();
-    const uvicorn = rows.find((r) => pidOf(r) === 300);
+    const uvicorn = rows.find((r) => rowPid(r) === 300);
     assert.ok(uvicorn, 'the uvicorn launcher must always be listed — nothing is hidden');
     assert.ok(
       String(uvicorn.description).includes('[uvicorn]'),
@@ -510,8 +494,8 @@ suite('Processes Panel — zero-filter display cues', () => {
     const decorations = new ProcessDecorationProvider(provider);
     try {
       const rows = provider.getChildren();
-      const inside = rows.find((r) => pidOf(r) === 100); // inWorkspace: true
-      const outside = rows.find((r) => pidOf(r) === 300); // inWorkspace: false, debuggable
+      const inside = rows.find((r) => rowPid(r) === 100); // inWorkspace: true
+      const outside = rows.find((r) => rowPid(r) === 300); // inWorkspace: false, debuggable
       assert.ok(inside && outside, 'both the workspace and outside rows must exist');
       const insideUri = resourceUri(inside);
       const outsideUri = resourceUri(outside);
@@ -555,11 +539,11 @@ suite('Processes Panel — zero-filter display cues', () => {
     try {
       const rows = provider.getChildren();
       assert.strictEqual(
-        pidOf(rows[rows.length - 1]!),
+        rowPid(rows[rows.length - 1]!),
         900,
         'the non-debuggable row sinks to the bottom despite the highest CPU',
       );
-      const machineryRow = rows.find((r) => pidOf(r) === 900);
+      const machineryRow = rows.find((r) => rowPid(r) === 900);
       assert.ok(machineryRow, 'the machinery process must still be LISTED, not hidden');
       assert.ok(
         labelText(machineryRow).startsWith('🚫'),
@@ -603,7 +587,7 @@ suite('Processes Panel — display cues: icons, precedence, tooltip, grouping',
     store.profilerActive(100, 'sess-cpu'); // mark PID 100 as actively profiled (store-derived, #148)
     provider = await loadedProvider(store);
     const rows = provider.getChildren();
-    const icons = new Map(rows.map((r) => [pidOf(r), iconId(r)]));
+    const icons = new Map(rows.map((r) => [rowPid(r), iconId(r)]));
     assert.strictEqual(icons.get(100), 'flame', 'the actively-profiled row shows the flame');
     assert.strictEqual(
       icons.get(200),
@@ -624,7 +608,7 @@ suite('Processes Panel — display cues: icons, precedence, tooltip, grouping',
     provider = await loadedProvider(storeWith([wsMachinery]));
     const decorations = new ProcessDecorationProvider(provider);
     try {
-      const row = processRows(provider.getChildren()).find((r) => pidOf(r) === 900);
+      const row = processRows(provider.getChildren()).find((r) => rowPid(r) === 900);
       assert.ok(row, 'the process row must exist');
       const uri = resourceUri(row);
       assert.ok(uri, 'the row must carry a resourceUri');
@@ -640,7 +624,7 @@ suite('Processes Panel — display cues: icons, precedence, tooltip, grouping',
   });
 
   test('the tooltip surfaces every resolved detail (R8)', async () => {
-    const rich: ProcessInfo = proc(555, {
+    const rich: ProcessInfo = processFixture(555, {
       script: '/app/svc.py',
       cpuPercent: 7,
       memoryBytes: 12 * MB,
@@ -650,7 +634,7 @@ suite('Processes Panel — display cues: icons, precedence, tooltip, grouping',
       launcher: 'gunicorn',
     });
     provider = await loadedProvider(storeWith([rich]));
-    const row = processRows(provider.getChildren()).find((r) => pidOf(r) === 555);
+    const row = processRows(provider.getChildren()).find((r) => rowPid(r) === 555);
     assert.ok(row, 'the process row must exist');
     const tip = tooltipText(row);
     for (const needle of [
@@ -668,7 +652,7 @@ suite('Processes Panel — display cues: icons, precedence, tooltip, grouping',
   });
 
   test('a row opens its entry on click only when the runtime advertises source entries', async () => {
-    const script: ProcessInfo = proc(557, {
+    const script: ProcessInfo = processFixture(557, {
       name: 'python3',
       interpreterPath: '/usr/bin/python3',
       script: '/app/run.py',
@@ -683,25 +667,25 @@ suite('Processes Panel — display cues: icons, precedence, tooltip, grouping',
     };
     provider = await loadedProvider(storeWith([script, binary]));
     const rows = processRows(provider.getChildren());
-    const opens = rows.find((r) => pidOf(r) === 557)?.command;
+    const opens = rows.find((r) => rowPid(r) === 557)?.command;
     assert.strictEqual(opens?.command, 'vscode.open', 'a source entry opens in the editor');
     assert.strictEqual(String(opens?.arguments?.[0]), vscode.Uri.file('/app/run.py').toString());
     assert.strictEqual(
-      rows.find((r) => pidOf(r) === 558)?.command,
+      rows.find((r) => rowPid(r) === 558)?.command,
       undefined,
       'a runtime that never advertised source entries never opens its (binary) entry',
     );
   });
 
   test('a runtime the server never advertised is labelled by its wire id, not a guessed name', async () => {
-    const odd: ProcessInfo = proc(556, {
+    const odd: ProcessInfo = processFixture(556, {
       name: 'dotnet',
       interpreterPath: null,
       runtime: 'dotnet',
       runtimeVersion: '8.0.1',
     });
     provider = await loadedProvider(storeWith([odd]));
-    const row = processRows(provider.getChildren()).find((r) => pidOf(r) === 556);
+    const row = processRows(provider.getChildren()).find((r) => rowPid(r) === 556);
     assert.ok(row, 'the process row must exist');
     const tip = tooltipText(row);
     assert.ok(tip.includes('dotnet: 8.0.1'), `the wire id labels the version: ${tip}`);
@@ -796,7 +780,7 @@ suite('Processes Panel — Track Memory is debuggee-only', () => {
     provider = await loadedProvider(store);
     const rows = processRows(provider.getChildren());
     function ctxOf(pid: number): string | undefined {
-      return rows.find((r) => pidOf(r) === pid)?.contextValue;
+      return rows.find((r) => rowPid(r) === pid)?.contextValue;
     }
     assert.strictEqual(ctxOf(100), 'processDebuggee', 'the debuggee row enables Track Memory');
     assert.strictEqual(ctxOf(200), 'processElevated', 'an external (elevated) row does not');
@@ -808,8 +792,8 @@ suite('Processes Panel — Track Memory is debuggee-only', () => {
     store.setActiveDebuggeePid(100);
     provider = await loadedProvider(store);
     const rows = processRows(provider.getChildren());
-    const debuggee = rows.find((r) => pidOf(r) === 100);
-    const external = rows.find((r) => pidOf(r) === 300);
+    const debuggee = rows.find((r) => rowPid(r) === 100);
+    const external = rows.find((r) => rowPid(r) === 300);
     assert.ok(debuggee && external, 'both rows must exist');
     assert.ok(
       !tooltipText(debuggee).includes('Memory tracking needs'),
@@ -865,7 +849,7 @@ suite('Processes Panel — inline action target (issue #79)', () => {
     const provider = await loadedProvider(store);
     try {
       const rows = provider.getChildren();
-      const selected = rows.find((row) => pidOf(row) === 100);
+      const selected = rows.find((row) => rowPid(row) === 100);
       assert.ok(selected, 'expected the PID 100 row');
 
       const actions = createProcessRowActions(store, { selection: [selected] });
@@ -888,7 +872,7 @@ suite('Processes Panel — inline action target (issue #79)', () => {
     const provider = await loadedProvider(store);
     try {
       const rows = provider.getChildren();
-      const selected = rows.find((row) => pidOf(row) === 200);
+      const selected = rows.find((row) => rowPid(row) === 200);
       assert.ok(selected, 'expected the PID 200 row');
 
       const actions = createProcessRowActions(
@@ -934,7 +918,7 @@ suite('Processes Panel — inline action target (issue #79)', () => {
 // CPU action: package.json reveals it via `viewItem =~ /^process/`, and the
 // command handler is the last line of defence against a stale/raced row (#266).
 suite('Processes Panel — blocked rows never offer Profile CPU (#266)', () => {
-  const BLOCKED_MACHINERY: ProcessInfo = proc(400, {
+  const BLOCKED_MACHINERY: ProcessInfo = processFixture(400, {
     ppid: 100,
     name: 'python3.13',
     interpreterPath: '/usr/bin/python3.13',
@@ -954,7 +938,7 @@ suite('Processes Panel — blocked rows never offer Profile CPU (#266)', () => {
   test("a non-debuggable row's contextValue opts out of the /^process/ menu clauses", async () => {
     provider = await loadedProvider(storeWith([...STUB_PROCESSES, BLOCKED_MACHINERY]));
     const rows = processRows(provider.getChildren());
-    const blocked = rows.find((row) => pidOf(row) === 400);
+    const blocked = rows.find((row) => rowPid(row) === 400);
     assert.ok(blocked !== undefined, 'the machinery row must still be listed (zero-filter)');
     const ctx = blocked.contextValue ?? '';
     // package.json's clause is `viewItem =~ /^process/` — an anchored
@@ -971,7 +955,7 @@ suite('Processes Panel — blocked rows never offer Profile CPU (#266)', () => {
     const store = storeWith([...STUB_PROCESSES, BLOCKED_MACHINERY], requests);
     provider = await loadedProvider(store);
     const rows = processRows(provider.getChildren());
-    const blocked = rows.find((row) => pidOf(row) === 400);
+    const blocked = rows.find((row) => rowPid(row) === 400);
     assert.ok(blocked !== undefined, 'the machinery row must exist');
 
     const actions = createProcessRowActions(store, { selection: [blocked] });
diff --git a/src/editors/vscode/src/test/suite/profiler-ui-debuggee.ts b/src/editors/vscode/src/test/suite/profiler-ui-debuggee.ts
index f20eba87..16e028d5 100644
--- a/src/editors/vscode/src/test/suite/profiler-ui-debuggee.ts
+++ b/src/editors/vscode/src/test/suite/profiler-ui-debuggee.ts
@@ -95,6 +95,24 @@ const PROJECT = `<Project Sdk="Microsoft.NET.Sdk">
 </Project>
 `;
 
+/** A debuggee's sources: its assembly name, project file and one program file. */
+export interface DebuggeeSource {
+  readonly name: string;
+  readonly projectFile: string;
+  readonly project: string;
+  readonly sourceFile: string;
+  readonly program: string;
+}
+
+/** The C# debuggee above. */
+export const CSHARP_DEBUGGEE: DebuggeeSource = {
+  name: DEBUGGEE_NAME,
+  projectFile: `${DEBUGGEE_NAME}.csproj`,
+  project: PROJECT,
+  sourceFile: 'Program.cs',
+  program: PROGRAM,
+};
+
 /** A built debuggee and where its program lives. */
 export interface Debuggee {
   readonly project: ConsoleProject;
@@ -103,20 +121,23 @@ export interface Debuggee {
   readonly folder: vscode.WorkspaceFolder;
 }
 
-/** Write and build the debuggee under a fresh scratch dir in the workspace. */
-export async function materialiseDebuggee(prefix: string): Promise<Debuggee> {
+/** Write and build `source` under a fresh scratch dir in the workspace. */
+export async function materialiseDebuggee(
+  prefix: string,
+  source: DebuggeeSource = CSHARP_DEBUGGEE,
+): Promise<Debuggee> {
   const root = fs.mkdtempSync(path.join(requireWorkspaceRoot(), prefix));
   isolateFromRepoMsbuild(root);
-  const dir = path.join(root, DEBUGGEE_NAME);
+  const dir = path.join(root, source.name);
   fs.mkdirSync(dir, { recursive: true });
-  fs.writeFileSync(path.join(dir, `${DEBUGGEE_NAME}.csproj`), PROJECT, 'utf8');
-  const program = path.join(dir, 'Program.cs');
-  fs.writeFileSync(program, PROGRAM, 'utf8');
+  fs.writeFileSync(path.join(dir, source.projectFile), source.project, 'utf8');
+  const program = path.join(dir, source.sourceFile);
+  fs.writeFileSync(program, source.program, 'utf8');
   const project: ConsoleProject = {
-    projectFile: path.join(dir, `${DEBUGGEE_NAME}.csproj`),
+    projectFile: path.join(dir, source.projectFile),
     sourceFile: program,
     dir,
-    assemblyName: DEBUGGEE_NAME,
+    assemblyName: source.name,
   };
   await buildProject(project);
   const dll = builtDll(project);
@@ -227,12 +248,13 @@ export interface DebuggeeHarness {
 export function useDebuggee(
   prefix: string,
   cleanup: () => Promise<unknown> | undefined = () => undefined,
+  source: DebuggeeSource = CSHARP_DEBUGGEE,
 ): DebuggeeHarness {
   let built: Debuggee | undefined;
   let recorder: DapRecorder | undefined;
   suiteSetup(async function () {
     this.timeout(FIXTURE_BUILD_MS);
-    built = await materialiseDebuggee(prefix);
+    built = await materialiseDebuggee(prefix, source);
   });
   suiteTeardown(async () => {
     await vscode.commands.executeCommand('workbench.action.closeAllEditors');
diff --git a/src/editors/vscode/src/test/suite/profiler-ui-helpers.ts b/src/editors/vscode/src/test/suite/profiler-ui-helpers.ts
index 446865da..6941196e 100644
--- a/src/editors/vscode/src/test/suite/profiler-ui-helpers.ts
+++ b/src/editors/vscode/src/test/suite/profiler-ui-helpers.ts
@@ -16,12 +16,13 @@ import type { ProcessInfo } from '@nimblesite/lsp-profiler-ui/out/src/process-ex
 import type { ProcessInfo as WireProcess } from '@nimblesite/lsp-profiler-ui/out/src/wire-generated';
 import { delay } from '@nimblesite/lsp-profiler-ui/out/src/timeouts';
 import type { ProfileResult } from '@nimblesite/lsp-profiler-ui/out/src/profiler-decorations';
+import type { MemoryDashboardSnapshot } from '@nimblesite/lsp-profiler-ui/out/src/memory-dashboard';
 import type {
   MemoryDiffResult,
   MemorySnapshotResult,
   SuspectedLeak,
 } from '@nimblesite/lsp-profiler-ui/out/src/memory-decorations';
-import { rawField } from '@nimblesite/lsp-profiler-ui/out/src/unknown-shape';
+import { numberField, rawField } from '@nimblesite/lsp-profiler-ui/out/src/unknown-shape';
 import * as assert from 'node:assert/strict';
 import { errorMessage } from './profiler-ui-caught-error';
 import { lspClient, profilerStore } from './profiler-kit';
@@ -254,21 +255,44 @@ export function isRegistered(commandId: string): boolean {
   }
 }
 
-/** Swap `showWarningMessage` for a recorder while `body` runs. */
-export async function captureWarnings(body: () => Promise<unknown>): Promise<string[]> {
-  const warnings: string[] = [];
-  const window = vscode.window as { showWarningMessage: unknown };
-  const original = window.showWarningMessage;
-  window.showWarningMessage = async (message: string): Promise<undefined> => {
-    warnings.push(message);
+/** The notifications shown while a body ran, by severity, with the actions each offered. */
+export interface Toasts {
+  readonly info: { message: string; actions: string[] }[];
+  readonly warning: string[];
+  readonly error: string[];
+}
+
+type ToastWindow = Record<
+  'showInformationMessage' | 'showWarningMessage' | 'showErrorMessage',
+  unknown
+>;
+
+/** Swap every notification for a recorder while `body` runs. */
+export async function captureToasts(body: () => PromiseLike<unknown>): Promise<Toasts> {
+  const toasts: Toasts = { info: [], warning: [], error: [] };
+  const window = vscode.window as unknown as ToastWindow;
+  const original: ToastWindow = {
+    showInformationMessage: window.showInformationMessage,
+    showWarningMessage: window.showWarningMessage,
+    showErrorMessage: window.showErrorMessage,
+  };
+  window.showInformationMessage = async (message: string, ...items: unknown[]) => {
+    toasts.info.push({ message, actions: items.filter((i): i is string => typeof i === 'string') });
     return undefined;
   };
+  window.showWarningMessage = async (message: string) => void toasts.warning.push(message);
+  window.showErrorMessage = async (message: string) => void toasts.error.push(message);
   try {
     await body();
   } finally {
-    window.showWarningMessage = original;
+    Object.assign(window, original);
   }
-  return warnings;
+  return toasts;
+}
+
+/** Swap `showWarningMessage` for a recorder while `body` runs. */
+export async function captureWarnings(body: () => Promise<unknown>): Promise<string[]> {
+  return (await captureToasts(body)).warning;
 }
 
 /** A C# source with twelve numbered lines, for decorations to land on. */
@@ -352,3 +376,99 @@ export function assertHardened(html: string, what: string): void {
   );
   assert.ok(!html.includes('</script><img'), `${what}: untrusted data must not close the <script>`);
 }
+
+// ── Process-row fixtures ([PROF-UI-PROCESSES]) ─────────────────────
+
+const MB = 1024 * 1024;
+
+/**
+ * A debuggable process row; each caller overrides what it exercises. The
+ * one fixture every Processes-panel test builds its table from.
+ */
+export function processFixture(pid: number, overrides: Partial<ProcessInfo> = {}): ProcessInfo {
+  return {
+    pid,
+    ppid: 1,
+    name: 'python3.12',
+    interpreterPath: '/usr/bin/python3.12',
+    script: null,
+    runtime: 'python',
+    runtimeVersion: '3.12.1',
+    cpuPercent: 0,
+    memoryBytes: MB,
+    runtimeSecs: 1,
+    user: null,
+    requiresElevation: false,
+    inWorkspace: false,
+    launcher: null,
+    debuggable: true,
+    undebuggableReason: null,
+    ...overrides,
+  };
+}
+
+/** Read the PID a process row carries (the arg passed to inline commands). */
+export function rowPid(item: vscode.TreeItem): number | undefined {
+  // `process` is attached to the row by the provider under test, not by
+  // `vscode.TreeItem`, so it is read back by name rather than asserted on.
+  return numberField(rawField(item, 'process'), 'pid');
+}
+
+/** The row of `pid`, failing the test when the panel dropped it. */
+export function rowByPid(
+  rows: readonly vscode.TreeItem[],
+  pid: number,
+  what: string,
+): vscode.TreeItem {
+  const row = rows.find((item) => rowPid(item) === pid);
+  assert.ok(row !== undefined, `${what}: the PID ${pid} row must exist`);
+  return row;
+}
+
+// ── Decoration ledgers ─────────────────────────────────────────────
+
+/** What one applied decoration must show: its line, a colour, text it carries. */
+export interface PaintedExpectation {
+  readonly line?: number;
+  readonly color?: string;
+  /** A substring the decoration's after-line text must include. */
+  readonly includes?: string;
+}
+
+/** Assert a decoration was applied and shows exactly what `expect` names. */
+export function assertPainted(
+  painted: { line: number; color: string; contentText: string } | undefined,
+  expect: PaintedExpectation,
+  what: string,
+): void {
+  assert.ok(painted !== undefined, `${what}: a decoration must be applied`);
+  if (expect.line !== undefined) {
+    assert.equal(painted.line, expect.line, `${what}: it lands on its line`);
+  }
+  if (expect.color !== undefined) {
+    assert.equal(painted.color, expect.color, `${what}: it wears its colour`);
+  }
+  if (expect.includes !== undefined) {
+    assert.ok(painted.contentText.includes(expect.includes), painted.contentText);
+  }
+}
+
+// ── Dashboard snapshots ────────────────────────────────────────────
+
+/** A minimal dashboard snapshot (fresh session: one capture, no diff yet). */
+export function dashboardSnapshot(
+  overrides: Partial<MemoryDashboardSnapshot> = {},
+): MemoryDashboardSnapshot {
+  return {
+    memorySessionId: 'mem-1',
+    snapshotId: 'snap-1',
+    currentMemory: 1_048_576,
+    peakMemory: 2_097_152,
+    gcObjects: 1200,
+    gcCounts: [700, 12, 3],
+    topAllocations: [{ file: '/app/Program.cs', line: 10, size: 4096, count: 8 }],
+    timeline: [],
+    heapProfilePath: '',
+    ...overrides,
+  };
+}
diff --git a/src/editors/vscode/src/test/suite/profiler-webviews.test.ts b/src/editors/vscode/src/test/suite/profiler-webviews.test.ts
index 9baf09ae..5b8434b4 100644
--- a/src/editors/vscode/src/test/suite/profiler-webviews.test.ts
+++ b/src/editors/vscode/src/test/suite/profiler-webviews.test.ts
@@ -19,7 +19,6 @@ import {
 } from '@nimblesite/lsp-profiler-ui/out/src/profiler-webview';
 import {
   buildMemoryDashboardHtml,
-  type MemoryDashboardSnapshot,
   type MemoryDiffData,
 } from '@nimblesite/lsp-profiler-ui/out/src/memory-dashboard';
 import { buildRefGraphHtml } from '@nimblesite/lsp-profiler-ui/out/src/memory-ref-graph';
@@ -33,6 +32,7 @@ import {
   assertHardened,
   assertHtml,
   closeAllEditors,
+  dashboardSnapshot,
   pollUntilResult,
   profileResult as baseResult,
   removeTestDir,
@@ -42,23 +42,6 @@ import {
 const HOSTILE = '</script><img src=x onerror=alert(1)>';
 const SOURCE = '/app/Program.cs';
 
-function dashboardSnapshot(
-  overrides: Partial<MemoryDashboardSnapshot> = {},
-): MemoryDashboardSnapshot {
-  return {
-    memorySessionId: 'mem-1',
-    snapshotId: 'snap-1',
-    currentMemory: 1_048_576,
-    peakMemory: 2_097_152,
-    gcObjects: 1200,
-    gcCounts: [700, 12, 3],
-    topAllocations: [{ file: SOURCE, line: 10, size: 4096, count: 8 }],
-    timeline: [],
-    heapProfilePath: '',
-    ...overrides,
-  };
-}
-
 function profileResult(overrides: Partial<ProfileResult> = {}): ProfileResult {
   return baseResult({
     hotFunctions: [
diff --git a/src/editors/vscode/src/test/suite/real-repo-helpers.ts b/src/editors/vscode/src/test/suite/real-repo-helpers.ts
index c2e71b96..2e939b73 100644
--- a/src/editors/vscode/src/test/suite/real-repo-helpers.ts
+++ b/src/editors/vscode/src/test/suite/real-repo-helpers.ts
@@ -6,9 +6,10 @@
 // extension host and assert on the LSP results and on the server processes'
 // memory/CPU footprint.
 import * as assert from 'node:assert/strict';
-import { execFileSync } from 'node:child_process';
+import { execFile } from 'node:child_process';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { promisify } from 'node:util';
 import * as vscode from 'vscode';
 import { EXTENSION_ID, removeDirRecursive, waitForHoverResult } from './test-helpers';
 import { REAL_REPO_MS } from './test-timeouts';
@@ -57,22 +58,26 @@ export function realWorldFixturesRoot(): string {
 
 const RESTORED_MARKER = '.sharplsp-restored';
 
+/** A child process, awaited so the extension host keeps running meanwhile. */
+const run = promisify(execFile);
+
 /**
  * Clone (shallow, pinned tag) and `dotnet restore` a real repo, once.
  * Subsequent runs reuse the existing clone. The clone's `global.json` is
  * removed so the fixture restores with whatever modern SDK is installed —
  * the same workspace-independent SDK policy the sidecar applies per
- * [DIST-SDK-DISCOVERY]; the LSP behavior under test is identical.
+ * [DIST-SDK-DISCOVERY]; the LSP behavior under test is identical. Both steps run
+ * asynchronously: a cold restore of a large multi-target solution takes minutes,
+ * and a synchronous one would freeze the extension host for all of them.
  */
-export function ensureRepoReady(spec: RealRepoSpec): string {
+export async function ensureRepoReady(spec: RealRepoSpec): Promise<string> {
   const root = realWorldFixturesRoot();
   fs.mkdirSync(root, { recursive: true });
   const repoDir = path.join(root, spec.name);
   if (!fs.existsSync(path.join(repoDir, spec.sln))) {
     removeDirRecursive(repoDir);
-    execFileSync('git', ['clone', '--depth', '1', '--branch', spec.tag, spec.url, spec.name], {
+    await run('git', ['clone', '--depth', '1', '--branch', spec.tag, spec.url, spec.name], {
       cwd: root,
-      stdio: 'pipe',
       timeout: REAL_REPO_MS,
     });
   }
@@ -87,16 +92,15 @@ export function ensureRepoReady(spec: RealRepoSpec): string {
     // exists to drive the LSP against real-world code, not to audit that code's
     // dependencies. Same normalisation as removing global.json above.
     try {
-      execFileSync('dotnet', ['restore', spec.sln, '-p:NuGetAudit=false'], {
+      await run('dotnet', ['restore', spec.sln, '-p:NuGetAudit=false'], {
         cwd: repoDir,
-        stdio: 'pipe',
         timeout: REAL_REPO_MS,
       });
     } catch (err: unknown) {
       // stdio:'pipe' captures NuGet's diagnostics and the default rethrow discards
       // them, leaving only "Command failed: dotnet restore". Surface them.
-      const e = err as { stdout?: Buffer; stderr?: Buffer; message?: string };
-      const detail = `${e.stdout?.toString() ?? ''}${e.stderr?.toString() ?? ''}`.trim();
+      const e = err as { stdout?: string; stderr?: string; message?: string };
+      const detail = `${e.stdout ?? ''}${e.stderr ?? ''}`.trim();
       throw new Error(`dotnet restore ${spec.sln} failed:\n${detail || (e.message ?? '')}`, {
         cause: err,
       });
diff --git a/src/editors/vscode/src/test/suite/real-repo-kit.ts b/src/editors/vscode/src/test/suite/real-repo-kit.ts
index 2b09b105..3783a79d 100644
--- a/src/editors/vscode/src/test/suite/real-repo-kit.ts
+++ b/src/editors/vscode/src/test/suite/real-repo-kit.ts
@@ -50,9 +50,14 @@ export function useRealRepo(
   [snippet, focus]: Anchor,
 ): () => string {
   let repoDir = '';
+  // The clone and restore have a budget of their own: a cold restore can take
+  // minutes, and it must never eat the time the load and warm-up below need.
+  suiteSetup(async function () {
+    this.timeout(REAL_REPO_MS);
+    repoDir = await ensureRepoReady(spec);
+  });
   suiteSetup(async function () {
     this.timeout(REAL_REPO_MS);
-    repoDir = ensureRepoReady(spec);
     await loadSolutionInServer(path.join(repoDir, spec.sln));
     const { doc, uri } = await openRepoFile(repoDir, file);
     await waitForDocumentSymbols(uri, REAL_REPO_WARMUP_MS);
diff --git a/src/editors/vscode/src/test/suite/test-runner-selection.test.ts b/src/editors/vscode/src/test/suite/test-runner-selection.test.ts
new file mode 100644
index 00000000..9c0f768d
--- /dev/null
+++ b/src/editors/vscode/src/test/suite/test-runner-selection.test.ts
@@ -0,0 +1,58 @@
+// Tests for [DIST-CI-WIN-VSIX] and [NETFX-SCOPE]: which suites a run executes.
+//
+// The runner (./index) turns MOCHA_FILES into the suites Mocha loads. A request
+// that resolves to nothing must fail, never pass a run of zero tests: a pattern
+// matching no compiled suite, and, off Windows, a pattern naming only suites of
+// `windowsOnly` chunks, whose .NET Framework test hosts need the desktop CLR.
+// The Windows-only names are the real test-chunks.json's.
+import * as assert from 'node:assert/strict';
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { removeDirRecursive } from '../../utils';
+import { resolveSuiteFiles } from './index';
+
+const NETFX_LANGUAGE = 'netfx-language.test.js';
+const NETFX_RUN = 'netfx-run-fsharp.test.js';
+const EVERYWHERE = 'everywhere.test.js';
+const COMPILED = [EVERYWHERE, NETFX_LANGUAGE, NETFX_RUN];
+
+suite('Test runner — suite selection', () => {
+  let root = '';
+
+  suiteSetup(() => {
+    root = fs.mkdtempSync(path.join(os.tmpdir(), 'slsp-select-'));
+    for (const suiteFile of COMPILED) {
+      fs.writeFileSync(path.join(root, suiteFile), '');
+    }
+  });
+
+  suiteTeardown(() => removeDirRecursive(root));
+
+  test('off Windows: a pattern naming only Windows-only suites fails with the platform reason → a broad pattern runs the rest', () => {
+    assert.throws(
+      () => resolveSuiteFiles(root, [NETFX_LANGUAGE], 'linux'),
+      /selects only Windows-only suites, which run on Windows alone \(\[NETFX-SCOPE\]\): netfx-language\.test\.js$/,
+    );
+    assert.throws(
+      () => resolveSuiteFiles(root, [EVERYWHERE, 'netfx-*.test.js'], 'darwin'),
+      /Windows alone .*: netfx-\*\.test\.js$/,
+      'one Windows-only pattern fails the whole request',
+    );
+    assert.deepEqual(resolveSuiteFiles(root, ['*.test.js'], 'linux'), [EVERYWHERE]);
+    assert.deepEqual(resolveSuiteFiles(root, [EVERYWHERE], 'darwin'), [EVERYWHERE]);
+  });
+
+  test('on Windows: the same patterns run their suites → a pattern matching nothing still fails', () => {
+    assert.deepEqual(resolveSuiteFiles(root, [NETFX_LANGUAGE], 'win32'), [NETFX_LANGUAGE]);
+    assert.deepEqual(resolveSuiteFiles(root, ['netfx-*.test.js'], 'win32'), [
+      NETFX_LANGUAGE,
+      NETFX_RUN,
+    ]);
+    assert.deepEqual(resolveSuiteFiles(root, ['*.test.js'], 'win32'), [...COMPILED].sort());
+    assert.throws(
+      () => resolveSuiteFiles(root, ['nowhere.test.js'], 'win32'),
+      /matched no compiled suite: nowhere\.test\.js$/,
+    );
+  });
+});
diff --git a/src/editors/vscode/test-chunks.json b/src/editors/vscode/test-chunks.json
index f5c37a2b..4a2c60fb 100644
--- a/src/editors/vscode/test-chunks.json
+++ b/src/editors/vscode/test-chunks.json
@@ -191,7 +191,8 @@
         "nuget-browser.test.js",
         "nuget-deps-e2e.test.js",
         "fsi-build-output-e2e.test.js",
-        "utils.test.js"
+        "utils.test.js",
+        "test-runner-selection.test.js"
       ]
     },
     "profiler": {
diff --git a/src/sharplsp/src/diagnostics.rs b/src/sharplsp/src/diagnostics.rs
index d07386bd..e59eb6e8 100644
--- a/src/sharplsp/src/diagnostics.rs
+++ b/src/sharplsp/src/diagnostics.rs
@@ -85,6 +85,9 @@ struct SolutionDiagnosticsRequest {
     project_filter: Vec<String>,
 }
 
+/// A document to push diagnostics for: its owning sidecar, URI and native path.
+pub type PushTarget = (Arc<SidecarManager>, Uri, String);
+
 /// Spawn a background task to fetch diagnostics and publish them.
 ///
 /// Non-blocking: the main loop continues processing messages while
@@ -103,6 +106,57 @@ pub fn request_in_background(
     });
 }
 
+/// Publish every target's diagnostics NOW, concurrently, and return once each
+/// first answer is out, so whatever the caller sends next follows them. A fetch
+/// that failed, or answered a provisional set, goes on as a background push.
+/// Implements [NETFX-CONTEXT] and [DIAG-PUSH-GATE].
+pub fn publish_now(
+    runtime: &tokio::runtime::Runtime,
+    targets: Vec<PushTarget>,
+    sender: &crossbeam_channel::Sender<Message>,
+) {
+    let unfinished = runtime.block_on(async {
+        let mut pushes = tokio::task::JoinSet::new();
+        for target in targets {
+            let generation = next_generation(&target.1);
+            let _push = pushes.spawn(first_push(target, generation, sender.clone()));
+        }
+        still_pushing(pushes).await
+    });
+    for (sidecar, uri, file_path) in unfinished {
+        request_in_background(runtime, sidecar, sender.clone(), uri, file_path);
+    }
+}
+
+/// A target's first fetch and publish; the target back when its push must go on.
+async fn first_push(
+    target: PushTarget,
+    generation: u64,
+    sender: crossbeam_channel::Sender<Message>,
+) -> Option<PushTarget> {
+    let (sidecar, uri, file_path) = &target;
+    let source_tag = source_tag_for_uri(uri);
+    let again = publish_once(sidecar, &sender, uri, file_path, &source_tag, generation)
+        .await
+        .unwrap_or_else(|err| {
+            warn!(uri = %uri.as_str(), "Sidecar diagnostics unavailable: {err:#}");
+            true
+        });
+    again.then_some(target)
+}
+
+/// Every first push finished: the targets whose push must go on.
+async fn still_pushing(mut pushes: tokio::task::JoinSet<Option<PushTarget>>) -> Vec<PushTarget> {
+    let mut unfinished = Vec::new();
+    while let Some(joined) = pushes.join_next().await {
+        match joined {
+            Ok(again) => unfinished.extend(again),
+            Err(err) => warn!("Diagnostics push task failed: {err}"),
+        }
+    }
+    unfinished
+}
+
 /// Register a new push generation for `uri`, superseding in-flight fetches.
 /// [DIAG-PUSH-GATE]
 fn next_generation(uri: &Uri) -> u64 {
@@ -188,18 +242,10 @@ async fn fetch_and_publish_gated(
     generation: u64,
 ) {
     for attempt in 1..=MAX_PUSH_ATTEMPTS {
-        if sidecar.is_shutting_down() || !is_current(uri, generation) {
-            return;
-        }
-        match fetch(sidecar, file_path, source_tag).await {
-            Ok(diagnostics) => {
-                if !publish_provisional(sender, uri, generation, diagnostics) {
-                    return;
-                }
-            }
-            Err(err) => {
-                warn!("Sidecar diagnostics unavailable (attempt {attempt}): {err:#}");
-            }
+        match publish_once(sidecar, sender, uri, file_path, source_tag, generation).await {
+            Ok(false) => return,
+            Ok(true) => {}
+            Err(err) => warn!("Sidecar diagnostics unavailable (attempt {attempt}): {err:#}"),
         }
         tokio::time::sleep(PUSH_RETRY_DELAY).await;
     }
@@ -209,6 +255,24 @@ async fn fetch_and_publish_gated(
     );
 }
 
+/// One gated fetch and publish. `Ok(true)` when the published set is
+/// provisional and the push must go on, `Ok(false)` when it is done or
+/// superseded, and the fetch's error when it must retry. [DIAG-PUSH-GATE]
+async fn publish_once(
+    sidecar: &SidecarManager,
+    sender: &crossbeam_channel::Sender<Message>,
+    uri: &Uri,
+    file_path: &str,
+    source_tag: &str,
+    generation: u64,
+) -> Result<bool> {
+    if sidecar.is_shutting_down() || !is_current(uri, generation) {
+        return Ok(false);
+    }
+    let diagnostics = fetch(sidecar, file_path, source_tag).await?;
+    Ok(publish_provisional(sender, uri, generation, diagnostics))
+}
+
 /// Determine the diagnostic source tag based on the document language.
 fn source_tag_for_uri(uri: &Uri) -> String {
     match crate::tree_sitter_parse::LangId::from_uri(uri) {
diff --git a/src/sharplsp/src/main.rs b/src/sharplsp/src/main.rs
index a31a5dc1..f409ef15 100644
--- a/src/sharplsp/src/main.rs
+++ b/src/sharplsp/src/main.rs
@@ -950,8 +950,7 @@ fn handle_request(
         }
         "sharplsp/setTargetFramework" => {
             let sidecar = pick_sidecar(&req, csharp_sidecar, fsharp_sidecar);
-            let switched = target_framework::handle_set(req, runtime, sidecar, &connection.sender);
-            if switched.is_ok() {
+            target_framework::handle_set(req, runtime, sidecar).and_then(|switched| {
                 nav_cache.clear();
                 republish_open_diagnostics(
                     vfs,
@@ -960,8 +959,8 @@ fn handle_request(
                     fsharp_sidecar,
                     connection,
                 );
-            }
-            switched
+                switched.announce(&connection.sender)
+            })
         }
         // Solution loading
         "sharplsp/loadSolution" => handle_load_solution(
@@ -1611,8 +1610,9 @@ fn handle_notification(
     }
 }
 
-/// Re-publish every open document's diagnostics: a framework switch changes
-/// which `#if` branches compile. [NETFX-CONTEXT]
+/// Re-publish every open document's diagnostics, returning once each is out: a
+/// framework switch changes which `#if` branches compile, and the editor hears
+/// of the switch only after them. [NETFX-CONTEXT]
 fn republish_open_diagnostics(
     vfs: &Vfs,
     runtime: &tokio::runtime::Runtime,
@@ -1620,10 +1620,23 @@ fn republish_open_diagnostics(
     fsharp_sidecar: Option<&Arc<SidecarManager>>,
     connection: &Connection,
 ) {
-    let open: Vec<Uri> = vfs.iter().map(|entry| entry.key().clone()).collect();
-    for uri in &open {
-        trigger_diagnostics(uri, runtime, csharp_sidecar, fsharp_sidecar, connection);
-    }
+    let open = vfs
+        .iter()
+        .filter_map(|entry| push_target(entry.key(), csharp_sidecar, fsharp_sidecar))
+        .collect();
+    diagnostics::publish_now(runtime, open, &connection.sender);
+}
+
+/// Where a document's diagnostics come from: the sidecar its language routes
+/// to, and its native path.
+fn push_target(
+    uri: &Uri,
+    csharp_sidecar: Option<&Arc<SidecarManager>>,
+    fsharp_sidecar: Option<&Arc<SidecarManager>>,
+) -> Option<diagnostics::PushTarget> {
+    let sidecar = sidecar_for_uri(uri, csharp_sidecar, fsharp_sidecar)?;
+    let file_path = paths::uri_to_path(uri.as_str()).ok()?;
+    Some((Arc::clone(sidecar), uri.clone(), file_path))
 }
 
 /// Spawn a background diagnostic request for the given URI.
@@ -1636,19 +1649,10 @@ fn trigger_diagnostics(
     fsharp_sidecar: Option<&Arc<SidecarManager>>,
     connection: &Connection,
 ) {
-    let Some(sidecar) = sidecar_for_uri(uri, csharp_sidecar, fsharp_sidecar) else {
-        return;
-    };
-    let Ok(file_path) = paths::uri_to_path(uri.as_str()) else {
+    let Some((sidecar, uri, file_path)) = push_target(uri, csharp_sidecar, fsharp_sidecar) else {
         return;
     };
-    diagnostics::request_in_background(
-        runtime,
-        Arc::clone(sidecar),
-        connection.sender.clone(),
-        uri.clone(),
-        file_path,
-    );
+    diagnostics::request_in_background(runtime, sidecar, connection.sender.clone(), uri, file_path);
 }
 
 /// Re-parse a document with tree-sitter and cache the result.
diff --git a/src/sharplsp/src/profiler/host.rs b/src/sharplsp/src/profiler/host.rs
index 004b23fb..18328494 100644
--- a/src/sharplsp/src/profiler/host.rs
+++ b/src/sharplsp/src/profiler/host.rs
@@ -112,6 +112,10 @@ impl ProfilerHost {
         let Some((method, params)) = profiler_call(&req.params) else {
             return false;
         };
+        if let Some(reason) = malformed_arguments(&req.params) {
+            refuse(req.id.clone(), method, reason, sender);
+            return true;
+        }
         self.pending.retain(|_, cancel| !cancel.is_closed());
         let (cancel, cancelled) = oneshot::channel();
         let _ = self.pending.insert(req.id.clone(), cancel);
@@ -161,6 +165,42 @@ fn profiler_call(params: &Value) -> Option<(&'static str, Value)> {
     Some((method, arguments))
 }
 
+/// Why a profiler command's arguments are not exactly one params object
+/// ([PROF-WIRE-METHODS]); `None` when they are, or when the list is absent.
+fn malformed_arguments(params: &Value) -> Option<&'static str> {
+    match params.get("arguments") {
+        None | Some(Value::Null) => None,
+        Some(Value::Array(list)) => match list.as_slice() {
+            [Value::Object(_)] => None,
+            [_] => Some("the profiler params argument must be a JSON object"),
+            _ => Some("a profiler command takes exactly one argument, its params object"),
+        },
+        Some(_) => Some("a profiler command's arguments must be a list of one params object"),
+    }
+}
+
+/// Answer a profiler command whose arguments are malformed with `INVALID_PARAMS`.
+fn refuse(
+    id: RequestId,
+    method: &'static str,
+    reason: &'static str,
+    sender: &crossbeam_channel::Sender<Message>,
+) {
+    warn!(method, reason, "profiler request refused");
+    let error = lsp_profiler::ProfilerError::InvalidParams(reason.to_owned());
+    let code = i32::try_from(error.code()).unwrap_or(-32000);
+    if sender
+        .send(Message::Response(Response::new_err(
+            id,
+            code,
+            error.to_string(),
+        )))
+        .is_err()
+    {
+        warn!(method, "profiler response dropped: connection closed");
+    }
+}
+
 /// Emit exactly one response after completion or cancellation.
 async fn complete(
     service: Arc<ProfilerService>,
@@ -213,6 +253,38 @@ mod tests {
         );
     }
 
+    #[test]
+    fn anything_but_one_params_object_is_malformed() {
+        let refused = [
+            serde_json::json!([]),
+            serde_json::json!([{}, {}]),
+            serde_json::json!([42]),
+            serde_json::json!(["pid=1"]),
+            serde_json::json!([null]),
+            serde_json::json!("pid=1"),
+        ];
+        for arguments in refused {
+            let params = serde_json::json!({ "command": "sharplsp.lspProfiler.capabilities", "arguments": arguments });
+            assert!(
+                malformed_arguments(&params).is_some(),
+                "{arguments} is not one params object"
+            );
+        }
+    }
+
+    #[test]
+    fn one_params_object_or_no_argument_list_is_well_formed() {
+        let accepted = [
+            serde_json::json!({ "command": "sharplsp.lspProfiler.cpu.list" }),
+            serde_json::json!({ "command": "sharplsp.lspProfiler.cpu.list", "arguments": null }),
+            serde_json::json!({ "command": "sharplsp.lspProfiler.cpu.list", "arguments": [{}] }),
+            serde_json::json!({ "command": "sharplsp.lspProfiler.cpu.start", "arguments": [{ "pid": 7 }] }),
+        ];
+        for params in accepted {
+            assert_eq!(malformed_arguments(&params), None, "{params}");
+        }
+    }
+
     #[test]
     fn a_missing_argument_list_becomes_empty_params() {
         let params = serde_json::json!({ "command": "sharplsp.lspProfiler.capabilities" });
diff --git a/src/sharplsp/src/target_framework.rs b/src/sharplsp/src/target_framework.rs
index e7fbb202..27688449 100644
--- a/src/sharplsp/src/target_framework.rs
+++ b/src/sharplsp/src/target_framework.rs
@@ -110,13 +110,33 @@ pub fn handle_get(
     Ok(serde_json::to_value(context)?)
 }
 
-/// `sharplsp/setTargetFramework`: switch the project, then tell the editor.
+/// A project the sidecar has switched, not yet announced: the editor hears of it
+/// only after the host has invalidated what the switch made stale. [NETFX-CONTEXT]
+pub struct Switched {
+    /// The document the switch was asked from.
+    document: TextDocumentIdentifier,
+    /// The project's framework context after the switch.
+    context: FrameworkContext,
+}
+
+impl Switched {
+    /// Announce the switch and ask for the refreshes, then answer the request.
+    pub fn announce(
+        self,
+        sender: &crossbeam_channel::Sender<Message>,
+    ) -> Result<serde_json::Value> {
+        announce(sender, &self.document, &self.context)?;
+        Ok(serde_json::to_value(self.context)?)
+    }
+}
+
+/// `sharplsp/setTargetFramework`: switch the project. The caller clears its
+/// navigation cache and re-publishes diagnostics, THEN announces. [NETFX-CONTEXT]
 pub fn handle_set(
     req: Request,
     runtime: &tokio::runtime::Runtime,
     sidecar: Option<&Arc<SidecarManager>>,
-    sender: &crossbeam_channel::Sender<Message>,
-) -> Result<serde_json::Value> {
+) -> Result<Switched> {
     let params: FrameworkParams = serde_json::from_value(req.params)?;
     let framework = params
         .target_framework
@@ -124,8 +144,10 @@ pub fn handle_set(
         .context("sharplsp/setTargetFramework requires targetFramework")?;
     let context = forward(runtime, sidecar, "workspace/setTargetFramework", &params)?;
     info!(uri = %params.text_document.uri.as_str(), framework, "Target framework switched");
-    announce(sender, &params.text_document, &context)?;
-    Ok(serde_json::to_value(context)?)
+    Ok(Switched {
+        document: params.text_document,
+        context,
+    })
 }
 
 /// Ask the sidecar that owns the document.
diff --git a/src/sharplsp/tests/e2e_modules/target_framework.rs b/src/sharplsp/tests/e2e_modules/target_framework.rs
index 8556a06e..d448d8aa 100644
--- a/src/sharplsp/tests/e2e_modules/target_framework.rs
+++ b/src/sharplsp/tests/e2e_modules/target_framework.rs
@@ -22,6 +22,7 @@ public static class Probe
     public static string OnFramework => "framework";
 #else
     public static string OnModern => "modern";
+    public static int Modern() { int unused; return 0; }
 #endif
 }
 "#;
@@ -57,8 +58,16 @@ fn methods(messages: &[Value]) -> Vec<&str> {
         .collect()
 }
 
-/// The project answers from its first framework until switched; a switch announces
-/// itself and asks for exactly the refreshes the client declared; a bad switch fails.
+/// Where `method` first arrived, if it did.
+fn position(messages: &[Value], method: &str) -> Option<usize> {
+    messages
+        .iter()
+        .position(|message| message["method"] == method)
+}
+
+/// The project answers from its first framework until switched; a switch re-publishes
+/// the open document's diagnostics for the new framework, THEN announces itself, THEN
+/// asks for exactly the refreshes the client declared; a bad switch fails.
 #[test]
 fn test_full_stack_target_framework_switch() {
     require_dotnet();
@@ -108,6 +117,7 @@ fn test_full_stack_target_framework_switch() {
         !asked.contains(&"workspace/codeLens/refresh"),
         "not declared: {asked:?}"
     );
+    assert_switch_order(&arrived, &file_uri);
     let after = client.request("sharplsp/targetFramework", document);
     assert_eq!(after["result"]["active"], "net10.0");
 
@@ -128,3 +138,45 @@ fn test_full_stack_target_framework_switch() {
     client.shutdown_and_exit();
     client.wait_with_timeout();
 }
+
+/// [NETFX-CONTEXT]'s order: the new framework's diagnostics (net10.0 alone compiles
+/// `Modern`'s unused local), then `sharplsp/targetFrameworkChanged`, then each refresh.
+fn assert_switch_order(arrived: &[Value], file_uri: &str) {
+    let republished = arrived
+        .iter()
+        .position(|message| {
+            message["method"] == "textDocument/publishDiagnostics"
+                && message["params"]["uri"] == json!(file_uri)
+                && message["params"]["diagnostics"]
+                    .as_array()
+                    .is_some_and(|all| all.iter().any(|d| d["code"] == "CS0168"))
+        })
+        .unwrap_or_else(|| panic!("net10.0's diagnostics before the answer: {arrived:?}"));
+    let warning = &arrived[republished]["params"]["diagnostics"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .find(|d| d["code"] == "CS0168")
+        .unwrap()["range"]["start"];
+    assert_eq!(
+        (&warning["line"], &warning["character"]),
+        (&json!(8), &json!(37))
+    );
+    let changed = position(arrived, "sharplsp/targetFrameworkChanged").unwrap();
+    assert!(
+        republished < changed,
+        "diagnostics are re-published BEFORE the switch is announced: {:?}",
+        methods(arrived)
+    );
+    for refresh in [
+        "workspace/semanticTokens/refresh",
+        "workspace/inlayHint/refresh",
+    ] {
+        let asked = position(arrived, refresh).unwrap();
+        assert!(
+            changed < asked,
+            "{refresh} follows the announcement: {:?}",
+            methods(arrived)
+        );
+    }
+}
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/Directory.Build.props b/src/sharplsp/tests/fixtures/fsharp-profiling/Directory.Build.props
new file mode 100644
index 00000000..f3281334
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/Directory.Build.props
@@ -0,0 +1,5 @@
+<Project>
+    <!-- Intentionally empty: this file shadows the repository-wide Directory.Build.props so
+         SharpLsp's C# analyzers, package references and warnings-as-errors settings do not
+         apply to these F# profiling fixtures. Each fixture .fsproj sets every property it needs. -->
+</Project>
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Audit.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Audit.fs
new file mode 100644
index 00000000..70418b66
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Audit.fs
@@ -0,0 +1,68 @@
+// FsOrderLedger audit trail: a MailboxProcessor whose loop parks on a gate while paused, so
+// posted entries pile up in its unbounded queue - the mailbox-growth leak this fixture profiles.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Audit
+
+open System
+open System.Threading
+open FsOrderLedger
+
+let private running = new ManualResetEventSlim(true)
+let private parked = new ManualResetEventSlim(false)
+let mutable private paused = 0
+let mutable private queued = 0
+
+let private waitUntil (condition: unit -> bool) (timeoutMs: int) : bool =
+    let deadline = Environment.TickCount64 + int64 timeoutMs
+    let mutable settled = condition ()
+    while not settled && Environment.TickCount64 < deadline do
+        Thread.Sleep 1
+        settled <- condition ()
+    settled
+
+let private consume (entry: AuditEntry) : unit =
+    Interlocked.Decrement(&queued) |> ignore
+    ignore entry
+
+let private loop (inbox: MailboxProcessor<AuditEntry>) : Async<unit> =
+    async {
+        while true do
+            if Volatile.Read(&paused) = 1 then
+                parked.Set()
+                running.Wait()
+                parked.Reset()
+            else
+                let! received = inbox.TryReceive 25
+                match received with
+                | Some entry -> consume entry
+                | None -> ()
+    }
+
+let auditor = MailboxProcessor<AuditEntry>.Start loop
+
+let isPaused () : bool = Volatile.Read(&paused) = 1
+
+let queuedCount () : int = Volatile.Read(&queued)
+
+let whenDrained (timeoutMs: int) : unit =
+    waitUntil (fun () -> Volatile.Read(&queued) = 0) timeoutMs |> ignore
+
+/// Posts one audit entry; while paused it stays in the mailbox queue.
+let post (orderId: int) : unit =
+    let entry = { At = DateTime.UtcNow; OrderId = orderId; Note = sprintf "order %d placed" orderId }
+    Interlocked.Increment(&queued) |> ignore
+    auditor.Post entry
+
+/// Closes the gate and waits until the loop is provably parked, so further posts queue up.
+let pause () : unit =
+    Volatile.Write(&paused, 1)
+    running.Reset()
+    waitUntil (fun () -> parked.IsSet) 2_000 |> ignore
+
+/// Opens the gate and waits for the queue to drain (or for the bounded timeout to elapse).
+let resume () : unit =
+    Volatile.Write(&paused, 0)
+    running.Set()
+    waitUntil (fun () -> not parked.IsSet) 2_000 |> ignore
+    whenDrained 5_000
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Bus.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Bus.fs
new file mode 100644
index 00000000..05229d2b
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Bus.fs
@@ -0,0 +1,21 @@
+// FsOrderLedger event bus: a module-level F# `Event` whose handlers capture the subscribing
+// request id and are NEVER removed - the classic event-handler leak this fixture profiles.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Bus
+
+open System.Threading
+open FsOrderLedger
+
+let published = Event<Order> ()
+
+let mutable private subscriptions = 0
+
+/// Subscribes a handler that captures `requestId` and never unsubscribes it.
+let subscribe (requestId: int) : unit =
+    published.Publish.Add(fun order -> ignore (order.Id + requestId))
+    Interlocked.Increment(&subscriptions) |> ignore
+
+let handlers () : int = Volatile.Read(&subscriptions)
+
+let publish (order: Order) : unit = published.Trigger order
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Domain.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Domain.fs
new file mode 100644
index 00000000..a87354f6
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Domain.fs
@@ -0,0 +1,41 @@
+// FsOrderLedger models an event-sourced order service: placed orders, an in-process event bus,
+// undo history, a forever-growing quote cache, a mailbox audit trail and rejection capture.
+// It is the memory/leak profiling target: every command retains state that only `release` frees.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+namespace FsOrderLedger
+
+open System
+
+/// Single-case union, deliberately NOT a struct: each customer id is its own heap object.
+type CustomerId = CustomerId of int
+
+[<Struct>]
+type Address = { Street: string; Postcode: int }
+
+[<Struct>]
+type Money = Cents of int64
+
+type OrderLine = { Sku: string; Quantity: int; UnitPrice: Money }
+
+type OrderStatus =
+    | Pending
+    | Paid of paymentRef: string
+    | Shipped of carrier: string * tracking: string
+    | Cancelled of reason: string
+
+type Order =
+    { Id: int
+      Customer: CustomerId
+      ShipTo: Address
+      Lines: OrderLine list
+      Status: OrderStatus
+      Payload: byte array }
+
+type Versioned<'T> = { Version: int; Value: 'T }
+
+type AuditEntry = { At: DateTime; OrderId: int; Note: string }
+
+exception OrderRejected of orderId: int * reason: string
+
+type Quote = { Sku: string; Price: decimal; Tags: Set<string> }
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/FsOrderLedger.fsproj b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/FsOrderLedger.fsproj
new file mode 100644
index 00000000..db22d8bc
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/FsOrderLedger.fsproj
@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net10.0</TargetFramework>
+        <Optimize>false</Optimize>
+        <Tailcalls>false</Tailcalls>
+        <DebugType>portable</DebugType>
+        <WarningLevel>5</WarningLevel>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+        <GenerateDocumentationFile>false</GenerateDocumentationFile>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Domain.fs" />
+        <Compile Include="Gate.fs" />
+        <Compile Include="Bus.fs" />
+        <Compile Include="Ledger.fs" />
+        <Compile Include="History.fs" />
+        <Compile Include="Quotes.fs" />
+        <Compile Include="Audit.fs" />
+        <Compile Include="Rejections.fs" />
+        <Compile Include="Program.fs" />
+    </ItemGroup>
+</Project>
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Gate.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Gate.fs
new file mode 100644
index 00000000..edc9d63f
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Gate.fs
@@ -0,0 +1,10 @@
+// FsOrderLedger's single process-wide gate. Commands arrive on the stdin thread while the
+// "workload" thread drips orders and burns CPU, so every mutation, every workload tick and every
+// reply snapshot runs inside this one lock: the counts a reply prints are then one consistent
+// snapshot of the live heap, not a torn read.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Gate
+
+/// The one process-wide lock. Hold it for a whole command, a whole drip burst, or one burn call.
+let sync = obj ()
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/History.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/History.fs
new file mode 100644
index 00000000..5de0157c
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/History.fs
@@ -0,0 +1,15 @@
+// FsOrderLedger undo history: every snapshot keeps the whole immutable `Map` of orders and is
+// never dropped, so history grows without bound while re-using the same Order instances.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.History
+
+open FsOrderLedger
+
+let snapshots = ResizeArray<Versioned<Map<int, Order>>> ()
+
+/// Appends one immutable snapshot of the current orders; no Order record is copied.
+let record (orders: Order seq) : unit =
+    let state = orders |> Seq.map (fun order -> order.Id, order) |> Map.ofSeq
+    let versioned = { Version = snapshots.Count + 1; Value = state }
+    snapshots.Add versioned
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Ledger.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Ledger.fs
new file mode 100644
index 00000000..7d491f23
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Ledger.fs
@@ -0,0 +1,70 @@
+// FsOrderLedger order storage: every placed order is retained in a module-level ResizeArray.
+// Each allocation site (CustomerId, Paid, Shipped, Cancelled, OrderLine, Order) sits on its own
+// source line so a profiler can anchor that exact type to that exact line.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Ledger
+
+open FsOrderLedger
+
+type Counts =
+    { Total: int
+      Pending: int
+      Paid: int
+      Shipped: int
+      Cancelled: int }
+
+let orders = ResizeArray<Order> ()
+
+let private storage = obj ()
+let mutable private allocated = 0
+
+let private skuFor (id: int) : string = sprintf "SKU-%05d" (id % 400)
+
+/// The next order id: 0 first, then +1 forever, never reused.
+let nextId () : int =
+    lock storage (fun () ->
+        let id = allocated
+        allocated <- id + 1
+        id)
+
+/// Builds ONE order, appends it to `orders` and returns it.
+let place (id: int) : Order =
+    let customer = CustomerId(id % 5_000)
+    let status =
+        match id % 4 with
+        | 0 -> Pending
+        | 1 -> Paid(sprintf "PAY-%06d" id)
+        | 2 -> Shipped(sprintf "CARRIER-%d" (id % 3), sprintf "TRACK-%08d" id)
+        | _ -> Cancelled(sprintf "customer %d cancelled" (id % 97))
+    let unitPrice = Cents(int64 (100 + id % 900))
+    let line = { Sku = skuFor id; Quantity = 1 + id % 4; UnitPrice = unitPrice }
+    let shipTo = { Street = sprintf "%d Market Street" id; Postcode = 1_000 + id % 9_000 }
+    let order = { Id = id; Customer = customer; ShipTo = shipTo; Lines = [ line ]; Status = status; Payload = Array.zeroCreate 256 }
+    lock storage (fun () -> orders.Add order)
+    order
+
+/// Drops every retained order; ids keep counting from where they were.
+let release () : unit = lock storage (fun () -> orders.Clear())
+
+let snapshot () : Order array = lock storage (fun () -> orders.ToArray())
+
+let counts () : Counts =
+    let current = snapshot ()
+    let matching (predicate: OrderStatus -> bool) : int =
+        current |> Array.filter (fun order -> predicate order.Status) |> Array.length
+    { Total = current.Length
+      Pending = matching (function Pending -> true | _ -> false)
+      Paid = matching (function Paid _ -> true | _ -> false)
+      Shipped = matching (function Shipped _ -> true | _ -> false)
+      Cancelled = matching (function Cancelled _ -> true | _ -> false) }
+
+/// Sums the decimal total of every retained order - the `burn` workload's tight loop.
+let priceAll () : decimal =
+    let current = snapshot ()
+    let mutable total = 0M
+    for order in current do
+        for line in order.Lines do
+            let (Cents cents) = line.UnitPrice
+            total <- total + decimal cents * decimal line.Quantity
+    total
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Program.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Program.fs
new file mode 100644
index 00000000..13917397
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Program.fs
@@ -0,0 +1,188 @@
+// FsOrderLedger console entry point: a line protocol on stdin/stdout that grows (or releases) the
+// ledger's retained state, plus a "workload" thread that can drip orders and burn CPU on pricing.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Program
+
+open System
+open System.Diagnostics
+open System.Threading
+open FsOrderLedger
+
+let blobs = ResizeArray<byte array> ()
+
+let mutable private stopping = false
+let mutable private dripOn = false
+let mutable private burnOn = false
+let mutable private nextQuoteSku = 0
+let mutable private nextRejection = 0
+
+let private placeOne () : Order =
+    let order = Ledger.place (Ledger.nextId ())
+    Bus.subscribe order.Id
+    Bus.publish order
+    Audit.post order.Id
+    order
+
+/// One drip tick: 20 orders, all inside the gate. The sleep is outside it so commands run.
+let private dripTick () : unit =
+    lock Gate.sync (fun () ->
+        for _ in 1 .. 20 do
+            placeOne () |> ignore)
+    Thread.Sleep 50
+
+/// One burn tick: the gate is held for exactly one `priceAll` call, never across ticks.
+let private burnTick () : unit = lock Gate.sync (fun () -> Ledger.priceAll () |> ignore)
+
+let private workloadLoop () =
+    while not (Volatile.Read(&stopping)) do
+        let drip = Volatile.Read(&dripOn)
+        let burn = Volatile.Read(&burnOn)
+        if drip then dripTick ()
+        if burn then burnTick ()
+        if not (drip || burn) then Thread.Sleep 20
+
+let private countsText () : string =
+    let counted = Ledger.counts ()
+    sprintf
+        "orders=%d pending=%d paid=%d shipped=%d cancelled=%d handlers=%d audits=%d quotes=%d rejections=%d snapshots=%d blobs=%d"
+        counted.Total
+        counted.Pending
+        counted.Paid
+        counted.Shipped
+        counted.Cancelled
+        (Bus.handlers ())
+        (Audit.queuedCount ())
+        (Quotes.count ())
+        Rejections.rejected.Count
+        History.snapshots.Count
+        blobs.Count
+
+let private unknown (line: string) : string = sprintf "ERR unknown %s" line
+
+/// One reply: the echoed command followed by every live count, always in the same order.
+let private reply (echo: string) : string =
+    if not (Audit.isPaused ()) then Audit.whenDrained 2_000
+    sprintf "OK %s %s" echo (countsText ())
+
+let private parseCount (text: string) : int option =
+    match Int32.TryParse text with
+    | true, value when value > 0 -> Some value
+    | _ -> None
+
+let private placeOrders (count: int) : unit =
+    for _ in 1 .. count do
+        placeOne () |> ignore
+
+let private quoteSkus (count: int) : unit =
+    for _ in 1 .. count do
+        Quotes.quote (sprintf "SKU-Q%06d" (Volatile.Read(&nextQuoteSku))) |> ignore
+        Volatile.Write(&nextQuoteSku, Volatile.Read(&nextQuoteSku) + 1)
+
+let private rejectOrders (count: int) : unit =
+    for _ in 1 .. count do
+        Rejections.reject (Volatile.Read(&nextRejection))
+        Volatile.Write(&nextRejection, Volatile.Read(&nextRejection) + 1)
+
+let private retainBlob (mebibytes: int) : unit =
+    blobs.Add(Array.zeroCreate<byte> (mebibytes * 1_048_576))
+
+let private releaseAll () : unit =
+    Ledger.release ()
+    History.snapshots.Clear()
+    blobs.Clear()
+    Rejections.rejected.Clear()
+
+let private countedAction (name: string) : (int -> unit) option =
+    match name with
+    | "place" -> Some placeOrders
+    | "quote" -> Some quoteSkus
+    | "reject" -> Some rejectOrders
+    | "blob" -> Some retainBlob
+    | _ -> None
+
+let private stateAction (words: string list) : (unit -> unit) option =
+    match words with
+    | [ "history" ] -> Some(fun () -> History.record (Ledger.snapshot ()))
+    | [ "audit"; "pause" ] -> Some Audit.pause
+    | [ "audit"; "resume" ] -> Some Audit.resume
+    | [ "release"; "orders" ] -> Some Ledger.release
+    | [ "release"; "blobs" ] -> Some(fun () -> blobs.Clear())
+    | [ "release"; "all" ] -> Some releaseAll
+    | [ "drip"; "on" ] -> Some(fun () -> Volatile.Write(&dripOn, true))
+    | [ "drip"; "off" ] -> Some(fun () -> Volatile.Write(&dripOn, false))
+    | [ "burn"; "on" ] -> Some(fun () -> Volatile.Write(&burnOn, true))
+    | [ "burn"; "off" ] -> Some(fun () -> Volatile.Write(&burnOn, false))
+    | _ -> None
+
+/// Runs `<name> <positive count>` commands; false when the words are not that shape.
+let private applyCounted (words: string list) : bool =
+    match words with
+    | [ name; text ] ->
+        match countedAction name, parseCount text with
+        | Some action, Some count ->
+            action count
+            true
+        | _ -> false
+    | _ -> false
+
+/// Runs one command and builds its reply; the caller holds `Gate.sync`.
+let private runCommand (line: string) : string =
+    let words = line.Split([| ' ' |], StringSplitOptions.RemoveEmptyEntries) |> List.ofArray
+    let echo = String.Join(" ", words)
+    if applyCounted words then
+        reply echo
+    else
+        match stateAction words with
+        | Some action ->
+            action ()
+            reply echo
+        | None -> unknown line
+
+/// Every command mutates, snapshots and replies under the one process-wide gate.
+let private handle (line: string) : string = lock Gate.sync (fun () -> runCommand line)
+
+let private isProcessAlive (pid: int) : bool =
+    try
+        use running = Process.GetProcessById pid
+        not running.HasExited
+    with :? ArgumentException -> false
+
+let private watchParent () =
+    match Environment.GetEnvironmentVariable "SHARPLSP_PROFILE_TARGET_PARENT_PID" with
+    | null -> ()
+    | supplied ->
+        match Int32.TryParse supplied with
+        | true, pid when pid > 0 ->
+            let watchdog =
+                Thread(
+                    ThreadStart(fun () ->
+                        while isProcessAlive pid do
+                            Thread.Sleep 1_000
+                        Environment.Exit 0)
+                )
+            watchdog.IsBackground <- true
+            watchdog.Name <- "parent-death-watchdog"
+            watchdog.Start()
+        | _ -> ()
+
+let private replyLine (text: string) =
+    Console.Out.WriteLine text
+    Console.Out.Flush()
+
+[<EntryPoint>]
+let main _ =
+    Console.Out.WriteLine(sprintf "READY %d" Environment.ProcessId)
+    Console.Out.Flush()
+    watchParent ()
+    let workload = Thread(ThreadStart workloadLoop)
+    workload.IsBackground <- true
+    workload.Name <- "workload"
+    workload.Start()
+    let mutable reading = true
+    while reading do
+        match Console.In.ReadLine() with
+        | null -> reading <- false
+        | line -> replyLine (handle line)
+    Volatile.Write(&stopping, true)
+    0
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Quotes.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Quotes.fs
new file mode 100644
index 00000000..aea48852
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Quotes.fs
@@ -0,0 +1,35 @@
+// FsOrderLedger quotes: a memoizing closure whose Dictionary is captured and never evicted, so
+// every distinct SKU ever quoted stays reachable - the cache-growth leak this fixture profiles.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Quotes
+
+open System
+open System.Collections.Generic
+open System.Threading
+open FsOrderLedger
+
+/// Returns a memoized version of `compute`, backed by one Dictionary held by the closure.
+let memoize (compute: string -> 'T) : string -> 'T =
+    let cache = Dictionary<string, 'T>(StringComparer.Ordinal)
+    fun key ->
+        match cache.TryGetValue key with
+        | true, cached -> cached
+        | _ ->
+            let computed = compute key
+            cache.[key] <- computed
+            computed
+
+let mutable private cached = 0
+
+/// Quotes are built once per distinct SKU (memoize only calls the lambda on a miss), so the
+/// insertion counter equals the cache size exactly.
+let quote =
+    memoize (fun sku ->
+        Interlocked.Increment(&cached) |> ignore
+        let price = 10M + decimal (sku.Length % 17) * 1.5M
+        let tags = if price > 20M then set [ "retail"; "premium" ] else set [ "retail" ]
+        let quoted = { Sku = sku; Price = price; Tags = tags }
+        quoted)
+
+let count () : int = Volatile.Read(&cached)
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Rejections.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Rejections.fs
new file mode 100644
index 00000000..f6bd6804
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsOrderLedger/Rejections.fs
@@ -0,0 +1,14 @@
+// FsOrderLedger rejections: every refused order keeps its F# exception object, including the
+// stack trace it captured, in a module-level ResizeArray that only `release` clears.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsOrderLedger.Rejections
+
+open FsOrderLedger
+
+let rejected = ResizeArray<exn> ()
+
+/// Records one rejection: the exception carries the order id and a human-readable reason.
+let reject (orderId: int) : unit =
+    let failure = OrderRejected(orderId, sprintf "order %d declined by risk check" orderId)
+    rejected.Add failure
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Csv.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Csv.fs
new file mode 100644
index 00000000..ad165ea3
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Csv.fs
@@ -0,0 +1,54 @@
+// FsPricingEngine CSV ingestion: a synthetic 2,000-row catalogue plus the active patterns the
+// parser uses to validate each field. Malformed rows are dropped rather than thrown.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Csv
+
+open System
+open System.Globalization
+open System.Text
+open FsPricingEngine.Domain
+
+let private invariant = CultureInfo.InvariantCulture
+
+let (|Int|_|) (text: string) =
+    match Int32.TryParse(text, NumberStyles.Integer, invariant) with
+    | true, value -> Some value
+    | _ -> None
+
+let (|Money|_|) (text: string) =
+    match Decimal.TryParse(text, NumberStyles.Number, invariant) with
+    | true, value -> Some value
+    | _ -> None
+
+let (|SkuCode|_|) (text: string) =
+    match text with
+    | candidate when not (String.IsNullOrEmpty candidate) && candidate.StartsWith("SKU-", StringComparison.Ordinal) ->
+        Some(Sku candidate)
+    | _ -> None
+
+let parseLine (line: string) : Product option =
+    match line.Split([| ',' |]) with
+    | [| SkuCode sku; name; Money price; Int stock; category |] ->
+        Some { Sku = sku; Name = name; Price = price; Stock = stock; Category = category }
+    | _ -> None
+
+let parseAll (text: string) : Product list =
+    text.Split([| '\n' |], StringSplitOptions.RemoveEmptyEntries)
+    |> Array.toList
+    |> List.choose parseLine
+
+/// Builds the synthetic catalogue CSV once, at startup. Every 37th row is malformed on purpose
+/// so `parseLine` exercises both branches of the active patterns.
+let synthetic () : string =
+    let builder = StringBuilder()
+    builder.AppendLine("sku,name,price,stock,category") |> ignore
+    for index in 1 .. 2_000 do
+        let price = decimal (index % 89 + 1) + decimal (index % 100) / 100M
+        let priceText = price.ToString("0.00", invariant)
+        let category = index % 12
+        if index % 37 = 0 then
+            builder.AppendLine($"SKU-{index:D5},Item {index},not-a-price,{index % 250},Cat{category}") |> ignore
+        else
+            builder.AppendLine($"SKU-{index:D5},Item {index},{priceText},{index % 250},Cat{category}") |> ignore
+    builder.ToString()
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Domain.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Domain.fs
new file mode 100644
index 00000000..558e8369
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Domain.fs
@@ -0,0 +1,28 @@
+// FsPricingEngine models a retail checkout backend: catalogue CSV parsing, basket pricing
+// rules, fuzzy product search, delivery-route planning and daily sales reports. Every stage is
+// deliberately CPU-heavy so a sampling profiler sees a few clearly named hot methods.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Domain
+
+open System
+
+/// Stock-keeping unit: a single-case union so it prints and compares structurally.
+type Sku = Sku of string
+
+type Product =
+    { Sku: Sku
+      Name: string
+      Price: decimal
+      Stock: int
+      Category: string }
+
+type BasketLine = { Product: Sku; Quantity: int }
+
+type Discount =
+    | PercentOff of decimal
+    | BuyXGetY of buy: int * free: int
+    | Bundle of Sku list * price: decimal
+    | Tiered of (int * decimal) list
+
+type Order = { Id: int; PlacedOn: DateTime; Lines: BasketLine list }
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/FsPricingEngine.fsproj b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/FsPricingEngine.fsproj
new file mode 100644
index 00000000..da44ac85
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/FsPricingEngine.fsproj
@@ -0,0 +1,23 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net10.0</TargetFramework>
+        <Optimize>false</Optimize>
+        <Tailcalls>false</Tailcalls>
+        <DebugType>portable</DebugType>
+        <WarningLevel>5</WarningLevel>
+        <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+        <EnableDefaultCompileItems>false</EnableDefaultCompileItems>
+        <GenerateDocumentationFile>false</GenerateDocumentationFile>
+        <IsPackable>false</IsPackable>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Domain.fs" />
+        <Compile Include="Csv.fs" />
+        <Compile Include="Pricing.fs" />
+        <Compile Include="Search.fs" />
+        <Compile Include="Routing.fs" />
+        <Compile Include="Reports.fs" />
+        <Compile Include="Program.fs" />
+    </ItemGroup>
+</Project>
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Pricing.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Pricing.fs
new file mode 100644
index 00000000..4c840b28
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Pricing.fs
@@ -0,0 +1,68 @@
+// FsPricingEngine pricing: line and basket totals plus a recursive discount rule engine that
+// pattern-matches every `Discount` case. All money is `decimal`, rounded banker's-style.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Pricing
+
+open System
+open FsPricingEngine.Domain
+
+let private round2 (value: decimal) : decimal =
+    Math.Round(value, 2, MidpointRounding.ToEven)
+
+let unitPrice (catalogue: Map<Sku, Product>) (sku: Sku) : decimal =
+    catalogue |> Map.tryFind sku |> Option.map (fun product -> product.Price) |> Option.defaultValue 0M
+
+let lineTotal (catalogue: Map<Sku, Product>) (line: BasketLine) : decimal =
+    unitPrice catalogue line.Product * decimal line.Quantity
+
+let subtotal (catalogue: Map<Sku, Product>) (lines: BasketLine list) : decimal =
+    lines |> List.map (lineTotal catalogue) |> List.sum
+
+let private percentOf (percent: decimal) (amount: decimal) : decimal =
+    round2 (amount * percent / 100M)
+
+let private buyXGetY (catalogue: Map<Sku, Product>) (lines: BasketLine list) (buy: int, free: int) : decimal =
+    if buy <= 0 || free <= 0 then
+        0M
+    else
+        lines
+        |> List.sumBy (fun line -> decimal (line.Quantity / (buy + free) * free) * unitPrice catalogue line.Product)
+        |> round2
+
+let private bundle (catalogue: Map<Sku, Product>) (lines: BasketLine list) (items: Sku list) (price: decimal) : decimal =
+    match lines |> List.filter (fun line -> List.contains line.Product items) with
+    | [] -> 0M
+    | chosen -> round2 (max 0M (subtotal catalogue chosen - price))
+
+let private tiered (catalogue: Map<Sku, Product>) (lines: BasketLine list) (tiers: (int * decimal) list) : decimal =
+    let units = lines |> List.sumBy (fun line -> line.Quantity)
+    tiers
+    |> List.filter (fun (threshold, _) -> units >= threshold)
+    |> List.sortBy fst
+    |> List.tryLast
+    |> Option.map (fun (_, percent) -> percentOf percent (subtotal catalogue lines))
+    |> Option.defaultValue 0M
+
+/// Walks the whole discount list recursively, matching every case of the union.
+let rec applyRules (catalogue: Map<Sku, Product>) (lines: BasketLine list) (discounts: Discount list) : decimal =
+    match discounts with
+    | [] -> 0M
+    | PercentOff percent :: rest ->
+        percentOf percent (subtotal catalogue lines) + applyRules catalogue lines rest
+    | BuyXGetY(buy, free) :: rest ->
+        buyXGetY catalogue lines (buy, free) + applyRules catalogue lines rest
+    | Bundle(items, price) :: rest ->
+        bundle catalogue lines items price + applyRules catalogue lines rest
+    | Tiered tiers :: rest ->
+        tiered catalogue lines tiers + applyRules catalogue lines rest
+
+let basketTotal
+    (catalogue: Map<Sku, Product>)
+    (lines: BasketLine list)
+    (discounts: Discount list)
+    (taxRate: decimal)
+    : decimal =
+    let discounted = subtotal catalogue lines - applyRules catalogue lines discounts
+    let net = max 0M discounted
+    Math.Round(net + net * taxRate, 2, MidpointRounding.ToEven)
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Program.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Program.fs
new file mode 100644
index 00000000..95012ceb
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Program.fs
@@ -0,0 +1,158 @@
+// FsPricingEngine console entry point: a line protocol on stdin/stdout that points one
+// dedicated "workload" thread at a single CPU-heavy retail workload, or at all of them in turn.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Program
+
+open System
+open System.Diagnostics
+open System.Threading
+open FsPricingEngine
+open FsPricingEngine.Domain
+
+[<NoEquality; NoComparison>]
+type private Workload = { Name: string; Step: (unit -> unit) option }
+
+let private gate = obj ()
+let private current = ref { Name = "idle"; Step = None }
+let mutable private completed = 0L
+let mutable private stopping = false
+
+let private csvText = Csv.synthetic ()
+let private products = Csv.parseAll csvText
+let private catalogue = products |> List.map (fun product -> product.Sku, product) |> Map.ofList
+let private basket =
+    products |> List.take 12 |> List.mapi (fun index product -> { Product = product.Sku; Quantity = 1 + index % 4 })
+let private bundleSkus = products |> List.take 3 |> List.map (fun product -> product.Sku)
+let private discounts =
+    [ PercentOff 10M
+      BuyXGetY(2, 1)
+      Bundle(bundleSkus, 25M)
+      Tiered [ (5, 5M); (10, 12M); (20, 18M) ] ]
+let private orders = Reports.syntheticOrders catalogue 4_000
+
+let private parseStep () = Csv.parseAll csvText |> List.length |> ignore
+
+let private priceStep () = Pricing.basketTotal catalogue basket discounts 0.125M |> ignore
+
+let private searchStep () = Search.rank "Item 1234" products |> List.truncate 10 |> List.length |> ignore
+
+let private routeStep () = Routing.shortestPath Routing.graph 0 (Routing.nodeCount - 1) |> ignore
+
+let private reportStep () =
+    Reports.dailyTotals catalogue orders |> List.length |> ignore
+    Reports.buildAsync orders |> fun pending -> pending.GetAwaiter().GetResult() |> ignore
+
+let private stageNames = [| "parse"; "price"; "search"; "route"; "report" |]
+let private stages = [| parseStep; priceStep; searchStep; routeStep; reportStep |]
+
+/// Ground truth for the profiler: the Stopwatch ticks the workload thread spent in each
+/// stage. Every reply carries them, so a test can hold the profiler's shares against them.
+let private stageTicks = Array.zeroCreate<int64> stageNames.Length
+
+let private timed (index: int) (step: unit -> unit) () =
+    let started = Stopwatch.GetTimestamp()
+    step ()
+    Interlocked.Add(&stageTicks.[index], Stopwatch.GetTimestamp() - started) |> ignore
+
+let private mixedStep () =
+    stages |> Array.iteri (fun index step -> timed index step ())
+
+let private workloadFor (name: string) : Workload option =
+    match Array.tryFindIndex ((=) name) stageNames, name with
+    | Some index, _ -> Some { Name = name; Step = Some(timed index stages.[index]) }
+    | None, "mixed" -> Some { Name = name; Step = Some mixedStep }
+    | None, _ -> None
+
+let private stageTimes () : string =
+    stageNames
+    |> Array.mapi (fun index name ->
+        sprintf "%s_us=%d" name (Interlocked.Read(&stageTicks.[index]) * 1_000_000L / Stopwatch.Frequency))
+    |> String.concat " "
+
+let private idle = { Name = "idle"; Step = None }
+
+let private readCurrent () = lock gate (fun () -> current.Value)
+
+let private switchTo (workload: Workload) = lock gate (fun () -> current.Value <- workload)
+
+let private iterations () = lock gate (fun () -> completed)
+
+let private countIteration () = lock gate (fun () -> completed <- completed + 1L)
+
+let private unknown (line: string) = sprintf "ERR unknown %s" line
+
+let private replyRun (name: string) =
+    sprintf "OK run %s iterations=%d %s" name (iterations ()) (stageTimes ())
+
+let private replyIdle () = sprintf "OK idle iterations=%d %s" (iterations ()) (stageTimes ())
+
+let private replyStats () =
+    sprintf "OK stats workload=%s iterations=%d %s" (readCurrent ()).Name (iterations ()) (stageTimes ())
+
+let private handle (line: string) : string =
+    match line.Split([| ' ' |], StringSplitOptions.RemoveEmptyEntries) |> List.ofArray with
+    | [ "run"; name ] ->
+        match workloadFor name with
+        | Some workload ->
+            switchTo workload
+            replyRun name
+        | None -> unknown line
+    | [ "idle" ] ->
+        switchTo idle
+        replyIdle ()
+    | [ "stats" ] -> replyStats ()
+    | _ -> unknown line
+
+let private workloadLoop () =
+    while not (Volatile.Read(&stopping)) do
+        match (readCurrent ()).Step with
+        | None -> Thread.Sleep 20
+        | Some step ->
+            step ()
+            countIteration ()
+
+let private isProcessAlive (pid: int) : bool =
+    try
+        use running = Process.GetProcessById pid
+        not running.HasExited
+    with :? ArgumentException -> false
+
+let private watchParent () =
+    match Environment.GetEnvironmentVariable "SHARPLSP_PROFILE_TARGET_PARENT_PID" with
+    | null -> ()
+    | supplied ->
+        match Int32.TryParse supplied with
+        | true, pid when pid > 0 ->
+            let watchdog =
+                Thread(
+                    ThreadStart(fun () ->
+                        while isProcessAlive pid do
+                            Thread.Sleep 1_000
+                        Environment.Exit 0)
+                )
+            watchdog.IsBackground <- true
+            watchdog.Name <- "parent-death-watchdog"
+            watchdog.Start()
+        | _ -> ()
+
+let private reply (line: string) =
+    Console.Out.WriteLine line
+    Console.Out.Flush()
+
+[<EntryPoint>]
+let main _ =
+    Console.Out.WriteLine(sprintf "READY %d" Environment.ProcessId)
+    Console.Out.Flush()
+    watchParent ()
+    let workload = Thread(ThreadStart workloadLoop)
+    workload.IsBackground <- true
+    workload.Name <- "workload"
+    workload.Start()
+    let mutable reading = true
+    while reading do
+        match Console.In.ReadLine() with
+        | null -> reading <- false
+        | line -> reply (handle line)
+    Volatile.Write(&stopping, true)
+    0
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Reports.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Reports.fs
new file mode 100644
index 00000000..90dc8d0a
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Reports.fs
@@ -0,0 +1,47 @@
+// FsPricingEngine reporting: daily totals built from a `seq { ... }` of synthetic orders and an
+// async report builder that yields inside its loop so profiler frames interleave asynchronously.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Reports
+
+open System
+open System.Threading.Tasks
+open FsPricingEngine.Domain
+
+type DailyTotal = { Day: DateTime; OrderCount: int; Revenue: decimal }
+
+let syntheticOrders (catalogue: Map<Sku, Product>) (count: int) : Order seq =
+    let pool = catalogue |> Map.toList |> List.map fst |> List.truncate 24 |> Array.ofList
+    if Array.isEmpty pool then
+        Seq.empty
+    else
+        seq {
+            for index in 0 .. count - 1 ->
+                { Id = index
+                  PlacedOn = DateTime(2024, 1, 1, 0, 0, 0, DateTimeKind.Utc).AddDays(float (index % 30))
+                  Lines =
+                    [ for offset in 0 .. index % 4 ->
+                          { Product = pool.[(index + offset) % pool.Length]
+                            Quantity = 1 + (index + offset) % 3 } ] }
+        }
+
+let dailyTotals (catalogue: Map<Sku, Product>) (orders: Order seq) : DailyTotal list =
+    seq {
+        for day, dayOrders in orders |> Seq.groupBy (fun order -> order.PlacedOn.Date) ->
+            { Day = day
+              OrderCount = Seq.length dayOrders
+              Revenue = dayOrders |> Seq.sumBy (fun order -> Pricing.subtotal catalogue order.Lines) }
+    }
+    |> Seq.sortBy (fun total -> total.Day)
+    |> Seq.toList
+
+/// Builds the report table asynchronously, yielding on every row.
+let buildAsync (orders: Order seq) : Task<int> =
+    task {
+        let rows = orders |> Seq.toArray
+        let total = ref 0
+        for order in rows do
+            do! Task.Yield()
+            total.Value <- total.Value + order.Lines.Length
+        return total.Value
+    }
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Routing.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Routing.fs
new file mode 100644
index 00000000..29cefee6
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Routing.fs
@@ -0,0 +1,47 @@
+// FsPricingEngine delivery routing: a synthetic 400-node road graph and Dijkstra's algorithm
+// with an immutable `Set<float * int>` as the priority queue.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Routing
+
+open System
+
+type Graph = Map<int, (int * float) list>
+
+let nodeCount = 400
+
+let private build (nodes: int) : Graph =
+    let random = Random 42
+    [ for node in 0 .. nodes - 1 ->
+          let ringCost = 1.0 + float (node % 7)
+          let ring = (node + 1) % nodes, ringCost
+          let shortcuts =
+              [ for _ in 1 .. 3 ->
+                    let target = random.Next nodes
+                    target, 1.0 + random.NextDouble() * 9.0 ]
+          node, (ring :: shortcuts) |> List.distinctBy fst ]
+    |> Map.ofList
+
+let graph : Graph = build nodeCount
+
+/// Shortest-path cost from `source` to `target`; `infinity` when the target is unreachable.
+let shortestPath (roads: Graph) (source: int) (target: int) : float =
+    let rec visit (queue: Set<float * int>) (distances: Map<int, float>) : Map<int, float> =
+        if Set.isEmpty queue then
+            distances
+        else
+            let cost, node = Set.minElement queue
+            let queue = Set.remove (cost, node) queue
+            match Map.tryFind node distances with
+            | Some known when known < cost -> visit queue distances
+            | _ ->
+                let relax (found: Map<int, float>, pending: Set<float * int>) (next: int, weight: float) =
+                    let candidate = cost + weight
+                    match Map.tryFind next found with
+                    | Some known when known <= candidate -> found, pending
+                    | _ -> Map.add next candidate found, Set.add (candidate, next) pending
+                let found, pending =
+                    roads |> Map.tryFind node |> Option.defaultValue [] |> List.fold relax (distances, queue)
+                visit pending found
+    let distances = visit (Set.singleton (0.0, source)) (Map.ofList [ source, 0.0 ])
+    distances |> Map.tryFind target |> Option.defaultValue infinity
diff --git a/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Search.fs b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Search.fs
new file mode 100644
index 00000000..4e839e5a
--- /dev/null
+++ b/src/sharplsp/tests/fixtures/fsharp-profiling/FsPricingEngine/Search.fs
@@ -0,0 +1,28 @@
+// FsPricingEngine fuzzy search: Levenshtein distance over a 2D cost matrix (the dominant cost
+// of the `search` workload) and a ranked ordering of catalogue products by that distance.
+// Profiling fixture for [PROFILER-SHARED-LIBRARY-VSCODE] and lspkit's [PROF-TESTING].
+
+module FsPricingEngine.Search
+
+open FsPricingEngine.Domain
+
+let distance (left: string) (right: string) : int =
+    let rows = left.Length
+    let columns = right.Length
+    let costs = Array2D.zeroCreate<int> (rows + 1) (columns + 1)
+    for row in 0 .. rows do
+        costs.[row, 0] <- row
+    for column in 0 .. columns do
+        costs.[0, column] <- column
+    for column in 1 .. columns do
+        for row in 1 .. rows do
+            let substitution = if left.[row - 1] = right.[column - 1] then 0 else 1
+            let deletion = costs.[row - 1, column] + 1
+            let insertion = costs.[row, column - 1] + 1
+            let diagonal = costs.[row - 1, column - 1] + substitution
+            costs.[row, column] <- min deletion (min insertion diagonal)
+    costs.[rows, columns]
+
+let rank (query: string) (products: Product list) : Product list =
+    products
+    |> List.sortBy (fun product -> distance query product.Name, product.Price, product.Name)
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerTargetFrameworkTests.cs b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerTargetFrameworkTests.cs
index e9c48717..0906fec7 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerTargetFrameworkTests.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp.Tests/WorkspaceManagerTargetFrameworkTests.cs
@@ -119,11 +119,14 @@ public async Task An_undeclared_framework_fails_by_name_and_a_file_no_project_co
         );
     }
 
-    [Fact]
-    public async Task A_single_target_project_has_no_framework_to_choose()
+    /// <summary>A name ending in <c>(tfm)</c> is the project's own name, not a framework context.</summary>
+    [Theory]
+    [InlineData("Single")]
+    [InlineData("Utility(net48)")]
+    public async Task A_single_target_project_has_no_framework_to_choose(string name)
     {
-        var single = WriteProject("Single", "<TargetFramework>net10.0</TargetFramework>");
-        var source = NativePaths.Join(_root, "Single", "Single.cs");
+        var single = WriteProject(name, "<TargetFramework>net10.0</TargetFramework>");
+        var source = NativePaths.Join(_root, name, "Single.cs");
         await File.WriteAllTextAsync(source, "namespace Fx;\n\npublic static class Single { }\n");
         Restore(single);
         using var manager = await OpenAsync(single);
@@ -131,6 +134,26 @@ public async Task A_single_target_project_has_no_framework_to_choose()
         Assert.Null(context.Active);
         Assert.Empty(context.Available);
         Assert.Equal(single, context.Project);
+        var refused = await manager.SetTargetFrameworkAsync(source, "net48", default);
+        Assert.True(refused.IsError, "a single-target project has no framework to switch to");
+    }
+
+    [Fact]
+    public async Task A_multi_targeted_project_named_like_a_framework_answers_its_declared_frameworks()
+    {
+        var name = "Tool(net10.0)";
+        var tool = WriteProject(name, "<TargetFrameworks>net48;net10.0</TargetFrameworks>");
+        var source = NativePaths.Join(_root, name, "Tool.cs");
+        await File.WriteAllTextAsync(source, "namespace Fx;\n\npublic static class Tool { }\n");
+        Restore(tool);
+        using var manager = await OpenAsync(tool);
+        var context = AssertOk(await manager.GetTargetFrameworksAsync(source, default));
+        Assert.Equal("net48", context.Active);
+        Assert.Equal(Declared, context.Available);
+        Assert.Equal(tool, context.Project);
+        var switched = AssertOk(await manager.SetTargetFrameworkAsync(source, "net10.0", default));
+        Assert.Equal(("net10.0", tool), (switched.Active, switched.Project));
+        Assert.Equal(Declared, switched.Available);
     }
 
     private const string SharedSource = """
diff --git a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs
index 7fd047d2..5810f9f7 100644
--- a/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs
+++ b/src/sidecars/SharpLsp.Sidecar.CSharp/Workspace/TargetFrameworks.cs
@@ -14,12 +14,23 @@ namespace SharpLsp.Sidecar.CSharp.Workspace;
 /// </summary>
 internal static class TargetFrameworks
 {
-    /// <summary>The framework of a per-framework project; null for a single-target one.</summary>
+    /// <summary>
+    /// The framework of a per-framework project; null for a single-target one.
+    /// <c>MSBuildWorkspace</c> appends <c>(tfm)</c> to the project FILE's stem, so only a
+    /// suffix past that stem is a framework: a single-target <c>Utility(net48).csproj</c>
+    /// is named <c>Utility(net48)</c> and has none.
+    /// </summary>
     internal static string? FrameworkOf(Project project)
     {
         var name = project.Name;
-        var open = name.LastIndexOf('(');
-        return open > 0 && name.EndsWith(')') ? name[(open + 1)..^1] : null;
+        var stem = project.FilePath is null ? name : NativePaths.StemOf(project.FilePath);
+        return
+            name.Length > stem.Length + 2
+            && name.StartsWith(stem, StringComparison.Ordinal)
+            && name[stem.Length] == '('
+            && name.EndsWith(')')
+            ? name[(stem.Length + 1)..^1]
+            : null;
     }
 
     /// <summary>The per-framework projects built from <paramref name="project"/>'s file, in load order.</summary>
diff --git a/src/sidecars/SharpLsp.Sidecar.FSharp.Tests/FSharpCSharpReferenceTests.fs b/src/sidecars/SharpLsp.Sidecar.FSharp.Tests/FSharpCSharpReferenceTests.fs
index ad689957..ff28b9f0 100644
--- a/src/sidecars/SharpLsp.Sidecar.FSharp.Tests/FSharpCSharpReferenceTests.fs
+++ b/src/sidecars/SharpLsp.Sidecar.FSharp.Tests/FSharpCSharpReferenceTests.fs
@@ -379,3 +379,53 @@ let ``a project reading C# in memory still offers the FS0001 conversion`` () =
         finally
             cleanup root
     }
+
+/// `Core`'s `Order` with an `init` accessor. On .NET Framework the compiler needs
+/// `IsExternalInit`, which the framework lacks and the PolySharp source generator writes
+/// into the build.
+let private orderSource =
+    String.Join(
+        "\n",
+        [ "namespace Core"
+          "{"
+          "    public sealed class Order"
+          "    {"
+          "        public string Sku { get; init; } = \"none\";"
+          "    }"
+          "}"
+          "" ]
+    )
+
+/// A C# project that a source generator completes compiles in memory as its build does:
+/// with the generator's sources. Without them, an `init` accessor on .NET Framework has
+/// no `IsExternalInit`, Roslyn emits nothing, and F# reads a DLL nobody built (FS0078,
+/// FS0084), as GitReader.Core's PolySharp polyfills showed.
+[<Fact>]
+let ``a C# project its source generator completes for .NET Framework is read in memory`` () =
+    task {
+        let root = NativePaths.Temp($"sharplsp-fs-cs-gen-{Guid.NewGuid():N}")
+
+        try
+            // As GitReader.Core: a modern C# on .NET Framework, polyfilled by PolySharp.
+            let modernCSharp = node "PropertyGroup" [ node "LangVersion" [ "latest" :> obj ] ]
+
+            let polySharp =
+                node "ItemGroup" [ node "PackageReference" [ attribute "Include" "PolySharp"; attribute "Version" "1.15.0"; attribute "PrivateAssets" "All" ] ]
+
+            writeProject root "Core" "csproj" "net48" "Order.cs" orderSource [] [ modernCSharp; polySharp ] |> ignore
+            let shopSource = "module Shop\n\nlet sku = Core.Order().Sku\n"
+            let shop = writeProject root "Shop" "fsproj" "net48" "Shop.fs" shopSource [ NativePaths.Join("..", "Core", "Core.csproj") ] []
+            restore (NativePaths.Resolve(root, "Shop", "Shop.fsproj"))
+            let state = FSharpWorkspace.create ()
+            let! loaded = FSharpWorkspace.loadProject state root
+            Assert.True(Result.isOk loaded, $"the project loads: {loaded}")
+
+            let! errors = errorsIn state shop
+            Assert.Empty(errors)
+            Assert.Equal(1, state.CSharpBuilds.Count)
+            let wired = (FSharpWorkspace.optionsFor state shop).Value
+            Assert.Equal(1, (assembliesReadBy wired).Length)
+            Assert.Empty(Directory.GetFiles(root, "*.dll", SearchOption.AllDirectories))
+        finally
+            cleanup root
+    }
diff --git a/src/sidecars/SharpLsp.Sidecar.FSharp/FSharpCSharpReferences.fs b/src/sidecars/SharpLsp.Sidecar.FSharp/FSharpCSharpReferences.fs
index cf125454..6b39d53c 100644
--- a/src/sidecars/SharpLsp.Sidecar.FSharp/FSharpCSharpReferences.fs
+++ b/src/sidecars/SharpLsp.Sidecar.FSharp/FSharpCSharpReferences.fs
@@ -104,6 +104,37 @@ let private emit (compilation: CSharpCompilation) =
 let private strongNaming (build: CSharpBuild) =
     DesktopStrongNameProvider(ImmutableArray.Create(NativePaths.DirectoryOf build.Project))
 
+/// Loads a source generator from the assembly a command line's `/analyzer:` names.
+type private GeneratorLoader() =
+    interface IAnalyzerAssemblyLoader with
+        member _.AddDependencyLocation(_: string) = ()
+        member _.LoadFromPath(path: string) = Reflection.Assembly.LoadFrom path
+
+let private generatorLoader = GeneratorLoader()
+
+/// The C# source generators `reference` holds; none when its assembly does not load here,
+/// and the log says why, so a generator never costs the project its load.
+let private generatorsIn (reference: Diagnostics.AnalyzerReference) =
+    try
+        reference.GetGenerators(LanguageNames.CSharp) |> List.ofSeq
+    with error ->
+        Log.Warning("Source generators of {Path} are skipped: {Reason}", reference.FullPath, error.Message)
+        []
+
+/// The C# source generators the command line's `/analyzer:` assemblies hold.
+let private generatorsOf (arguments: CSharpCommandLineArguments) =
+    arguments.ResolveAnalyzerReferences(generatorLoader) |> Seq.collect generatorsIn |> List.ofSeq
+
+/// `compilation` with the sources its source generators add, as the build runs them. A
+/// project that polyfills .NET Framework through one (PolySharp writes `IsExternalInit`
+/// for an `init` accessor) has no image without them, and F# would read a DLL nobody built.
+let private generated (arguments: CSharpCommandLineArguments) (compilation: CSharpCompilation) =
+    match generatorsOf arguments with
+    | [] -> compilation
+    | generators ->
+        CSharpGeneratorDriver.Create(generators, parseOptions = arguments.ParseOptions).RunGenerators(compilation).GetRunResult().GeneratedTrees
+        |> compilation.AddSyntaxTrees
+
 /// Each reference on the command line: a C# project compiled here is read from its
 /// compilation, a file the disk has from that file, and a file it lacks — an unbuilt
 /// project no build here covers — is left for the compiler to report.
@@ -128,6 +159,7 @@ and private compile (build: CSharpBuild) =
 
     let options = build.Arguments.CompilationOptions.WithStrongNameProvider(strongNaming build)
     CSharpCompilation.Create(name, syntaxTrees build.Arguments, metadataReferences build, options)
+    |> generated build.Arguments
 
 /// The compilation and image of `build` as its inputs stand now: emitted again when they
 /// changed, and the last ones kept when Roslyn cannot emit the changed sources.
diff --git a/src/website/src/_data/i18n.json b/src/website/src/_data/i18n.json
index 47349aed..55dd931b 100644
--- a/src/website/src/_data/i18n.json
+++ b/src/website/src/_data/i18n.json
@@ -154,6 +154,7 @@
       "contextMenus": "Context Menus",
       "nuget": "NuGet Package Manager",
       "profiler": "Profiler",
+      "fsharpProfiling": "Profiling F#",
       "memoryLeaks": "Fix a Memory Leak",
       "contributing": "Contributing",
       "menuLabel": "Documentation menu",
@@ -348,6 +349,7 @@
       "contextMenus": "上下文菜单",
       "nuget": "NuGet 包管理器",
       "profiler": "性能分析器",
+      "fsharpProfiling": "F# 性能分析",
       "memoryLeaks": "修复内存泄漏",
       "contributing": "参与贡献",
       "menuLabel": "文档菜单",
@@ -542,6 +544,7 @@
       "contextMenus": "コンテキストメニュー",
       "nuget": "NuGet パッケージマネージャー",
       "profiler": "プロファイラー",
+      "fsharpProfiling": "F# のプロファイリング",
       "memoryLeaks": "メモリリークの修正",
       "contributing": "コントリビューション",
       "menuLabel": "ドキュメントメニュー",
diff --git a/src/website/src/_data/navigation.json b/src/website/src/_data/navigation.json
index d1690891..14e8146a 100644
--- a/src/website/src/_data/navigation.json
+++ b/src/website/src/_data/navigation.json
@@ -17,7 +17,7 @@
         "refactoring/": "refactoring"
       }
     },
-    { "group": "tools", "pages": { "context-menus/": "contextMenus", "nuget/": "nuget", "profiler/": "profiler", "memory-leaks/": "memoryLeaks" } },
+    { "group": "tools", "pages": { "context-menus/": "contextMenus", "nuget/": "nuget", "profiler/": "profiler", "fsharp-profiling/": "fsharpProfiling", "memory-leaks/": "memoryLeaks" } },
     { "group": "contributors", "secondary": true, "pages": { "architecture/": "architecture", "contributing/": "contributing" } }
   ],
   "footer": [
diff --git a/src/website/src/_data/videos.json b/src/website/src/_data/videos.json
index 026b4b8c..0f93a73e 100644
--- a/src/website/src/_data/videos.json
+++ b/src/website/src/_data/videos.json
@@ -83,6 +83,28 @@
       }
     }
   },
+  "profiler-fsharp": {
+    "encodings": ["webm", "mp4"],
+    "width": 1920,
+    "height": 1200,
+    "duration": "PT1M52S",
+    "uploadDate": "2026-10-18T19:00:00+11:00",
+    "captions": ["en", "ja", "zh"],
+    "text": {
+      "en": {
+        "label": "Screen recording: profiling an F# app in VS Code with SharpLsp, from hot pipeline stages and closures to F# records and union cases leaking from a module value, and a verified fix",
+        "caption": "Narrated, with original music and captions. The F# loop on the FsStorefront demo, recorded in VS Code: Profile CPU and the heat map on .fs lines, Track Memory, records and union cases painted where they are built, the retention graph rooted at a module value, the fix typed in, then a second run. Fast-forwarded stretches are marked on screen."
+      },
+      "zh": {
+        "label": "屏幕录像：在 VS Code 中用 SharpLsp 分析 F# 应用，从热点管道阶段和闭包，到从模块值泄漏的 F# 记录和联合用例，再到验证修复",
+        "caption": "带旁白、原创配乐和字幕。在 VS Code 中录制的 FsStorefront 演示 F# 完整流程：Profile CPU 和 .fs 行上的热力图、Track Memory、标在构造位置的记录和联合用例、根为模块值的保留图、输入修复代码，然后再次运行。快进的片段在画面上有标注。"
+      },
+      "ja": {
+        "label": "画面録画：VS Code で SharpLsp を使い F# アプリをプロファイリング。ホットなパイプラインのステージとクロージャーから、モジュール値からリークする F# のレコードと共用体ケース、修正の確認まで",
+        "caption": "ナレーション、オリジナル音楽、字幕付き。VS Code で収録した FsStorefront デモでの F# の一連の流れ：Profile CPU と .fs の行のヒートマップ、Track Memory、組み立てた行に塗られるレコードと共用体ケース、モジュール値をルートとする保持グラフ、修正の入力、そして再実行。早送りの部分は画面上に表示されます。"
+      }
+    }
+  },
   "sharplsp-tour": {
     "encodings": ["webm", "mp4"],
     "width": 1000,
diff --git a/src/website/src/assets/screenshots/profiler/profiler-fsharp-graph.webp b/src/website/src/assets/screenshots/profiler/profiler-fsharp-graph.webp
new file mode 100644
index 00000000..1538c843
Binary files /dev/null and b/src/website/src/assets/screenshots/profiler/profiler-fsharp-graph.webp differ
diff --git a/src/website/src/assets/screenshots/profiler/profiler-fsharp-heatmap.webp b/src/website/src/assets/screenshots/profiler/profiler-fsharp-heatmap.webp
new file mode 100644
index 00000000..7fa25e7a
Binary files /dev/null and b/src/website/src/assets/screenshots/profiler/profiler-fsharp-heatmap.webp differ
diff --git a/src/website/src/assets/screenshots/profiler/profiler-fsharp-leaks.webp b/src/website/src/assets/screenshots/profiler/profiler-fsharp-leaks.webp
new file mode 100644
index 00000000..c2896bc8
Binary files /dev/null and b/src/website/src/assets/screenshots/profiler/profiler-fsharp-leaks.webp differ
diff --git a/src/website/src/assets/screenshots/profiler/profiler-fsharp-results.webp b/src/website/src/assets/screenshots/profiler/profiler-fsharp-results.webp
new file mode 100644
index 00000000..86389557
Binary files /dev/null and b/src/website/src/assets/screenshots/profiler/profiler-fsharp-results.webp differ
diff --git a/src/website/src/assets/videos/profiler-fsharp-poster.webp b/src/website/src/assets/videos/profiler-fsharp-poster.webp
new file mode 100644
index 00000000..8b51ecec
Binary files /dev/null and b/src/website/src/assets/videos/profiler-fsharp-poster.webp differ
diff --git a/src/website/src/assets/videos/profiler-fsharp.en.vtt b/src/website/src/assets/videos/profiler-fsharp.en.vtt
new file mode 100644
index 00000000..5fc6bbaa
--- /dev/null
+++ b/src/website/src/assets/videos/profiler-fsharp.en.vtt
@@ -0,0 +1,32 @@
+WEBVTT
+
+00:00.000 --> 00:07.432
+[Gentle music]
+This is FsStorefront, an F# app that's running right now. Let's find out where its time goes.
+
+00:12.850 --> 00:20.659
+Stop the profiler, and every hot line of F# lights up: the catalog parsing, the basket shuffle, and the discount fold.
+
+00:22.017 --> 00:31.499
+The results keep the names the F# compiler gives your code. Every closure and pipeline stage is named after its line, so you know exactly where to look.
+
+00:32.049 --> 00:38.125
+Now let's track memory on the same app. SharpLsp snapshots the heap every ten seconds.
+
+00:43.550 --> 00:50.638
+F# records and union cases show up as leak suspects. Click one, and you jump straight to the line that builds it.
+
+00:53.183 --> 00:54.974
+So, what's keeping them alive?
+
+00:58.379 --> 01:04.974
+A module value called sessions, named just as you wrote it. It holds every session the app has ever seen.
+
+01:07.646 --> 01:11.433
+The fix: keep the last thousand sessions, and let the rest go.
+
+01:23.613 --> 01:26.126
+Rebuild, run it again, and track memory.
+
+01:38.616 --> 01:47.220
+This time the heap holds steady, and nothing climbs past Low. That's F# profiling in SharpLsp. Free, and open source.
diff --git a/src/website/src/assets/videos/profiler-fsharp.ja.vtt b/src/website/src/assets/videos/profiler-fsharp.ja.vtt
new file mode 100644
index 00000000..639c6571
--- /dev/null
+++ b/src/website/src/assets/videos/profiler-fsharp.ja.vtt
@@ -0,0 +1,32 @@
+WEBVTT
+
+00:00.000 --> 00:07.432
+[穏やかな音楽]
+これは FsStorefront、いま実際に動いている F# アプリです。時間がどこに使われているのか見てみましょう。
+
+00:12.850 --> 00:20.659
+プロファイラーを止めると、F# のホットな行がすべて光ります。カタログの解析、バスケットのシャッフル、そして割引の fold です。
+
+00:22.017 --> 00:31.499
+結果には、F# コンパイラーがコードに付けた名前がそのまま残ります。クロージャーもパイプラインのステージも行にちなんだ名前なので、どこを見ればいいかがすぐわかります。
+
+00:32.049 --> 00:38.125
+次は同じアプリのメモリを追跡しましょう。SharpLsp が 10 秒ごとにヒープのスナップショットを取ります。
+
+00:43.550 --> 00:50.638
+F# のレコードと共用体ケースがリークの疑いとして現れます。クリックすると、それを組み立てる行に直接ジャンプします。
+
+00:53.183 --> 00:54.974
+では、何がそれらを生かし続けているのでしょうか？
+
+00:58.379 --> 01:04.974
+sessions というモジュール値です。書いたとおりの名前で示されます。アプリがこれまでに扱ったすべてのセッションを保持しています。
+
+01:07.646 --> 01:11.433
+修正は、直近 1,000 件のセッションだけを残し、残りを手放すことです。
+
+01:23.613 --> 01:26.126
+再ビルドして、もう一度実行し、メモリを追跡します。
+
+01:38.616 --> 01:47.220
+今度はヒープが横ばいのまま、Low を超えるものはありません。これが SharpLsp の F# プロファイリングです。無料で、オープンソースです。
diff --git a/src/website/src/assets/videos/profiler-fsharp.mp4 b/src/website/src/assets/videos/profiler-fsharp.mp4
new file mode 100644
index 00000000..58efb0c3
--- /dev/null
+++ b/src/website/src/assets/videos/profiler-fsharp.mp4
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cc27dbe605da94df73711d74ff23eea22ff99b31286d27bb8307828d271bdfd
+size 5539126
diff --git a/src/website/src/assets/videos/profiler-fsharp.webm b/src/website/src/assets/videos/profiler-fsharp.webm
new file mode 100644
index 00000000..84d64ae8
--- /dev/null
+++ b/src/website/src/assets/videos/profiler-fsharp.webm
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:91c8c742bc261c5a43cbe8e16fd342795102daeefd79ed0fbe8ca4ac4159bd8e
+size 6737758
diff --git a/src/website/src/assets/videos/profiler-fsharp.zh.vtt b/src/website/src/assets/videos/profiler-fsharp.zh.vtt
new file mode 100644
index 00000000..d9f4140f
--- /dev/null
+++ b/src/website/src/assets/videos/profiler-fsharp.zh.vtt
@@ -0,0 +1,32 @@
+WEBVTT
+
+00:00.000 --> 00:07.432
+[舒缓的音乐]
+这是 FsStorefront，一个正在运行的 F# 应用。我们来看看它的时间都花在了哪里。
+
+00:12.850 --> 00:20.659
+停止性能分析器，F# 的每个热点行都会亮起：商品目录解析、购物篮洗牌，还有折扣 fold。
+
+00:22.017 --> 00:31.499
+结果保留了 F# 编译器给代码起的名字。每个闭包和管道阶段都以它所在的行命名，所以你清楚地知道该看哪里。
+
+00:32.049 --> 00:38.125
+现在来跟踪同一个应用的内存。SharpLsp 每十秒为堆拍一次快照。
+
+00:43.550 --> 00:50.638
+F# 记录和联合用例被列为可疑泄漏。点击其中一个，就能直接跳到构造它的那一行。
+
+00:53.183 --> 00:54.974
+那么，是什么让它们一直存活？
+
+00:58.379 --> 01:04.974
+一个名为 sessions 的模块值，名称和你写的一模一样。它保存着应用见过的每一个会话。
+
+01:07.646 --> 01:11.433
+修复方法：只保留最近一千个会话，其余的放手。
+
+01:23.613 --> 01:26.126
+重新构建，再次运行，然后跟踪内存。
+
+01:38.616 --> 01:47.220
+这一次，堆保持平稳，没有任何项超过 Low。这就是 SharpLsp 的 F# 性能分析。免费，而且开源。
diff --git a/src/website/src/docs/fsharp-profiling.md b/src/website/src/docs/fsharp-profiling.md
new file mode 100644
index 00000000..72a639c5
--- /dev/null
+++ b/src/website/src/docs/fsharp-profiling.md
@@ -0,0 +1,102 @@
+---
+layout: layouts/docs.njk
+title: Profiling F#
+description: "Profile F# CPU and memory in VS Code with SharpLsp: heat bars on .fs lines, closures and pipeline stages by name, records and union cases anchored on the line that builds them, and leaks traced to the module value that holds them."
+eleventyExcludeFromCollections: true
+---
+
+# Profiling F#
+
+SharpLsp's [profiler](/docs/profiler/) attaches to the .NET runtime, not to a language, so an F# program gets everything a C# program gets: heat bars on hot lines, a flame graph, a live heap timeline and ranked leak suspects. It also understands the code the F# compiler emits:
+
+- **Closures and pipeline stages** keep the names the compiler gives them, so a hot stage points at its line.
+- **Records, unions and union cases** anchor on the line that constructs them, because the members the compiler generates for them have no source lines of their own.
+- **A leak held by a module value** names that value as it is spelled in your source.
+
+Here is the whole loop on FsStorefront, the F# twin of the C# Storefront demo, recorded in VS Code. Fast-forwarded stretches are marked on screen:
+
+{% video "profiler-fsharp" %}
+
+FsStorefront checks out orders forever: it parses a CSV catalog, picks a basket, prices it and renders an invoice with `sprintf`. It also keeps every customer session in a module-level `Dictionary` that nothing ever empties.
+
+## CPU profiling F# code
+
+Hover your app's row in the **Processes** view and click **Profile CPU**, or run **SharpLsp: Start Profiling**. Let the slow path run, then click **Stop Profiling**. Every hot line in your `.fs` files gets a heat bar with its share of the samples.
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-heatmap.webp" alt="Checkout.fs with heat bars on the CSV parsing, basket shuffle and discount lines of an F# program" width="2400" height="1500">
+  <figcaption>The heat map in <code>Checkout.fs</code>. The hot lines are the CSV parsing pipeline, the basket shuffle and the discount fold.</figcaption>
+</figure>
+
+The results panel and the flame graph name each frame as the compiler emitted it:
+
+| In your F# code | In the results |
+|---|---|
+| A module function, `let toProduct line = …` | `FsStorefront.Checkout.toProduct`: the namespace, the module, then the function |
+| A lambda, `fun p -> sprintf …` on line 24 | `Checkout+lines@24.Invoke`: the value it is bound to and its line |
+| A stage of a pipeline, `… \|> Array.choose toProduct` on line 11 | `Checkout+Pipe #1 stage #1 at line 11@11.Invoke` |
+| An `inline` function | No frame: the compiler copies its body into each caller, so its time is the caller's |
+| `List.map`, `Seq.fold` and the rest of FSharp.Core | `Microsoft.FSharp.Collections.ListModule.Map`, and so on |
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-results.webp" alt="SharpLsp Profiler results panel for an F# program, with a flame graph and hot functions named by module, closure and pipeline stage" width="2400" height="1500">
+  <figcaption>The results panel. Each closure and pipeline stage is named after the line that holds it.</figcaption>
+</figure>
+
+Profile the build you ship. A Debug build keeps a frame for every call. A Release build inlines small functions, and the F# compiler emits tail calls, so a function that ends by calling another can be missing from the stack beneath it.
+
+## Memory profiling F# code
+
+Click **Track Memory** on the row, or run **SharpLsp: Start Memory Tracking**. The **SharpLsp Memory Dashboard** opens beside your code with the heap timeline, the top allocation sites and the leak suspects. Turn on timed snapshots with `sharplsp.profiler.autoSnapshot`, and the dashboard ranks suspects as they grow.
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-leaks.webp" alt="Memory dashboard ranking F# records and a union case as leak suspects, beside Sessions.fs with purple heat bars on the lines that construct them" width="2400" height="1500">
+  <figcaption>Leak suspects in FsStorefront. The record and the union case are painted on the lines in <code>Sessions.fs</code> that build them.</figcaption>
+</figure>
+
+### Where an F# type is painted
+
+A C# class is painted on its declaration. Every member the F# compiler generates for a record or a union has no source line, so SharpLsp paints those types on the line in your program that constructs them:
+
+| Type | Where it is painted | Name in the dashboard |
+|---|---|---|
+| A record, `{ Order = order; Stage = stage; … }` | The line that builds it | `FsStorefront.CustomerSession` |
+| A union case with fields, `CheckedOut order.Total` | The line that builds it | `FsStorefront.Stage+CheckedOut`: each case with fields is a class nested in its union |
+| A single-case union, `CustomerId 42` | The line that builds it | `FsStorefront.CustomerId` |
+| A generic record | The line that builds it | Closed over its arguments, such as ``Tagged`1[System.Int32]`` |
+| A closure or an anonymous record | The line that builds it | Its compiled name |
+| A class with members of its own | Its first member | `FsStorefront.PriceTicker` |
+| A struct record or a struct union (`[<Struct>]`) | Nowhere: it is stored inside the object that holds it, so it never appears on its own | Not listed |
+| A union case without fields, such as `Browsing` | Nowhere: every use shares one instance, so it never grows | Not listed |
+| An array, an F# list, and other FSharp.Core and framework types | Nowhere: they have no source in your project | By name, such as ``FSharpList`1[FsStorefront.Product]`` |
+
+Click a suspect on the dashboard to jump to its line.
+
+### What keeps it alive: module values
+
+Run **SharpLsp: Show Reference Graph** and pick the suspect's type to see the objects that hold it and the root that keeps them alive. A module value such as `let private sessions = Dictionary<int, CustomerSession>()` compiles to a static field named after its line, `sessions@6`. The graph labels the root `static sessions`, as you wrote it.
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-graph.webp" alt="Retention graph for FsStorefront.CustomerSession: sessions held by a Dictionary rooted at the module value static sessions" width="2400" height="1500">
+  <figcaption>Every <code>CustomerSession</code> hangs off one <code>Dictionary</code>, rooted at the module value <code>sessions</code>.</figcaption>
+</figure>
+
+FsStorefront only needs recent sessions, so the fix keeps a window of the last 1,000:
+
+```fsharp
+// Remembers the last 1,000 orders "for analytics", and forgets older ones.
+let private sessions = Dictionary<int, CustomerSession>()
+
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
+    sessions.Remove(order.Id - 1_000) |> ignore
+```
+
+Rebuilt and tracked again, the heap levels off and no suspect climbs past Low. [How to Fix a Memory Leak](/docs/memory-leaks/) walks through the whole loop, with F# fixes for event handlers and closures and an F# leak test.
+
+## Related
+
+- [Profiler](/docs/profiler/): every profiler command and setting
+- [How to Fix a Memory Leak](/docs/memory-leaks/): the leak loop step by step, in C# and F#
+- [F# Language Support](/docs/fsharp/): everything else SharpLsp does for F#
diff --git a/src/website/src/docs/fsharp.md b/src/website/src/docs/fsharp.md
index 893bbc86..c6d9cc83 100644
--- a/src/website/src/docs/fsharp.md
+++ b/src/website/src/docs/fsharp.md
@@ -34,6 +34,7 @@ F# is a **first-class citizen** in SharpLsp. The Rust LSP host routes F# semanti
 | Formatting (Fantomas) | Not exposed | Implemented in the sidecar but intentionally not advertised or routed by the host |
 | Folding / Selection Range | Supported | The Rust host uses the F# tree-sitter grammar for both syntax features |
 | F# Interactive | Supported | VS Code commands for sending code, starting FSI, and generating signatures |
+| CPU and memory profiling | Supported | Heat bars on `.fs` lines, closures and pipeline stages by name, records and unions painted where they are built |
 
 ## IntelliSense
 
@@ -114,6 +115,12 @@ The VS Code extension provides:
 
 FSI uses the .NET 10 SDK located or installed during extension activation. Extra arguments come from the trusted-workspace VS Code setting `sharplsp.fsi.extraArgs`; they are not read from `sharplsp.toml`.
 
+## Profiling
+
+The SharpLsp profiler attaches to any running .NET process, so F# programs get CPU profiling, heap snapshots and leak suspects without a restart. It reads F#'s compiled code: closures and pipeline stages keep their compiler names, records and union cases are painted on the line that builds them, and a module value that holds a leak is named as in source. See [Profiling F#](/docs/fsharp-profiling/).
+
+{% video "profiler-fsharp" %}
+
 ## Editor-Agnostic Protocol
 
 SharpLsp prefers standard LSP methods for completion, hover, navigation, symbols, diagnostics, code lens, and hierarchies. VS Code is the supported client today; other editor integrations are still being prepared.
diff --git a/src/website/src/docs/memory-leaks.md b/src/website/src/docs/memory-leaks.md
index 60842864..1b1b4282 100644
--- a/src/website/src/docs/memory-leaks.md
+++ b/src/website/src/docs/memory-leaks.md
@@ -124,13 +124,14 @@ public static class SessionCache
 }
 ```
 
-The same leak in F# is a module-level `Dictionary`, and the fix is the same:
+The same leak in F# is a module-level `Dictionary`, and the fix is the same. [Profiling F#](/docs/fsharp-profiling/) films this loop on FsStorefront, Storefront's F# twin:
 
 ```fsharp
 let private sessions = Dictionary<int, CustomerSession>()
 
-let remember (order: Order) =
-    sessions[order.Id] <- CustomerSession order
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
     sessions.Remove(order.Id - 1_000) |> ignore
 ```
 
@@ -378,4 +379,5 @@ No. It is SharpLsp's own memory profiler, open source and MIT-licensed. Visual S
 ## Related
 
 - [Profiler](/docs/profiler/): every profiler command and setting
+- [Profiling F#](/docs/fsharp-profiling/): the same loop on an F# app
 - [Configuration](/docs/configuration/): the `[profiler]` table in `sharplsp.toml`
diff --git a/src/website/src/docs/profiler.md b/src/website/src/docs/profiler.md
index a5caf7af..117b44eb 100644
--- a/src/website/src/docs/profiler.md
+++ b/src/website/src/docs/profiler.md
@@ -114,6 +114,10 @@ Suspects are ranked by how consistently they grow. Each one shows its growth in
 
 {% video "profiler-memory-timelapse" %}
 
+## F#
+
+F# programs get the same profiler, and it reads the code the F# compiler emits. Closures and pipeline stages keep the names the compiler gives them, such as `Pipe #1 stage #1 at line 11`. Records, unions and union cases are painted on the line that constructs them. A leak held by a module value names that value as it is spelled in your source. [Profiling F#](/docs/fsharp-profiling/) shows the whole loop on an F# app, in a walkthrough video.
+
 ## Commands
 
 | Command | Purpose |
diff --git a/src/website/src/ja/docs/fsharp-profiling.md b/src/website/src/ja/docs/fsharp-profiling.md
new file mode 100644
index 00000000..d5dfcb91
--- /dev/null
+++ b/src/website/src/ja/docs/fsharp-profiling.md
@@ -0,0 +1,103 @@
+---
+layout: layouts/docs.njk
+title: F# のプロファイリング
+description: "SharpLsp で F# の CPU とメモリを VS Code でプロファイリング：.fs の行に付くヒートバー、名前で示されるクロージャーとパイプラインのステージ、組み立てた行に固定されるレコードと共用体ケース、リークを保持するモジュール値の特定。"
+lang: ja
+eleventyExcludeFromCollections: true
+---
+
+# F# のプロファイリング
+
+SharpLsp の[プロファイラー](/ja/docs/profiler/)は言語ではなく .NET ランタイムにアタッチするため、F# のプログラムも C# と同じものをすべて得られます。ホットな行のヒートバー、フレームグラフ、ライブのヒープタイムライン、ランク付けされたリークの疑いです。さらに、F# コンパイラーが生成するコードを理解します。
+
+- **クロージャーとパイプラインのステージ**は、コンパイラーが付けた名前のまま表示されるので、ホットなステージがその行を指し示します。
+- **レコード、共用体、共用体ケース**は、それを組み立てる行に固定されます。コンパイラーがこれらの型に生成するメンバーには、独自のソース行がないためです。
+- **モジュール値が保持するリーク**は、その値をソースに書いたとおりの名前で示します。
+
+C# の Storefront デモの F# 版である FsStorefront での一連の流れを、VS Code で収録しました。早送りの部分は画面上に表示されます。
+
+{% video "profiler-fsharp" %}
+
+FsStorefront は注文のチェックアウトを延々と続けます。CSV のカタログを解析し、バスケットを選び、価格を計算し、`sprintf` で請求書を作ります。さらに、すべての顧客セッションを、誰も空にしないモジュールレベルの `Dictionary` に保持し続けます。
+
+## F# コードの CPU プロファイリング
+
+**Processes** ビューでアプリの行にカーソルを合わせて **Profile CPU** をクリックするか、**SharpLsp: Start Profiling** を実行します。遅い処理を走らせてから **Stop Profiling** をクリックします。`.fs` ファイルのホットな行すべてに、サンプルに占める割合を示すヒートバーが付きます。
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-heatmap.webp" alt="F# プログラムの CSV 解析、バスケットのシャッフル、割引の行にヒートバーが付いた Checkout.fs" width="2400" height="1500">
+  <figcaption><code>Checkout.fs</code> のヒートマップ。ホットな行は、CSV 解析のパイプライン、バスケットのシャッフル、割引の fold です。</figcaption>
+</figure>
+
+結果パネルとフレームグラフは、各フレームをコンパイラーが生成したとおりの名前で表示します。
+
+| F# のコード | 結果での表示 |
+|---|---|
+| モジュール関数 `let toProduct line = …` | `FsStorefront.Checkout.toProduct`：名前空間、モジュール、関数の順 |
+| 24 行目のラムダ `fun p -> sprintf …` | `Checkout+lines@24.Invoke`：束縛先の値とその行 |
+| 11 行目のパイプラインのステージ `… \|> Array.choose toProduct` | `Checkout+Pipe #1 stage #1 at line 11@11.Invoke` |
+| `inline` 関数 | フレームなし：コンパイラーが本体を呼び出し元にコピーするため、その時間は呼び出し元のものになります |
+| `List.map`、`Seq.fold` など FSharp.Core の関数 | `Microsoft.FSharp.Collections.ListModule.Map` など |
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-results.webp" alt="F# プログラムの SharpLsp Profiler 結果パネル。フレームグラフと、モジュール、クロージャー、パイプラインのステージ名で示されたホット関数" width="2400" height="1500">
+  <figcaption>結果パネル。各クロージャーとパイプラインのステージは、それを含む行にちなんだ名前で示されます。</figcaption>
+</figure>
+
+出荷するビルドをプロファイリングしてください。Debug ビルドはすべての呼び出しにフレームを残します。Release ビルドは小さな関数をインライン化し、F# コンパイラーは末尾呼び出しを生成するので、最後に別の関数を呼び出して終わる関数は、その下のスタックから消えることがあります。
+
+## F# コードのメモリプロファイリング
+
+行の **Track Memory** をクリックするか、**SharpLsp: Start Memory Tracking** を実行します。**SharpLsp Memory Dashboard** がコードの隣に開き、ヒープのタイムライン、上位の割り当てサイト、リークの疑いを表示します。`sharplsp.profiler.autoSnapshot` で定期的なスナップショットをオンにすると、ダッシュボードは増え続ける型を疑いとしてランク付けします。
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-leaks.webp" alt="F# のレコードと共用体ケースをリークの疑いとしてランク付けするメモリダッシュボード。隣の Sessions.fs では、それらを組み立てる行に紫のヒートバーが付いている" width="2400" height="1500">
+  <figcaption>FsStorefront のリークの疑い。レコードと共用体ケースは、<code>Sessions.fs</code> でそれを組み立てる行に塗られます。</figcaption>
+</figure>
+
+### F# の型が塗られる場所
+
+C# のクラスは宣言に塗られます。F# コンパイラーがレコードや共用体に生成するメンバーにはソース行がないため、SharpLsp はそれらの型を、プログラム内でその型を組み立てる行に塗ります。
+
+| 型 | 塗られる場所 | ダッシュボードでの名前 |
+|---|---|---|
+| レコード `{ Order = order; Stage = stage; … }` | それを組み立てる行 | `FsStorefront.CustomerSession` |
+| フィールドを持つ共用体ケース `CheckedOut order.Total` | それを組み立てる行 | `FsStorefront.Stage+CheckedOut`：フィールドを持つケースは、共用体に入れ子になったクラスです |
+| 単一ケースの共用体 `CustomerId 42` | それを組み立てる行 | `FsStorefront.CustomerId` |
+| ジェネリックなレコード | それを組み立てる行 | ``Tagged`1[System.Int32]`` のように型引数を含む名前 |
+| クロージャーや匿名レコード | それを組み立てる行 | コンパイル後の名前 |
+| 独自のメンバーを持つクラス | 最初のメンバー | `FsStorefront.PriceTicker` |
+| 構造体のレコードや共用体（`[<Struct>]`） | なし：保持するオブジェクトの中に格納されるので、単独では現れません | 表示されない |
+| `Browsing` のようなフィールドのない共用体ケース | なし：すべての使用で 1 つのインスタンスを共有するので、増えません | 表示されない |
+| 配列、F# のリスト、その他の FSharp.Core やフレームワークの型 | なし：プロジェクト内にソースがありません | ``FSharpList`1[FsStorefront.Product]`` のように名前だけ |
+
+ダッシュボードの疑いをクリックすると、その行にジャンプします。
+
+### 何が生かし続けているか：モジュール値
+
+**SharpLsp: Show Reference Graph** を実行して疑いの型を選ぶと、その型を保持するオブジェクトと、それらを生かし続けるルートが表示されます。`let private sessions = Dictionary<int, CustomerSession>()` のようなモジュール値は、行番号付きの名前の静的フィールド `sessions@6` にコンパイルされます。グラフはそのルートを、書いたとおりに `static sessions` と表示します。
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-graph.webp" alt="FsStorefront.CustomerSession の保持グラフ：モジュール値 static sessions をルートとする Dictionary が保持するセッション" width="2400" height="1500">
+  <figcaption>すべての <code>CustomerSession</code> は 1 つの <code>Dictionary</code> にぶら下がり、そのルートはモジュール値 <code>sessions</code> です。</figcaption>
+</figure>
+
+FsStorefront に必要なのは最近のセッションだけなので、修正では直近 1,000 件の枠を保ちます。
+
+```fsharp
+// Remembers the last 1,000 orders "for analytics", and forgets older ones.
+let private sessions = Dictionary<int, CustomerSession>()
+
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
+    sessions.Remove(order.Id - 1_000) |> ignore
+```
+
+再ビルドしてもう一度追跡すると、ヒープは横ばいになり、Low を超える疑いはありません。[メモリリークの直し方](/ja/docs/memory-leaks/)では、イベントハンドラーやクロージャーの F# での修正と F# のリークテストを含め、この流れ全体を解説しています。
+
+## 関連
+
+- [プロファイラー](/ja/docs/profiler/)：プロファイラーのすべてのコマンドと設定
+- [メモリリークの直し方](/ja/docs/memory-leaks/)：C# と F# でのリーク修正の手順
+- [F# 言語サポート](/ja/docs/fsharp/)：SharpLsp が F# のためにできるその他すべて
diff --git a/src/website/src/ja/docs/fsharp.md b/src/website/src/ja/docs/fsharp.md
index 4c0357ca..966be67a 100644
--- a/src/website/src/ja/docs/fsharp.md
+++ b/src/website/src/ja/docs/fsharp.md
@@ -35,6 +35,7 @@ Ionide を支えるエンジンである [FsAutoComplete（FSAC）](https://ioni
 | フォーマット（Fantomas） | 非公開 | サイドカーには実装されていますが、ホストが意図的にサポート対象として通知せず、ルーティングもしていません |
 | 折りたたみ／選択範囲 | 対応済み | Rust ホストは、両方の構文機能に F# の tree-sitter 文法を使用します |
 | F# Interactive | 対応済み | コードの送信、FSI の起動、シグネチャ生成を行う VS Code コマンド |
+| CPU とメモリのプロファイリング | 対応済み | `.fs` の行のヒートバー、名前で示されるクロージャーとパイプラインのステージ、組み立てた行に塗られるレコードと共用体 |
 
 ## IntelliSense
 
@@ -115,6 +116,12 @@ VS Code 拡張機能は次の機能を提供します。
 
 FSI は、拡張機能のアクティベーション中に検出またはインストールされた .NET 10 SDK を使用します。追加引数は、信頼されたワークスペースでの VS Code 設定 `sharplsp.fsi.extraArgs` から取得します。`sharplsp.toml` からは読み取りません。
 
+## プロファイリング
+
+SharpLsp のプロファイラーは実行中の任意の .NET プロセスにアタッチするので、F# のプログラムでも再起動なしで CPU プロファイリング、ヒープのスナップショット、リークの疑いが得られます。F# のコンパイル後のコードも読み解きます。クロージャーとパイプラインのステージはコンパイラーが付けた名前で示され、レコードと共用体ケースはそれを組み立てる行に塗られ、リークを保持するモジュール値はソースのとおりの名前で示されます。[F# のプロファイリング](/ja/docs/fsharp-profiling/)を参照してください。
+
+{% video "profiler-fsharp" %}
+
 ## エディター非依存プロトコル
 
 SharpLsp は、補完、ホバー、ナビゲーション、シンボル、診断、コードレンズ、階層に標準 LSP メソッドを優先します。現在サポートされているクライアントは VS Code です。ほかのエディターとの連携は、まだ準備中です。
diff --git a/src/website/src/ja/docs/memory-leaks.md b/src/website/src/ja/docs/memory-leaks.md
index 8718bdda..debe904d 100644
--- a/src/website/src/ja/docs/memory-leaks.md
+++ b/src/website/src/ja/docs/memory-leaks.md
@@ -125,13 +125,14 @@ public static class SessionCache
 }
 ```
 
-F# での同じリークはモジュールレベルの `Dictionary` で、修正も同じです。
+F# での同じリークはモジュールレベルの `Dictionary` で、修正も同じです。[F# のプロファイリング](/ja/docs/fsharp-profiling/)では、Storefront の F# 版である FsStorefront でこの流れを収録しています。
 
 ```fsharp
 let private sessions = Dictionary<int, CustomerSession>()
 
-let remember (order: Order) =
-    sessions[order.Id] <- CustomerSession order
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
     sessions.Remove(order.Id - 1_000) |> ignore
 ```
 
@@ -379,4 +380,5 @@ dotnet-dump analyze <dump-file>
 ## 関連ドキュメント
 
 - [プロファイラー](/ja/docs/profiler/)：プロファイラーのすべてのコマンドと設定
+- [F# のプロファイリング](/ja/docs/fsharp-profiling/)：F# アプリでの同じ流れ
 - [設定](/ja/docs/configuration/)：`sharplsp.toml` の `[profiler]` テーブル
diff --git a/src/website/src/ja/docs/profiler.md b/src/website/src/ja/docs/profiler.md
index 3606317c..ba98211e 100644
--- a/src/website/src/ja/docs/profiler.md
+++ b/src/website/src/ja/docs/profiler.md
@@ -115,6 +115,10 @@ SharpLsp サイドバーの **Processes** ビューは、マシン上の .NET 
 
 {% video "profiler-memory-timelapse" %}
 
+## F#
+
+F# のプログラムにも同じプロファイラーが使え、F# コンパイラーが生成するコードを読み解きます。クロージャーとパイプラインのステージは、`Pipe #1 stage #1 at line 11` のようにコンパイラーが付けた名前のまま表示されます。レコード、共用体、共用体ケースは、それを組み立てる行に塗られます。モジュール値が保持するリークは、その値をソースに書いたとおりの名前で示します。[F# のプロファイリング](/ja/docs/fsharp-profiling/)では、F# アプリでの一連の流れを動画で紹介しています。
+
 ## コマンド
 
 | コマンド | 用途 |
diff --git a/src/website/src/zh/docs/fsharp-profiling.md b/src/website/src/zh/docs/fsharp-profiling.md
new file mode 100644
index 00000000..a54e6af3
--- /dev/null
+++ b/src/website/src/zh/docs/fsharp-profiling.md
@@ -0,0 +1,103 @@
+---
+layout: layouts/docs.njk
+title: F# 性能分析
+description: "用 SharpLsp 在 VS Code 中分析 F# 的 CPU 和内存：.fs 行上的热力条、按名称显示的闭包和管道阶段、标在构造位置的记录和联合用例，以及追溯到持有泄漏的模块值。"
+lang: zh
+eleventyExcludeFromCollections: true
+---
+
+# F# 性能分析
+
+SharpLsp 的[性能分析器](/zh/docs/profiler/)附加到 .NET 运行时，而不是某种语言，因此 F# 程序能得到 C# 程序拥有的一切：热点行上的热力条、火焰图、实时堆时间线和排好序的可疑泄漏。它还能读懂 F# 编译器生成的代码：
+
+- **闭包和管道阶段**保留编译器给它们的名称，因此热点阶段会指向它所在的行。
+- **记录、联合和联合用例**标在构造它们的行上，因为编译器为这些类型生成的成员没有自己的源代码行。
+- **由模块值持有的泄漏**会以源代码中的写法给出该值的名称。
+
+下面是在 FsStorefront（C# Storefront 演示的 F# 版本）上完整流程的录像，在 VS Code 中录制。快进的片段在画面上有标注：
+
+{% video "profiler-fsharp" %}
+
+FsStorefront 不停地处理订单结账：解析 CSV 商品目录、挑选购物篮、计算价格，并用 `sprintf` 生成发票。它还把每个客户会话都保存在一个模块级的 `Dictionary` 中，而这个字典从不清空。
+
+## 分析 F# 代码的 CPU
+
+在 **Processes** 视图中将鼠标悬停在应用所在行上并点击 **Profile CPU**，或运行 **SharpLsp: Start Profiling**。让慢路径运行一段时间，然后点击 **Stop Profiling**。`.fs` 文件中的每个热点行都会得到一个热力条，显示它所占的样本比例。
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-heatmap.webp" alt="Checkout.fs 中 F# 程序的 CSV 解析、购物篮洗牌和折扣行上带有热力条" width="2400" height="1500">
+  <figcaption><code>Checkout.fs</code> 中的热力图。热点行是 CSV 解析管道、购物篮洗牌和折扣的 fold。</figcaption>
+</figure>
+
+结果面板和火焰图按编译器生成的名称显示每一帧：
+
+| F# 代码 | 结果中的显示 |
+|---|---|
+| 模块函数 `let toProduct line = …` | `FsStorefront.Checkout.toProduct`：依次为命名空间、模块和函数 |
+| 第 24 行的 lambda `fun p -> sprintf …` | `Checkout+lines@24.Invoke`：它绑定到的值及其行号 |
+| 第 11 行的管道阶段 `… \|> Array.choose toProduct` | `Checkout+Pipe #1 stage #1 at line 11@11.Invoke` |
+| `inline` 函数 | 没有帧：编译器把函数体复制到每个调用方，所以它的时间计入调用方 |
+| `List.map`、`Seq.fold` 等 FSharp.Core 函数 | `Microsoft.FSharp.Collections.ListModule.Map` 等 |
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-results.webp" alt="F# 程序的 SharpLsp Profiler 结果面板，包含火焰图，以及按模块、闭包和管道阶段命名的热点函数" width="2400" height="1500">
+  <figcaption>结果面板。每个闭包和管道阶段都以它所在的行命名。</figcaption>
+</figure>
+
+请分析你实际发布的构建。Debug 构建为每次调用保留一个帧。Release 构建会内联小函数，F# 编译器还会生成尾调用，因此以调用另一个函数结束的函数可能不会出现在其下方的调用栈中。
+
+## 分析 F# 代码的内存
+
+点击该行的 **Track Memory**，或运行 **SharpLsp: Start Memory Tracking**。**SharpLsp Memory Dashboard** 会在代码旁打开，显示堆时间线、主要分配位置和可疑泄漏。用 `sharplsp.profiler.autoSnapshot` 打开定时快照后，仪表板会对持续增长的类型进行排序。
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-leaks.webp" alt="内存仪表板将 F# 记录和联合用例列为可疑泄漏，旁边的 Sessions.fs 在构造它们的行上带有紫色热力条" width="2400" height="1500">
+  <figcaption>FsStorefront 中的可疑泄漏。记录和联合用例被标在 <code>Sessions.fs</code> 中构造它们的行上。</figcaption>
+</figure>
+
+### F# 类型标在哪里
+
+C# 类标在它的声明处。F# 编译器为记录或联合生成的成员都没有源代码行，因此 SharpLsp 把这些类型标在程序中构造它们的行上：
+
+| 类型 | 标注位置 | 仪表板中的名称 |
+|---|---|---|
+| 记录 `{ Order = order; Stage = stage; … }` | 构造它的行 | `FsStorefront.CustomerSession` |
+| 带字段的联合用例 `CheckedOut order.Total` | 构造它的行 | `FsStorefront.Stage+CheckedOut`：每个带字段的用例都是嵌套在其联合中的类 |
+| 单用例联合 `CustomerId 42` | 构造它的行 | `FsStorefront.CustomerId` |
+| 泛型记录 | 构造它的行 | 带上类型参数，例如 ``Tagged`1[System.Int32]`` |
+| 闭包或匿名记录 | 构造它的行 | 编译后的名称 |
+| 有自己成员的类 | 它的第一个成员 | `FsStorefront.PriceTicker` |
+| 结构体记录或结构体联合（`[<Struct>]`） | 不标注：它存储在持有它的对象内部，不会单独出现 | 不列出 |
+| 不带字段的联合用例，例如 `Browsing` | 不标注：每次使用都共享同一个实例，所以不会增长 | 不列出 |
+| 数组、F# 列表以及其他 FSharp.Core 和框架类型 | 不标注：它们在你的项目中没有源代码 | 只显示名称，例如 ``FSharpList`1[FsStorefront.Product]`` |
+
+点击仪表板上的可疑项即可跳转到它的行。
+
+### 是什么让它一直存活：模块值
+
+运行 **SharpLsp: Show Reference Graph** 并选择可疑类型，即可看到持有它的对象，以及让这些对象一直存活的根。像 `let private sessions = Dictionary<int, CustomerSession>()` 这样的模块值会被编译成一个以行号命名的静态字段 `sessions@6`。保留图把这个根标为 `static sessions`，与你写的一致。
+
+<figure class="article-figure">
+  <img src="/assets/screenshots/profiler/profiler-fsharp-graph.webp" alt="FsStorefront.CustomerSession 的保留图：会话由一个 Dictionary 持有，根是模块值 static sessions" width="2400" height="1500">
+  <figcaption>每个 <code>CustomerSession</code> 都挂在同一个 <code>Dictionary</code> 上，根是模块值 <code>sessions</code>。</figcaption>
+</figure>
+
+FsStorefront 只需要最近的会话，所以修复方法是只保留最近 1,000 个：
+
+```fsharp
+// Remembers the last 1,000 orders "for analytics", and forgets older ones.
+let private sessions = Dictionary<int, CustomerSession>()
+
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
+    sessions.Remove(order.Id - 1_000) |> ignore
+```
+
+重新构建并再次跟踪后，堆趋于平稳，没有任何可疑项升到 Low 以上。[如何修复内存泄漏](/zh/docs/memory-leaks/)完整讲解了这一流程，包括事件处理程序和闭包的 F# 修复方法，以及 F# 泄漏测试。
+
+## 相关内容
+
+- [性能分析器](/zh/docs/profiler/)：所有性能分析器命令和设置
+- [如何修复内存泄漏](/zh/docs/memory-leaks/)：用 C# 和 F# 逐步修复泄漏
+- [F# 语言支持](/zh/docs/fsharp/)：SharpLsp 为 F# 提供的其他一切
diff --git a/src/website/src/zh/docs/fsharp.md b/src/website/src/zh/docs/fsharp.md
index ca7cba1c..417df6ff 100644
--- a/src/website/src/zh/docs/fsharp.md
+++ b/src/website/src/zh/docs/fsharp.md
@@ -35,6 +35,7 @@ F# 在 SharpLsp 中是**一等公民**。Rust LSP 主机会将 F# 语义请求
 | 格式化（Fantomas） | 未开放 | sidecar 已实现，但主机有意不公布也不路由该功能 |
 | 折叠／选择范围 | 支持 | Rust 主机使用 F# tree-sitter 语法提供这两项语法功能 |
 | F# Interactive | 支持 | 提供发送代码、启动 FSI 和生成签名的 VS Code 命令 |
+| CPU 和内存分析 | 支持 | `.fs` 行上的热力条、按名称显示的闭包和管道阶段、标在构造位置的记录和联合 |
 
 ## IntelliSense
 
@@ -115,6 +116,12 @@ VS Code 扩展提供：
 
 FSI 使用扩展激活期间定位或安装的 .NET 10 SDK。额外参数来自受信任工作区的 VS Code 设置 `sharplsp.fsi.extraArgs`，不会从 `sharplsp.toml` 读取。
 
+## 性能分析
+
+SharpLsp 性能分析器可以附加到任何正在运行的 .NET 进程，因此 F# 程序无需重启即可进行 CPU 分析、堆快照和可疑泄漏检测。它能读懂 F# 编译后的代码：闭包和管道阶段保留编译器给出的名称，记录和联合用例标在构造它们的行上，持有泄漏的模块值按源代码中的写法命名。请参阅 [F# 性能分析](/zh/docs/fsharp-profiling/)。
+
+{% video "profiler-fsharp" %}
+
 ## 编辑器无关协议
 
 SharpLsp 优先使用标准 LSP 方法来实现补全、悬停信息、导航、符号、诊断、Code Lens 和层次结构。目前受支持的客户端是 VS Code；其他编辑器集成仍在准备中。
diff --git a/src/website/src/zh/docs/memory-leaks.md b/src/website/src/zh/docs/memory-leaks.md
index 23b52b44..e4498f66 100644
--- a/src/website/src/zh/docs/memory-leaks.md
+++ b/src/website/src/zh/docs/memory-leaks.md
@@ -125,13 +125,14 @@ public static class SessionCache
 }
 ```
 
-同样的泄漏在 F# 中是一个模块级的 `Dictionary`，修复方法也一样：
+同样的泄漏在 F# 中是一个模块级的 `Dictionary`，修复方法也一样。[F# 性能分析](/zh/docs/fsharp-profiling/)录制了 Storefront 的 F# 版本 FsStorefront 上的这一流程：
 
 ```fsharp
 let private sessions = Dictionary<int, CustomerSession>()
 
-let remember (order: Order) =
-    sessions[order.Id] <- CustomerSession order
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
     sessions.Remove(order.Id - 1_000) |> ignore
 ```
 
@@ -379,4 +380,5 @@ dotnet-dump analyze <dump-file>
 ## 相关内容
 
 - [性能分析器](/zh/docs/profiler/)：所有性能分析器命令和设置
+- [F# 性能分析](/zh/docs/fsharp-profiling/)：在 F# 应用上的同一流程
 - [配置](/zh/docs/configuration/)：`sharplsp.toml` 中的 `[profiler]` 表
diff --git a/src/website/src/zh/docs/profiler.md b/src/website/src/zh/docs/profiler.md
index 39f8f735..264069cd 100644
--- a/src/website/src/zh/docs/profiler.md
+++ b/src/website/src/zh/docs/profiler.md
@@ -115,6 +115,10 @@ SharpLsp 侧边栏中的 **Processes** 视图会发现本机上的 .NET 进程
 
 {% video "profiler-memory-timelapse" %}
 
+## F#
+
+F# 程序可以使用同一个性能分析器，它能读懂 F# 编译器生成的代码。闭包和管道阶段保留编译器给出的名称，例如 `Pipe #1 stage #1 at line 11`。记录、联合和联合用例标在构造它们的行上。由模块值持有的泄漏会以源代码中的写法给出该值的名称。[F# 性能分析](/zh/docs/fsharp-profiling/)用一段演示视频展示了 F# 应用上的完整流程。
+
 ## 命令
 
 | 命令 | 用途 |
diff --git a/src/website/tests/docs-nav.spec.js b/src/website/tests/docs-nav.spec.js
index 6a7764a5..16fd4802 100644
--- a/src/website/tests/docs-nav.spec.js
+++ b/src/website/tests/docs-nav.spec.js
@@ -7,7 +7,7 @@ import { docsSidebar as sidebar, openDocsMenu as openDrawer } from './docs-menu.
 const GROUPS = {
   'Set up': ['Getting Started', 'Editor Setup', 'Zed', 'Configuration'],
   'Write code': ['F# Language Support', 'Code Completions', 'Hover & Quick Info', 'Go to Definition', 'Diagnostics', 'Refactoring & Code Actions'],
-  'Project tools': ['Context Menus', 'NuGet Package Manager', 'Profiler', 'Fix a Memory Leak'],
+  'Project tools': ['Context Menus', 'NuGet Package Manager', 'Profiler', 'Profiling F#', 'Fix a Memory Leak'],
 };
 const CONTRIBUTOR_PAGES = ['Architecture', 'Contributing'];
 const LOCALIZED_GROUPS = { '/zh/docs/': ['安装与设置', '编写代码', '项目工具', '面向贡献者'], '/ja/docs/': ['セットアップ', 'コードを書く', 'プロジェクトツール', 'コントリビューター向け'] };
diff --git a/src/website/tests/profiler-media.spec.js b/src/website/tests/profiler-media.spec.js
index 0e5d195f..630025d3 100644
--- a/src/website/tests/profiler-media.spec.js
+++ b/src/website/tests/profiler-media.spec.js
@@ -9,9 +9,26 @@ const PROFILER_STILLS = 8;
 const STILL_WIDTH = 2400;
 const DOCS = ['/docs/profiler/', '/zh/docs/profiler/', '/ja/docs/profiler/'];
 
+const FSHARP_POSTER = '/assets/videos/profiler-fsharp-poster.webp';
+const FSHARP_STILLS = ['heatmap', 'results', 'leaks', 'graph'].map((shot) => `/assets/screenshots/profiler/profiler-fsharp-${shot}.webp`);
+const FSHARP_DOCS = ['/docs/fsharp-profiling/', '/zh/docs/fsharp-profiling/', '/ja/docs/fsharp-profiling/'];
+
 const RECORDING_SOURCES = ['/assets/videos/profiler-cpu-recording.mp4'];
 const AUTOPLAYING = ['section.hero video', 'section[aria-labelledby="profiler-title"] video'];
 
+/** Every profiler still on the page loads as the 2400px render with real alt text. */
+async function expectStills(stills) {
+  for (const still of await stills.all()) {
+    await still.scrollIntoViewIfNeeded();
+    const rendered = await still.evaluate((img) => ({ complete: img.complete, width: img.naturalWidth, alt: img.alt }));
+    expect(rendered.complete, 'still finishes loading').toBe(true);
+    expect(rendered.width, 'still is the 2400px render').toBe(STILL_WIDTH);
+    // Characters, not words: a CJK description is dense, so the floor is low but real.
+    expect(rendered.alt.length, 'still has meaningful alt text').toBeGreaterThanOrEqual(8);
+    expect(rendered.alt, 'alt text describes the shot, not the file').not.toContain('.webp');
+  }
+}
+
 async function expectSilentLoop(request, video, sources) {
   await expect(video).toHaveAttribute('autoplay', '');
   await expect(video).toHaveAttribute('loop', '');
@@ -94,15 +111,7 @@ test.describe('Profiler docs media', () => {
       await page.goto(docPath);
       const stills = page.locator('img[src^="/assets/screenshots/profiler/"]');
       await expect(stills).toHaveCount(PROFILER_STILLS);
-      for (const still of await stills.all()) {
-        await still.scrollIntoViewIfNeeded();
-        const rendered = await still.evaluate((img) => ({ complete: img.complete, width: img.naturalWidth, alt: img.alt }));
-        expect(rendered.complete, 'still finishes loading').toBe(true);
-        expect(rendered.width, 'still is the 2400px render').toBe(STILL_WIDTH);
-        // Characters, not words: a CJK description is dense, so the floor is low but real.
-        expect(rendered.alt.length, 'still has meaningful alt text').toBeGreaterThanOrEqual(8);
-        expect(rendered.alt, 'alt text describes the shot, not the file').not.toContain('.webp');
-      }
+      await expectStills(stills);
 
       const videos = page.locator('figure video');
       await expect(videos).toHaveCount(3);
@@ -115,3 +124,22 @@ test.describe('Profiler docs media', () => {
     });
   }
 });
+
+test.describe('F# profiling docs media', () => {
+  for (const docPath of FSHARP_DOCS) {
+    test(`${docPath} shows the F# stills in order and the F# walkthrough with controls`, async ({ page, request }) => {
+      await page.goto(docPath);
+      const stills = page.locator('img[src^="/assets/screenshots/profiler/"]');
+      await expect(stills).toHaveCount(FSHARP_STILLS.length);
+      expect(await stills.evaluateAll((images) => images.map((img) => img.getAttribute('src'))), 'heat map, results, suspects, graph').toEqual(FSHARP_STILLS);
+      await expectStills(stills);
+
+      const video = page.locator('figure video');
+      await expect(video).toHaveCount(1);
+      await expect(video).toHaveAttribute('controls', '');
+      await expect(video).not.toHaveAttribute('autoplay', '');
+      await expect(video).toHaveAttribute('poster', FSHARP_POSTER);
+      await expectPlayable(request, await sourcesOf(video), 'video/');
+    });
+  }
+});
diff --git a/src/website/tests/site-videos.spec.js b/src/website/tests/site-videos.spec.js
index 052eee21..a52b4d94 100644
--- a/src/website/tests/site-videos.spec.js
+++ b/src/website/tests/site-videos.spec.js
@@ -19,6 +19,12 @@ const PAGES = [
   { path: '/docs/memory-leaks/', videos: ['profiler-fix-memory-leak'], says: 'leak' },
   { path: '/ja/docs/memory-leaks/', videos: ['profiler-fix-memory-leak'], says: 'リーク' },
   { path: '/zh/docs/memory-leaks/', videos: ['profiler-fix-memory-leak'], says: '泄漏' },
+  { path: '/docs/fsharp-profiling/', videos: ['profiler-fsharp'], says: 'profiling' },
+  { path: '/ja/docs/fsharp-profiling/', videos: ['profiler-fsharp'], says: 'プロファイリング' },
+  { path: '/zh/docs/fsharp-profiling/', videos: ['profiler-fsharp'], says: '分析' },
+  { path: '/docs/fsharp/', videos: ['profiler-fsharp'], says: 'profiling' },
+  { path: '/ja/docs/fsharp/', videos: ['profiler-fsharp'], says: 'プロファイリング' },
+  { path: '/zh/docs/fsharp/', videos: ['profiler-fsharp'], says: '分析' },
   { path: '/blog/introducing-sharplsp/', videos: ['profiler-film'], says: 'profiler' },
   { path: '/ja/blog/introducing-sharplsp/', videos: ['profiler-film'], says: 'プロファイラー' },
   { path: '/zh/blog/introducing-sharplsp/', videos: ['profiler-film'], says: '性能分析器' },
@@ -71,8 +77,24 @@ for (const { path, videos, says } of PAGES) {
   });
 }
 
+// The F# walkthrough is narrated: a reader hears it, and reads it in their own language.
+const NARRATED = [['/docs/fsharp-profiling/', 'en'], ['/ja/docs/fsharp-profiling/', 'ja'], ['/zh/docs/fsharp-profiling/', 'zh']];
+
+for (const [path, lang] of NARRATED) {
+  test(`${path} plays the F# walkthrough with its narration, captioned in ${lang} by default`, async ({ page, request }) => {
+    await page.goto(path);
+    const player = page.locator('figure video');
+    expect((await playback(player)).muted, 'the narration is heard, never muted').toBe(false);
+    const tracks = player.locator('track[kind="captions"]');
+    await expect(tracks).toHaveCount(3);
+    expect(await tracks.evaluateAll((all) => all.map((track) => track.getAttribute('srclang'))), 'captions in every site language').toEqual(['en', 'ja', 'zh']);
+    await expect(player.locator('track[default]')).toHaveAttribute('srclang', lang);
+    await expectPlayable(request, await tracks.evaluateAll((all) => all.map((track) => track.getAttribute('src'))), 'text/vtt');
+  });
+}
+
 test('articles and docs never autoplay; readers start every film themselves', async ({ page }) => {
-  for (const path of ['/docs/', '/docs/memory-leaks/', '/blog/introducing-sharplsp/', '/blog/editor-agnostic-dotnet-lsp/']) {
+  for (const path of ['/docs/', '/docs/memory-leaks/', '/docs/fsharp-profiling/', '/blog/introducing-sharplsp/', '/blog/editor-agnostic-dotnet-lsp/']) {
     await page.goto(path);
     const player = page.locator('figure video').first();
     await expect(player).toHaveAttribute('controls', '');
diff --git a/src/website/tools/profiler-film/.gitignore b/src/website/tools/profiler-film/.gitignore
index 89f9ac04..ed1bf778 100644
--- a/src/website/tools/profiler-film/.gitignore
+++ b/src/website/tools/profiler-film/.gitignore
@@ -1 +1,2 @@
 out/
+node_modules/
diff --git a/src/website/tools/profiler-film/README.md b/src/website/tools/profiler-film/README.md
new file mode 100644
index 00000000..dbc5096d
--- /dev/null
+++ b/src/website/tools/profiler-film/README.md
@@ -0,0 +1,93 @@
+# Profiler films
+
+This folder holds the scripts that shoot and publish the videos and stills on sharplsp.dev. Every frame is the real extension: an isolated VS Code (its own user data and extensions, never yours) runs the packaged VSIX against a demo app. Nothing in the editor is mocked. The rules are in [WEB-DESIGN-MEDIA](../../../../docs/specs/DESIGN-SYSTEM.md).
+
+## Make a film
+
+You need a packaged VSIX, ffmpeg with libvpx and libopus, cwebp, and the .NET 10 SDK. Install the narration voice once:
+
+```sh
+npm ci --prefix src/website                            # Playwright
+npm ci --prefix src/website/tools/profiler-film        # kokoro-js, for narration
+```
+
+The first narrated publish downloads the voice model (about 310 MB) into `node_modules`; a later `npm ci` there deletes it again.
+
+Then shoot and publish a film by its name in `films/`:
+
+```sh
+make _film FILM=fsharp             # package the VSIX, shoot, then publish
+make _film FILM=fsharp PUBLISH=1   # publish the last shoot again
+```
+
+`make _film` runs `node src/website/tools/profiler-film/film.mjs <film> [--publish]`, which you can also call directly after `make _build-vsix VSIX_PREBUILT=1`.
+
+A shoot takes a few minutes and lands in `out/<film>/`, which is gitignored. Publishing writes the MP4, WebM, poster, captions and stills into `src/website/src/assets/`. Add or update the video's entry in `src/website/src/_data/videos.json` (its length, its upload date, and its label and caption in each language), then place it on a page with `{% video "<name>" %}`.
+
+| Film | Video | What it shows |
+|---|---|---|
+| `fsharp` | `profiler-fsharp` | CPU and memory on FsStorefront, the F# demo. Narrated. |
+| `leak` | `profiler-fix-memory-leak` | The C# memory-leak loop on Storefront |
+| `films/profiler/` | `profiler-film` | The one-minute composited film: `capture.mjs`, then `render.mjs` |
+
+## Add a film
+
+A film is one file in `films/`. It exports the video's name, the demo it is shot on, the poster frame and its scenes:
+
+```js
+import { cpuLoop } from '../kit/acts/cpu.mjs';
+import { prepare } from '../kit/scenes.mjs';
+import { STOREFRONT } from '../kit/set.mjs';
+
+export default {
+  name: 'profiler-cpu-tour',
+  demo: STOREFRONT,
+  narration: 'cpu-tour.narration.json', // optional
+  poster: { scene: 'heat', at: 4 },
+  scenes: [
+    { offCamera: prepare('CheckoutPipeline.cs') },
+    ...cpuLoop({ file: 'CheckoutPipeline.cs', captions: { profile: '…', heat: '…', results: '…' } }, 1),
+  ],
+};
+```
+
+A scene is either a clip or a step off camera:
+
+- `{ clip, act, speed, retries }`: `act(shot)` is recorded in real time as `<clip>.mp4`. It plays back at `speed`, and the frame shows a speed badge whenever `speed` is above 1. `retries` shoots a flaky take again.
+- `{ offCamera }`: `offCamera(shot)` runs between clips and is never recorded. Use it for setup, rebuilds and stills.
+
+`shot` is `{ page, set, app, workspace, stills }`: the Playwright page, the recorder, the demo process, the staged workspace and the stills folder.
+
+The kit tells the common stories so a film only supplies its words:
+
+| Module | What it gives a film |
+|---|---|
+| `kit/acts/cpu.mjs` | `cpuLoop(story, first)`: Profile CPU, sampling at 4×, the heat map, the results panel, and optional stills |
+| `kit/acts/memory.mjs` | `memoryLoop(story, first)`: Track Memory, growth at 8×, a suspect, the retention graph, the fix typed in, and the fixed build tracked again |
+| `kit/scenes.mjs` | `prepare(file)`, `switchTo(file)`, `restart`, `startOnRow(step, text, action, status)`, and the shoot and publish engine |
+| `kit/overlay.mjs` | `caption(page, step, text, speed)` and `ringClick(page, cues, locator, label)` |
+| `kit/workbench.mjs` | Editor moves: the Processes view and its demo row, `openFile`, `toggleMaximised`, `typeAt`, `panel` and more |
+| `kit/camera.mjs` | `snap(shot, name)` takes a still, published as `<name>.webp` |
+| `kit/set.mjs` | The demos (`STOREFRONT`, `FS_STOREFRONT`) and `onSet`, which stages a demo beside an isolated editor |
+| `kit/sound/` | Narration (`voice.mjs`), the original score (`score.mjs`) and the mix (`soundtrack.mjs`) |
+
+A new demo app goes in `demos/<folder>/`, with one project and an empty `Directory.Build.props`, and is declared in `kit/set.mjs`. It must print a line to stdout once it is running.
+
+## Narration
+
+A narrated film has a script next to it, `films/<film>.narration.json`:
+
+```json
+{
+  "voice": "af_heart",
+  "say": { "F#": "F sharp" },
+  "music": { "en": "[Gentle music]", "ja": "[穏やかな音楽]", "zh": "[舒缓的音乐]" },
+  "lines": [{ "scene": "heat", "en": "…", "ja": "…", "zh": "…" }]
+}
+```
+
+- **Voice.** Kokoro-82M (Apache-2.0) speaks each line in English on this machine, through `kokoro-js`. Never use a speech service or the operating system's voices: their licences forbid publishing.
+- **Pronunciation.** `say` respells words for the voice only. The captions keep the original spelling.
+- **Timing.** Each line starts just after its scene's cut. A scene holds its last frame until its line has been spoken, so keep lines about as long as their scenes.
+- **Music.** `kit/sound/score.mjs` synthesises an original score, so no film carries licensed music. It ducks under the voice, and the mix is normalised to -16 LUFS.
+- **Captions.** Every language in `music` gets WebVTT captions, `<name>.<lang>.vtt`. List those languages under `captions` in `videos.json`, and the page's own language shows by default.
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/Catalog.fs b/src/website/tools/profiler-film/demos/fs-storefront/Catalog.fs
new file mode 100644
index 00000000..a1552a90
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/Catalog.fs
@@ -0,0 +1,14 @@
+module FsStorefront.Catalog
+
+open System.Globalization
+
+let private adjectives = [| "Ergonomic"; "Rustic"; "Sleek"; "Vintage" |]
+let private nouns = [| "Keyboard"; "Lamp"; "Backpack"; "Kettle"; "Monitor" |]
+
+let private row index =
+    let name = $"{adjectives[index % adjectives.Length]} {nouns[index % nouns.Length]}"
+    let price = (9.99m + decimal (index % 90)).ToString CultureInfo.InvariantCulture
+    $"SKU-%05d{index},{name},{price}"
+
+/// The catalog as CSV, one product per line.
+let generate itemCount = List.init itemCount row |> String.concat "\n"
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/Checkout.fs b/src/website/tools/profiler-film/demos/fs-storefront/Checkout.fs
new file mode 100644
index 00000000..7465d3b8
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/Checkout.fs
@@ -0,0 +1,30 @@
+module FsStorefront.Checkout
+
+open System
+open System.Globalization
+
+let private toProduct (line: string) =
+    match line.Split ',' with
+    | [| sku; name; price |] -> Some { Sku = sku; Name = name; Price = Decimal.Parse(price, CultureInfo.InvariantCulture) }
+    | _ -> None
+
+let parseCatalog (csv: string) = csv.Split '\n' |> Array.choose toProduct |> List.ofArray
+
+let pickBasket seed products =
+    let random = Random seed
+    products |> List.sortBy (fun _ -> random.Next()) |> List.truncate 12
+
+let private applyDiscounts product =
+    let hash = Seq.fold (fun hash round -> (hash * 31) ^^^ int product.Sku[round % product.Sku.Length]) 17 (seq { 0..4_999 })
+    if hash % 7 = 0 then product.Price * 0.9m else product.Price
+
+let priceBasket basket = basket |> List.sumBy applyDiscounts
+
+let renderInvoice orderId basket total =
+    let lines = basket |> List.map (fun p -> sprintf "%-12s%-28s%10.2f" p.Sku p.Name p.Price)
+    sprintf "INVOICE #%d\n%s\nTOTAL %.2f" orderId (String.concat "\n" lines) total
+
+let checkout catalog orderId =
+    let basket = parseCatalog catalog |> pickBasket orderId
+    let total = priceBasket basket
+    { Id = orderId; Items = basket; Total = total; Invoice = renderInvoice orderId basket total }
diff --git a/src/website/tools/profiler-film/storefront/Directory.Build.props b/src/website/tools/profiler-film/demos/fs-storefront/Directory.Build.props
similarity index 100%
rename from src/website/tools/profiler-film/storefront/Directory.Build.props
rename to src/website/tools/profiler-film/demos/fs-storefront/Directory.Build.props
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/Domain.fs b/src/website/tools/profiler-film/demos/fs-storefront/Domain.fs
new file mode 100644
index 00000000..5546f827
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/Domain.fs
@@ -0,0 +1,11 @@
+namespace FsStorefront
+
+type Product = { Sku: string; Name: string; Price: decimal }
+
+type Order = { Id: int; Items: Product list; Total: decimal; Invoice: string }
+
+type Stage =
+    | Browsing
+    | CheckedOut of total: decimal
+
+type CustomerSession = { Order: Order; Stage: Stage; Snapshot: byte array }
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/FsStorefront.fsproj b/src/website/tools/profiler-film/demos/fs-storefront/FsStorefront.fsproj
new file mode 100644
index 00000000..9fc17acf
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/FsStorefront.fsproj
@@ -0,0 +1,13 @@
+<Project Sdk="Microsoft.NET.Sdk">
+    <PropertyGroup>
+        <OutputType>Exe</OutputType>
+        <TargetFramework>net10.0</TargetFramework>
+    </PropertyGroup>
+    <ItemGroup>
+        <Compile Include="Domain.fs" />
+        <Compile Include="Catalog.fs" />
+        <Compile Include="Checkout.fs" />
+        <Compile Include="Sessions.fs" />
+        <Compile Include="Program.fs" />
+    </ItemGroup>
+</Project>
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/FsStorefront.slnx b/src/website/tools/profiler-film/demos/fs-storefront/FsStorefront.slnx
new file mode 100644
index 00000000..fe762db4
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/FsStorefront.slnx
@@ -0,0 +1,3 @@
+<Solution>
+  <Project Path="FsStorefront.fsproj" />
+</Solution>
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/Program.fs b/src/website/tools/profiler-film/demos/fs-storefront/Program.fs
new file mode 100644
index 00000000..788b3d50
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/Program.fs
@@ -0,0 +1,12 @@
+// FsStorefront: the F# demo workload the website's profiler film records.
+// It checks out orders forever, with real hot paths and a cache that never evicts.
+module FsStorefront.Program
+
+open System
+
+[<EntryPoint>]
+let main _ =
+    let catalog = Catalog.generate 2_000
+    printfn $"FsStorefront running (PID {Environment.ProcessId})"
+    Seq.initInfinite (Checkout.checkout catalog) |> Seq.iter Sessions.remember
+    0
diff --git a/src/website/tools/profiler-film/demos/fs-storefront/Sessions.fs b/src/website/tools/profiler-film/demos/fs-storefront/Sessions.fs
new file mode 100644
index 00000000..06afa375
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/fs-storefront/Sessions.fs
@@ -0,0 +1,10 @@
+module FsStorefront.Sessions
+
+open System.Collections.Generic
+
+// Remembers every order "for analytics", and never forgets one.
+let private sessions = Dictionary<int, CustomerSession>()
+
+let remember order =
+    let stage = CheckedOut order.Total
+    sessions[order.Id] <- { Order = order; Stage = stage; Snapshot = Array.zeroCreate 4096 }
diff --git a/src/website/tools/profiler-film/storefront/Catalog.cs b/src/website/tools/profiler-film/demos/storefront/Catalog.cs
similarity index 100%
rename from src/website/tools/profiler-film/storefront/Catalog.cs
rename to src/website/tools/profiler-film/demos/storefront/Catalog.cs
diff --git a/src/website/tools/profiler-film/storefront/CheckoutPipeline.cs b/src/website/tools/profiler-film/demos/storefront/CheckoutPipeline.cs
similarity index 100%
rename from src/website/tools/profiler-film/storefront/CheckoutPipeline.cs
rename to src/website/tools/profiler-film/demos/storefront/CheckoutPipeline.cs
diff --git a/src/website/tools/profiler-film/demos/storefront/Directory.Build.props b/src/website/tools/profiler-film/demos/storefront/Directory.Build.props
new file mode 100644
index 00000000..37390751
--- /dev/null
+++ b/src/website/tools/profiler-film/demos/storefront/Directory.Build.props
@@ -0,0 +1,3 @@
+<Project>
+    <!-- The film's demo workload is a standalone app, not product code: stop the repo props applying. -->
+</Project>
diff --git a/src/website/tools/profiler-film/storefront/Program.cs b/src/website/tools/profiler-film/demos/storefront/Program.cs
similarity index 100%
rename from src/website/tools/profiler-film/storefront/Program.cs
rename to src/website/tools/profiler-film/demos/storefront/Program.cs
diff --git a/src/website/tools/profiler-film/storefront/SessionCache.cs b/src/website/tools/profiler-film/demos/storefront/SessionCache.cs
similarity index 100%
rename from src/website/tools/profiler-film/storefront/SessionCache.cs
rename to src/website/tools/profiler-film/demos/storefront/SessionCache.cs
diff --git a/src/website/tools/profiler-film/storefront/Storefront.csproj b/src/website/tools/profiler-film/demos/storefront/Storefront.csproj
similarity index 100%
rename from src/website/tools/profiler-film/storefront/Storefront.csproj
rename to src/website/tools/profiler-film/demos/storefront/Storefront.csproj
diff --git a/src/website/tools/profiler-film/storefront/Storefront.slnx b/src/website/tools/profiler-film/demos/storefront/Storefront.slnx
similarity index 100%
rename from src/website/tools/profiler-film/storefront/Storefront.slnx
rename to src/website/tools/profiler-film/demos/storefront/Storefront.slnx
diff --git a/src/website/tools/profiler-film/film.mjs b/src/website/tools/profiler-film/film.mjs
new file mode 100644
index 00000000..0fcef170
--- /dev/null
+++ b/src/website/tools/profiler-film/film.mjs
@@ -0,0 +1,28 @@
+// Implements [WEB-DESIGN-MEDIA]. Shoots and publishes one walkthrough film from
+// films/<film>.mjs. See README.md.
+//
+//   make _build-vsix VSIX_PREBUILT=1
+//   node src/website/tools/profiler-film/film.mjs <film>              (shoot, then publish)
+//   node src/website/tools/profiler-film/film.mjs <film> --publish    (publish the last shoot)
+//
+// A shoot lands in out/<film>/ (gitignored); publishing writes the site's video,
+// poster, captions and stills under src/website/src/assets.
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { out as filmsOut, publishStills } from './kit/encode.mjs';
+import { publishWalkthrough, shootWalkthrough } from './kit/scenes.mjs';
+
+const films = path.join(path.dirname(fileURLToPath(import.meta.url)), 'films');
+const available = fs.readdirSync(films).filter((file) => file.endsWith('.mjs')).map((file) => file.replace(/\.mjs$/, ''));
+const [id] = process.argv.slice(2).filter((arg) => !arg.startsWith('--'));
+if (!available.includes(id)) throw new Error(`usage: film.mjs <${available.join('|')}> [--publish]`);
+
+const film = (await import(path.join(films, `${id}.mjs`))).default;
+const out = path.join(filmsOut, id);
+const narration = film.narration && JSON.parse(fs.readFileSync(path.join(films, film.narration), 'utf8'));
+
+if (!process.argv.includes('--publish')) await shootWalkthrough({ demo: film.demo, out, scenes: film.scenes });
+const length = await publishWalkthrough({ name: film.name, out, scenes: film.scenes, posterAt: film.poster, narration });
+if (fs.existsSync(path.join(out, 'stills'))) publishStills(path.join(out, 'stills'));
+process.stdout.write(`${film.name}: ${length.toFixed(1)}s published\n`);
diff --git a/src/website/tools/profiler-film/films/fsharp.mjs b/src/website/tools/profiler-film/films/fsharp.mjs
new file mode 100644
index 00000000..5d26f61f
--- /dev/null
+++ b/src/website/tools/profiler-film/films/fsharp.mjs
@@ -0,0 +1,61 @@
+// Implements [WEB-DESIGN-MEDIA]. The F# walkthrough the profiler docs play
+// (`profiler-fsharp`): FsStorefront's CPU down to its F# lines and pipeline
+// stages, then its memory: records and union cases painted where the code
+// builds them, the module value that roots the leak, the fix, and a second run.
+//
+//   node src/website/tools/profiler-film/film.mjs fsharp
+import { snap } from '../kit/camera.mjs';
+import { cpuLoop } from '../kit/acts/cpu.mjs';
+import { memoryLoop } from '../kit/acts/memory.mjs';
+import { prepare, switchTo } from '../kit/scenes.mjs';
+import { FS_STOREFRONT } from '../kit/set.mjs';
+
+const CHECKOUT = 'Checkout.fs';
+const SESSIONS = 'Sessions.fs';
+
+export default {
+  name: 'profiler-fsharp',
+  demo: FS_STOREFRONT,
+  narration: 'fsharp.narration.json',
+  poster: { scene: 'suspect', at: 6 },
+  scenes: [
+    { offCamera: prepare(CHECKOUT) },
+    ...cpuLoop(
+      {
+        file: CHECKOUT,
+        stills: 'profiler-fsharp',
+        captions: {
+          profile: 'Profile CPU on a running F# app',
+          heat: 'Stop: every hot F# line gets its share of the samples',
+          results: 'Hot functions keep their F# names, down to each pipeline stage',
+        },
+      },
+      1,
+    ),
+    { offCamera: switchTo(SESSIONS) },
+    ...memoryLoop(
+      {
+        file: SESSIONS,
+        type: 'FsStorefront.CustomerSession',
+        // A bounded window: the comment line is replaced; the eviction follows the store.
+        fix: [
+          { line: 5, text: '// Remembers the last 1,000 orders "for analytics", and forgets older ones.' },
+          { line: 10, append: true, text: '\n    sessions.Remove(order.Id - 1_000) |> ignore' },
+        ],
+        captions: {
+          track: 'Track Memory on the same app',
+          grow: 'Let it run: SharpLsp snapshots the heap every 10 seconds',
+          suspect: 'Records and union cases rank by growth. Click one to jump to the line that builds it',
+          graph: 'Ask what keeps it alive: SharpLsp: Show Reference Graph',
+          rooted: 'The root is the module value sessions, named as in your source',
+          fix: 'Fix it: keep the last 1,000 sessions and evict the rest',
+          retrack: 'Rebuild, run, and track memory again',
+          steady: 'The heap holds steady, and no suspect climbs past Low',
+        },
+        afterSuspect: (shot) => snap(shot, 'profiler-fsharp-leaks'),
+        atGraph: (shot) => snap(shot, 'profiler-fsharp-graph'),
+      },
+      4,
+    ),
+  ],
+};
diff --git a/src/website/tools/profiler-film/films/fsharp.narration.json b/src/website/tools/profiler-film/films/fsharp.narration.json
new file mode 100644
index 00000000..0827ef9b
--- /dev/null
+++ b/src/website/tools/profiler-film/films/fsharp.narration.json
@@ -0,0 +1,67 @@
+{
+  "voice": "af_heart",
+  "say": { "FsStorefront": "F S Storefront", "SharpLsp": "Sharp L S P", "F#": "F sharp" },
+  "music": { "en": "[Gentle music]", "ja": "[穏やかな音楽]", "zh": "[舒缓的音乐]" },
+  "lines": [
+    {
+      "scene": "profile",
+      "en": "This is FsStorefront, an F# app that's running right now. Let's find out where its time goes.",
+      "ja": "これは FsStorefront、いま実際に動いている F# アプリです。時間がどこに使われているのか見てみましょう。",
+      "zh": "这是 FsStorefront，一个正在运行的 F# 应用。我们来看看它的时间都花在了哪里。"
+    },
+    {
+      "scene": "heat",
+      "en": "Stop the profiler, and every hot line of F# lights up: the catalog parsing, the basket shuffle, and the discount fold.",
+      "ja": "プロファイラーを止めると、F# のホットな行がすべて光ります。カタログの解析、バスケットのシャッフル、そして割引の fold です。",
+      "zh": "停止性能分析器，F# 的每个热点行都会亮起：商品目录解析、购物篮洗牌，还有折扣 fold。"
+    },
+    {
+      "scene": "results",
+      "en": "The results keep the names the F# compiler gives your code. Every closure and pipeline stage is named after its line, so you know exactly where to look.",
+      "ja": "結果には、F# コンパイラーがコードに付けた名前がそのまま残ります。クロージャーもパイプラインのステージも行にちなんだ名前なので、どこを見ればいいかがすぐわかります。",
+      "zh": "结果保留了 F# 编译器给代码起的名字。每个闭包和管道阶段都以它所在的行命名，所以你清楚地知道该看哪里。"
+    },
+    {
+      "scene": "track",
+      "en": "Now let's track memory on the same app. SharpLsp snapshots the heap every ten seconds.",
+      "ja": "次は同じアプリのメモリを追跡しましょう。SharpLsp が 10 秒ごとにヒープのスナップショットを取ります。",
+      "zh": "现在来跟踪同一个应用的内存。SharpLsp 每十秒为堆拍一次快照。"
+    },
+    {
+      "scene": "suspect",
+      "en": "F# records and union cases show up as leak suspects. Click one, and you jump straight to the line that builds it.",
+      "ja": "F# のレコードと共用体ケースがリークの疑いとして現れます。クリックすると、それを組み立てる行に直接ジャンプします。",
+      "zh": "F# 记录和联合用例被列为可疑泄漏。点击其中一个，就能直接跳到构造它的那一行。"
+    },
+    {
+      "scene": "ask",
+      "en": "So, what's keeping them alive?",
+      "ja": "では、何がそれらを生かし続けているのでしょうか？",
+      "zh": "那么，是什么让它们一直存活？"
+    },
+    {
+      "scene": "graph",
+      "en": "A module value called sessions, named just as you wrote it. It holds every session the app has ever seen.",
+      "ja": "sessions というモジュール値です。書いたとおりの名前で示されます。アプリがこれまでに扱ったすべてのセッションを保持しています。",
+      "zh": "一个名为 sessions 的模块值，名称和你写的一模一样。它保存着应用见过的每一个会话。"
+    },
+    {
+      "scene": "fix",
+      "en": "The fix: keep the last thousand sessions, and let the rest go.",
+      "ja": "修正は、直近 1,000 件のセッションだけを残し、残りを手放すことです。",
+      "zh": "修复方法：只保留最近一千个会话，其余的放手。"
+    },
+    {
+      "scene": "retrack",
+      "en": "Rebuild, run it again, and track memory.",
+      "ja": "再ビルドして、もう一度実行し、メモリを追跡します。",
+      "zh": "重新构建，再次运行，然后跟踪内存。"
+    },
+    {
+      "scene": "steady",
+      "en": "This time the heap holds steady, and nothing climbs past Low. That's F# profiling in SharpLsp. Free, and open source.",
+      "ja": "今度はヒープが横ばいのまま、Low を超えるものはありません。これが SharpLsp の F# プロファイリングです。無料で、オープンソースです。",
+      "zh": "这一次，堆保持平稳，没有任何项超过 Low。这就是 SharpLsp 的 F# 性能分析。免费，而且开源。"
+    }
+  ]
+}
diff --git a/src/website/tools/profiler-film/films/leak.mjs b/src/website/tools/profiler-film/films/leak.mjs
new file mode 100644
index 00000000..f08d9c4f
--- /dev/null
+++ b/src/website/tools/profiler-film/films/leak.mjs
@@ -0,0 +1,50 @@
+// Implements [WEB-DESIGN-MEDIA]. The memory-leak walkthrough the "Fix a Memory
+// Leak" guide plays (`profiler-fix-memory-leak`): the C# Storefront demo's leak
+// followed to the static field that roots it, the fix typed in, the fixed build
+// tracked again.
+//
+//   node src/website/tools/profiler-film/film.mjs leak
+import { memoryLoop } from '../kit/acts/memory.mjs';
+import { prepare } from '../kit/scenes.mjs';
+import { STOREFRONT } from '../kit/set.mjs';
+
+const FILE = 'SessionCache.cs';
+
+export default {
+  name: 'profiler-fix-memory-leak',
+  demo: STOREFRONT,
+  poster: { scene: 'graph', at: 5 },
+  scenes: [
+    { offCamera: prepare(FILE) },
+    ...memoryLoop(
+      {
+        file: FILE,
+        type: 'Storefront.CustomerSession',
+        // Each entry replaces one line of SessionCache.cs.
+        fix: [
+          { line: 3, text: '// Remembers the last 1,000 orders "for analytics", and forgets older ones.' },
+          {
+            line: 8,
+            text: [
+              '    public static void Remember(Order order)',
+              '    {',
+              '        Sessions[order.Id] = new CustomerSession(order);',
+              '        Sessions.Remove(order.Id - 1_000);',
+              '    }',
+            ].join('\n'),
+          },
+        ],
+        captions: {
+          track: 'Track Memory on the process whose memory keeps climbing',
+          grow: 'Let it run: SharpLsp snapshots the heap every 10 seconds',
+          suspect: 'Suspects rank by consistent growth. Click one to jump to its code',
+          graph: 'Ask what keeps it alive: SharpLsp: Show Reference Graph',
+          fix: 'Fix it: keep a bounded window and evict the rest',
+          retrack: 'Rebuild, run, and track memory again',
+          steady: 'The heap holds steady, and no suspect climbs past Low',
+        },
+      },
+      1,
+    ),
+  ],
+};
diff --git a/src/website/tools/profiler-film/capture.mjs b/src/website/tools/profiler-film/films/profiler/capture.mjs
similarity index 59%
rename from src/website/tools/profiler-film/capture.mjs
rename to src/website/tools/profiler-film/films/profiler/capture.mjs
index 297a94dc..5a65e234 100644
--- a/src/website/tools/profiler-film/capture.mjs
+++ b/src/website/tools/profiler-film/films/profiler/capture.mjs
@@ -3,71 +3,47 @@
 // and real-time screencast clips, plus the click cues the film's cursor follows.
 //
 //   make _build-vsix VSIX_PREBUILT=1
-//   node src/website/tools/profiler-film/capture.mjs
+//   node src/website/tools/profiler-film/films/profiler/capture.mjs
 //
 // Output lands in tools/profiler-film/out/ (gitignored); render.mjs turns it into
 // the website's assets.
 import fs from 'node:fs';
 import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { launchVsCode, runCommand } from './vscode.mjs';
-import { captureFlameGraph } from './flamegraph.mjs';
+import { cpuStills } from '../../kit/acts/cpu.mjs';
+import { cueLog, record, still } from '../../kit/camera.mjs';
+import { runCommand } from '../../kit/editor.mjs';
+import { out } from '../../kit/encode.mjs';
+import { STOREFRONT, onSet } from '../../kit/set.mjs';
 import {
   PARK,
+  awaitResults,
   clickSharpLspIcon,
-  cueLog,
+  demoRow,
   headerButton,
   openFile,
-  record,
   rowButton,
   scrollDashboard,
   sleep,
-  stageStorefront,
-  still,
-  storefront,
-  storefrontRow,
-  toggleSideBar,
   trackMemory,
-  waitForStorefrontRow,
-} from './studio.mjs';
+  waitForDemoRow,
+} from '../../kit/workbench.mjs';
+import { captureFlameGraph } from './flamegraph.mjs';
 
-const here = path.dirname(fileURLToPath(import.meta.url));
-const out = path.join(here, 'out');
 const stills = path.join(out, 'stills');
 const clips = path.join(out, 'clips');
 const PROFILE_SECONDS = 10;
 const MEMORY_SECONDS = 26;
 
-/**
- * Toggle `title`'s editor group maximised by double-clicking its tab — no
- * palette, which a refreshing webview would close by stealing focus.
- */
-async function toggleMaximised(page, title) {
-  await page.locator('.tab', { hasText: title }).first().dblclick();
-  await sleep(1200);
-}
-
 async function cpuAct(page, cues) {
   await cues.click(page, await rowButton(page, 'Profile CPU'), 'Profile CPU');
   await sleep(7000);
   await still(page, stills, 'profiler-live');
   await sleep((PROFILE_SECONDS - 7) * 1000);
   await cues.click(page, await headerButton(page, 'Stop Profiling'), 'Stop Profiling');
-  await page.locator('.tab', { hasText: 'SharpLsp Profiler' }).waitFor({ timeout: 60_000 });
+  await awaitResults(page);
   await sleep(3500);
 }
 
-async function cpuStills(page) {
-  await toggleMaximised(page, 'SharpLsp Profiler');
-  await still(page, stills, 'profiler-results');
-  await toggleMaximised(page, 'SharpLsp Profiler');
-  await toggleMaximised(page, 'CheckoutPipeline.cs');
-  await toggleSideBar(page);
-  await still(page, stills, 'profiler-heatmap');
-  await toggleSideBar(page);
-  await toggleMaximised(page, 'CheckoutPipeline.cs');
-}
-
 async function memoryAct(page, cues) {
   await trackMemory(page, (locator, label) => cues.click(page, locator, label));
   await sleep(MEMORY_SECONDS * 1000);
@@ -86,9 +62,9 @@ async function prepare(page) {
   await clickSharpLspIcon(page);
   await openFile(page, 'CheckoutPipeline.cs');
   await sleep(15_000);
-  await waitForStorefrontRow(page);
+  await waitForDemoRow(page);
   await page.mouse.move(PARK.x, PARK.y);
-  await storefrontRow(page).hover();
+  await demoRow(page).hover();
   await sleep(600);
   await page.screenshot({ path: path.join(stills, 'profiler-processes.png') });
 }
@@ -97,12 +73,12 @@ async function shoot(page, cdp, app) {
   const set = { cdp, cues: cueLog(clips), frames: path.join(out, 'frames'), clips };
   await prepare(page);
   await record(set, 'cpu', () => cpuAct(page, set.cues));
-  await cpuStills(page);
+  await cpuStills(page, stills, 'CheckoutPipeline.cs', 'profiler');
   await runCommand(page, 'View: Close All Editors');
   await openFile(page, 'SessionCache.cs');
   app.stop();
   await app.start();
-  await waitForStorefrontRow(page);
+  await waitForDemoRow(page);
   await record(set, 'memory', () => memoryAct(page, set.cues));
   await memoryStills(page);
 }
@@ -110,21 +86,10 @@ async function shoot(page, cdp, app) {
 async function main() {
   fs.mkdirSync(stills, { recursive: true });
   fs.mkdirSync(clips, { recursive: true });
-  const { root, workspace } = stageStorefront();
-  const editor = await launchVsCode({ workspace });
-  const app = storefront(workspace);
-  await app.start();
-  try {
-    await shoot(editor.page, editor.cdp, app);
+  await onSet({ demo: STOREFRONT, out }, async ({ page, cdp, app, workspace }) => {
+    await shoot(page, cdp, app);
     await captureFlameGraph(path.join(workspace, '.sharplsp/profiles'), out);
-  } catch (error) {
-    await editor.page.screenshot({ path: path.join(out, 'failure.png') }).catch(() => undefined);
-    throw error;
-  } finally {
-    app.stop();
-    await editor.close();
-    fs.rmSync(root, { recursive: true, force: true });
-  }
+  });
 }
 
 await main();
diff --git a/src/website/tools/profiler-film/film.html b/src/website/tools/profiler-film/films/profiler/film.html
similarity index 94%
rename from src/website/tools/profiler-film/film.html
rename to src/website/tools/profiler-film/films/profiler/film.html
index 7fa3725f..05ac4afa 100644
--- a/src/website/tools/profiler-film/film.html
+++ b/src/website/tools/profiler-film/films/profiler/film.html
@@ -4,7 +4,7 @@
 <meta charset="utf-8">
 <title>SharpLsp Profiler film</title>
 <!-- The profiler film: every frame is a pure function of t (renderFrame), so
-     render.mjs can step it deterministically. Assets come from out/film/. -->
+     render.mjs can step it deterministically. Assets come from the tool's out/film/. -->
 <style>
   :root {
     --bg: #070a08;
@@ -74,7 +74,7 @@
   </div>
 
   <div class="layer center" id="title">
-    <img id="logo" src="../../src/assets/images/sharplsp-logo.svg" alt="">
+    <img id="logo" src="../../../../src/assets/images/sharplsp-logo.svg" alt="">
     <div class="wordmark">SharpLsp <span class="profiler">Profiler</span></div>
     <div class="sub" id="titleSub">CPU and memory profiling for .NET, inside VS Code.</div>
   </div>
@@ -85,12 +85,12 @@
 
   <div id="caption"><div class="eyebrow" id="eyebrow"></div><div class="headline" id="headline"></div></div>
   <div id="speed"></div>
-  <div id="mark"><img src="../../src/assets/images/sharplsp-logo.svg" alt="">SharpLsp</div>
+  <div id="mark"><img src="../../../../src/assets/images/sharplsp-logo.svg" alt="">SharpLsp</div>
   <div id="ripple"></div>
   <svg id="cursor" viewBox="0 0 24 24"><path d="M4 2l16 9.5-7 1.6 4.2 7.4-2.9 1.6-4.2-7.4L4 19z" fill="#fff" stroke="#111" stroke-width="1.2" stroke-linejoin="round"/></svg>
 
   <div class="layer center" id="end">
-    <img id="endLogo" src="../../src/assets/images/sharplsp-logo.svg" alt="" style="width:132px;height:132px;border-radius:28px">
+    <img id="endLogo" src="../../../../src/assets/images/sharplsp-logo.svg" alt="" style="width:132px;height:132px;border-radius:28px">
     <div class="wordmark" style="font-size:96px">Profile .NET where you code.</div>
     <div class="tagline">Free and open source. No license. No vendor lock-in.</div>
     <div class="url">sharplsp.dev</div>
diff --git a/src/website/tools/profiler-film/film.js b/src/website/tools/profiler-film/films/profiler/film.js
similarity index 99%
rename from src/website/tools/profiler-film/film.js
rename to src/website/tools/profiler-film/films/profiler/film.js
index 0c4839ce..7aa11bac 100644
--- a/src/website/tools/profiler-film/film.js
+++ b/src/website/tools/profiler-film/films/profiler/film.js
@@ -120,8 +120,8 @@ function show(img, src) {
   pending.push(img.decode().catch(() => undefined));
 }
 const clipFrame = (name, clipT) =>
-  `out/film/${name}/${String(clamp(Math.round(clipT * FPS) + 1, 1, DATA[name].frames)).padStart(5, '0')}.jpg`;
-const still = (name) => `out/stills/${name}.png`;
+  `../../out/film/${name}/${String(clamp(Math.round(clipT * FPS) + 1, 1, DATA[name].frames)).padStart(5, '0')}.jpg`;
+const still = (name) => `../../out/stills/${name}.png`;
 
 // ── Camera ──
 
diff --git a/src/website/tools/profiler-film/flamegraph.mjs b/src/website/tools/profiler-film/films/profiler/flamegraph.mjs
similarity index 100%
rename from src/website/tools/profiler-film/flamegraph.mjs
rename to src/website/tools/profiler-film/films/profiler/flamegraph.mjs
diff --git a/src/website/tools/profiler-film/render.mjs b/src/website/tools/profiler-film/films/profiler/render.mjs
similarity index 88%
rename from src/website/tools/profiler-film/render.mjs
rename to src/website/tools/profiler-film/films/profiler/render.mjs
index 3df62909..9ee5d6d1 100644
--- a/src/website/tools/profiler-film/render.mjs
+++ b/src/website/tools/profiler-film/films/profiler/render.mjs
@@ -3,17 +3,16 @@
 // to ffmpeg, then writes the site assets (film MP4/WebM + poster, the unedited
 // recordings + posters, WebP stills).
 //
-//   node src/website/tools/profiler-film/render.mjs
-//   node src/website/tools/profiler-film/render.mjs --preview 2,9.5,24   (stills of those seconds)
+//   node src/website/tools/profiler-film/films/profiler/render.mjs
+//   node src/website/tools/profiler-film/films/profiler/render.mjs --preview 2,9.5,24   (stills of those seconds)
 import { spawn } from 'node:child_process';
 import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { chromium } from '@playwright/test';
-import { H264, VP9, ffmpeg, out, poster, videos, webp } from './encode.mjs';
+import { H264, VP9, ffmpeg, out, poster, publishStills, videos } from '../../kit/encode.mjs';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-const shots = path.resolve(here, '../../src/assets/screenshots/profiler');
 const FPS = 30;
 const POSTER_AT = 25.5;
 
@@ -93,21 +92,15 @@ function publishRecordings() {
   poster(path.join(videos, 'profiler-memory-timelapse.mp4'), 14, 'profiler-memory-timelapse');
 }
 
-function publishStills() {
-  for (const file of fs.readdirSync(path.join(out, 'stills')).filter((name) => name.endsWith('.png'))) {
-    webp(path.join(out, 'stills', file), path.join(shots, file.replace(/\.png$/, '.webp')), 2400);
-  }
-}
-
 async function main() {
   const flag = process.argv.indexOf('--preview');
   if (flag > 0) return preview(process.argv[flag + 1].split(',').map(Number));
-  for (const dir of [videos, shots]) fs.mkdirSync(dir, { recursive: true });
+  fs.mkdirSync(videos, { recursive: true });
   const master = path.join(out, 'film-master.mp4');
   const duration = await renderMaster(master);
   publishFilm(master);
   publishRecordings();
-  publishStills();
+  publishStills(path.join(out, 'stills'));
   process.stdout.write(`rendered ${duration.toFixed(1)}s film and the profiler media\n`);
 }
 
diff --git a/src/website/tools/profiler-film/kit/acts/cpu.mjs b/src/website/tools/profiler-film/kit/acts/cpu.mjs
new file mode 100644
index 00000000..f83c4e16
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/acts/cpu.mjs
@@ -0,0 +1,61 @@
+// Implements [WEB-DESIGN-MEDIA]. The CPU act as scenes: profile the running
+// demo, let it sample (fast-forwarded), stop on the heat map, then read the
+// results panel. A film tells it in its own words (`story`), on its own file.
+import { still } from '../camera.mjs';
+import { caption, ringClick } from '../overlay.mjs';
+import { startOnRow } from '../scenes.mjs';
+import { awaitResults, headerButton, scrollDashboard, sleep, toggleMaximised, toggleSideBar } from '../workbench.mjs';
+
+const SAMPLE_SECONDS = 8;
+const RESULTS = 'SharpLsp Profiler';
+
+/**
+ * After a CPU stop: `<prefix>-results`, the results panel maximised, and
+ * `<prefix>-heatmap`, `file` maximised with its heat bars and no side bar.
+ */
+export async function cpuStills(page, dir, file, prefix) {
+  await toggleMaximised(page, RESULTS);
+  await still(page, dir, `${prefix}-results`);
+  await toggleMaximised(page, RESULTS);
+  await toggleMaximised(page, file);
+  await toggleSideBar(page);
+  await still(page, dir, `${prefix}-heatmap`);
+  await toggleSideBar(page);
+  await toggleMaximised(page, file);
+}
+
+async function heatScene({ page, set }, step, text) {
+  await caption(page, step, text);
+  await ringClick(page, set.cues, await headerButton(page, 'Stop Profiling'), 'Stop Profiling');
+  await awaitResults(page);
+  await sleep(6000);
+}
+
+async function resultsScene({ page }, step, text) {
+  await caption(page, step, text);
+  await sleep(2500);
+  await scrollDashboard(page, 700);
+  await sleep(5000);
+}
+
+/** Off camera: the results scrolled back up, then `<stills>` prefixed heat map and results stills. */
+const stillsStep = (story) => async (shot) => {
+  await scrollDashboard(shot.page, -8000);
+  await cpuStills(shot.page, shot.stills, story.file, story.stills);
+};
+
+/**
+ * The CPU act as scenes, its steps numbered from `first`. `story` names the
+ * `file` the heat map is shown on, each step's caption (`profile`, `heat`,
+ * `results`), and the `stills` prefix of its heat-map and results stills.
+ */
+export function cpuLoop(story, first) {
+  const { captions } = story;
+  return [
+    { clip: 'profile', retries: 3, act: startOnRow(first, captions.profile, 'Profile CPU', 'Profiling') },
+    { clip: 'sample', speed: 4, act: ({ page }) => caption(page, first, captions.profile, '4×').then(() => sleep(SAMPLE_SECONDS * 1000)) },
+    { clip: 'heat', act: (shot) => heatScene(shot, first + 1, captions.heat) },
+    { clip: 'results', act: (shot) => resultsScene(shot, first + 2, captions.results) },
+    ...(story.stills ? [{ offCamera: stillsStep(story) }] : []),
+  ];
+}
diff --git a/src/website/tools/profiler-film/kit/acts/memory.mjs b/src/website/tools/profiler-film/kit/acts/memory.mjs
new file mode 100644
index 00000000..224f7205
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/acts/memory.mjs
@@ -0,0 +1,153 @@
+// Implements [WEB-DESIGN-MEDIA]. The memory act as scenes: track the demo,
+// watch the heap grow, open a suspect, ask what keeps it alive, type the fix,
+// rebuild, and track the fixed build again. A film tells it in its own words
+// (`story`), on its own demo and file.
+import { runCommand } from '../editor.mjs';
+import { caption, ringClick } from '../overlay.mjs';
+import { startOnRow } from '../scenes.mjs';
+import { buildDemo } from '../set.mjs';
+import {
+  awaitDashboard,
+  clickSharpLspIcon,
+  headerButton,
+  openFile,
+  panel,
+  scrollDashboard,
+  sleep,
+  toggleMaximised,
+  typeAt,
+  waitForDemoRow,
+} from '../workbench.mjs';
+
+const GROW_SECONDS = 6;
+const VERIFY_SECONDS = 45;
+const GRAPH = 'Retention Graph';
+
+/** The status-bar progress of an auto-capture still talking to the target. */
+const capturing = (page) => page.locator('.statusbar', { hasText: 'Auto-capturing memory' });
+
+const tracking = (step, text) => startOnRow(step, text, 'Track Memory', 'Memory: tracking');
+
+/** Pick `type` from the types the latest snapshot reported; a take without it is shot again. */
+async function pickType(page, type) {
+  await page.locator('.quick-input-widget input').fill(type.split('.').at(-1));
+  await sleep(700);
+  if ((await page.locator('.quick-input-list .monaco-list-row', { hasText: type }).count()) === 0) {
+    await page.keyboard.press('Escape');
+    throw new Error(`${type} is not in the latest snapshot yet`);
+  }
+  await page.keyboard.press('Enter');
+}
+
+/**
+ * Off camera: restore the maximised graph, stop tracking, let any in-flight
+ * capture finish before the leaking app exits, and reopen a clean `file`.
+ */
+async function stopAndReopen({ page, app }, file) {
+  await toggleMaximised(page, GRAPH);
+  await clickSharpLspIcon(page);
+  await (await headerButton(page, 'Stop Memory Tracking')).click();
+  await capturing(page).waitFor({ state: 'detached', timeout: 60_000 });
+  app.stop();
+  await openFile(page, file);
+  await runCommand(page, 'File: Revert File');
+  await runCommand(page, 'View: Close All Editors');
+  await openFile(page, file);
+  await clickSharpLspIcon(page);
+  await page.locator('.monaco-editor .view-lines').first().click();
+}
+
+/** Off camera: build the fixed code and start it with the Processes view open. */
+async function relaunch({ page, app, workspace }) {
+  buildDemo(workspace);
+  await app.start();
+  await clickSharpLspIcon(page);
+  await waitForDemoRow(page);
+}
+
+/** Runs until the autopilot ranks a suspect High (three growths in a row), and long enough to watch the climb. */
+async function growScene(page, step, text) {
+  await caption(page, step, text, '8×');
+  await awaitDashboard(page);
+  const high = panel(page).locator('.leak-row .badge', { hasText: /high/i }).first();
+  await Promise.all([high.waitFor({ state: 'attached', timeout: 120_000 }), sleep(GROW_SECONDS * 1000)]);
+}
+
+async function suspectScene({ page, set }, step, story) {
+  await caption(page, step, story.captions.suspect);
+  await scrollDashboard(page, 8000);
+  await sleep(2500);
+  await ringClick(page, set.cues, panel(page).locator('.leak-row', { hasText: story.file }).first(), 'Suspect');
+  await sleep(3500);
+}
+
+async function askScene(page, step, text, type) {
+  await caption(page, step, text);
+  await capturing(page).waitFor({ state: 'detached', timeout: 60_000 });
+  await sleep(600);
+  await runCommand(page, 'SharpLsp: Show Reference Graph');
+  await pickType(page, type);
+}
+
+/** The walk over a live heap of a hundred megabytes takes a while: fast-forwarded. */
+async function walkScene(page, step, text) {
+  await caption(page, step, text, '8×');
+  await page.locator('.tab', { hasText: GRAPH }).waitFor({ timeout: 240_000 });
+  await sleep(1000);
+}
+
+/** The graph maximised, so its root and its rows read at a glance; `atGraph` runs once it is. */
+async function graphScene(shot, step, text, atGraph) {
+  await caption(shot.page, step, text);
+  await toggleMaximised(shot.page, GRAPH);
+  if (atGraph) await atGraph(shot);
+  await sleep(7000);
+}
+
+async function fixScene(page, step, story) {
+  await caption(page, step, story.captions.fix);
+  await sleep(2000);
+  for (const edit of story.fix) await typeAt(page, edit);
+  await page.keyboard.press('Meta+S');
+  await sleep(3000);
+}
+
+async function verifyScene(page, step, text) {
+  await caption(page, step, text, '8×');
+  await awaitDashboard(page);
+  await sleep(VERIFY_SECONDS * 1000);
+}
+
+async function steadyScene(page, step, text) {
+  await caption(page, step, text);
+  await sleep(2500);
+  await scrollDashboard(page, 8000);
+  await sleep(4000);
+}
+
+/**
+ * The memory act as scenes, its steps numbered from `first`. `story` names the
+ * `file` the fix goes in, the suspect's `type`, the `fix`'s edits (see typeAt)
+ * and each step's caption (`rooted`, over the drawn graph, defaults to the
+ * `graph` question), plus an off-camera `afterSuspect` step and an `atGraph`
+ * step that sees the graph maximised.
+ */
+export function memoryLoop(story, first) {
+  const step = (offset) => first + offset;
+  const { captions } = story;
+  return [
+    { clip: 'track', retries: 3, act: tracking(step(0), captions.track) },
+    { clip: 'grow', speed: 8, act: ({ page }) => growScene(page, step(1), captions.grow) },
+    { clip: 'suspect', act: (shot) => suspectScene(shot, step(2), story) },
+    ...(story.afterSuspect ? [{ offCamera: story.afterSuspect }] : []),
+    { clip: 'ask', retries: 5, act: ({ page }) => askScene(page, step(3), captions.graph, story.type) },
+    { clip: 'walk', speed: 8, act: ({ page }) => walkScene(page, step(3), captions.graph) },
+    { clip: 'graph', act: (shot) => graphScene(shot, step(3), captions.rooted ?? captions.graph, story.atGraph) },
+    { offCamera: (shot) => stopAndReopen(shot, story.file) },
+    { clip: 'fix', act: ({ page }) => fixScene(page, step(4), story) },
+    { offCamera: relaunch },
+    { clip: 'retrack', retries: 3, act: tracking(step(5), captions.retrack) },
+    { clip: 'verify', speed: 8, act: ({ page }) => verifyScene(page, step(5), captions.retrack) },
+    { clip: 'steady', act: ({ page }) => steadyScene(page, step(6), captions.steady) },
+  ];
+}
diff --git a/src/website/tools/profiler-film/kit/camera.mjs b/src/website/tools/profiler-film/kit/camera.mjs
new file mode 100644
index 00000000..6c1a9a0c
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/camera.mjs
@@ -0,0 +1,64 @@
+// Implements [WEB-DESIGN-MEDIA]. What a film records: real-time screencast clips,
+// the click cues a composited film's cursor follows, and clean stills.
+import fs from 'node:fs';
+import path from 'node:path';
+import { startScreencast } from './screencast.mjs';
+import { PARK, sleep } from './workbench.mjs';
+
+/** Click-cue log: where and when the (invisible) mouse acted, relative to a clip's start. */
+export function cueLog(clips) {
+  let start = Date.now();
+  const cues = [];
+  return {
+    restart: () => {
+      start = Date.now();
+      cues.length = 0;
+    },
+    async click(page, locator, label) {
+      const box = await locator.boundingBox();
+      if (box) cues.push({ t: (Date.now() - start) / 1000, x: box.x + box.width / 2, y: box.y + box.height / 2, label });
+      await locator.click({ force: true });
+      await page.waitForTimeout(350);
+      await page.mouse.move(PARK.x, PARK.y);
+    },
+    save: (name) => fs.writeFileSync(path.join(clips, `${name}.cues.json`), JSON.stringify(cues, null, 2)),
+  };
+}
+
+/**
+ * Record `act` as a real-time clip `<clips>/<name>.mp4`, its frames under `<frames>/<name>`.
+ * A failed act still ends the screencast, so the take can be shot again.
+ */
+export async function record({ cdp, cues, frames, clips }, name, act) {
+  cues.restart();
+  const stop = await startScreencast(cdp, path.join(frames, name));
+  const clip = path.join(clips, `${name}.mp4`);
+  try {
+    await act();
+  } catch (error) {
+    await stop(clip).catch(() => undefined);
+    throw error;
+  }
+  await stop(clip);
+  cues.save(name);
+}
+
+/** Show or hide the step caption, if a walkthrough has drawn one. */
+const showCaption = (page, shown) =>
+  page.evaluate((visibility) => document.getElementById('film-caption')?.style.setProperty('visibility', visibility), shown ? 'visible' : 'hidden');
+
+/**
+ * A clean frame `<dir>/<name>.png`: no hover, and the step caption hidden only
+ * for the instant of the shot (Do Not Disturb keeps toasts off screen).
+ */
+export async function still(page, dir, name) {
+  fs.mkdirSync(dir, { recursive: true });
+  await page.mouse.move(PARK.x, PARK.y);
+  await sleep(700);
+  await showCaption(page, false);
+  await page.screenshot({ path: path.join(dir, `${name}.png`) });
+  await showCaption(page, true);
+}
+
+/** A walkthrough's still, into the film's own stills folder; published as `<name>.webp`. */
+export const snap = (shot, name) => still(shot.page, shot.stills, name);
diff --git a/src/website/tools/profiler-film/vscode.mjs b/src/website/tools/profiler-film/kit/editor.mjs
similarity index 99%
rename from src/website/tools/profiler-film/vscode.mjs
rename to src/website/tools/profiler-film/kit/editor.mjs
index b67a3019..6ed0bee9 100644
--- a/src/website/tools/profiler-film/vscode.mjs
+++ b/src/website/tools/profiler-film/kit/editor.mjs
@@ -11,7 +11,7 @@ import { fileURLToPath } from 'node:url';
 import { chromium } from '@playwright/test';
 
 const here = path.dirname(fileURLToPath(import.meta.url));
-export const repoRoot = path.resolve(here, '../../../..');
+export const repoRoot = path.resolve(here, '../../../../..');
 const testHome = path.join(repoRoot, 'src/editors/vscode/.vscode-test');
 const vsix = path.join(repoRoot, 'dist/sharplsp.vsix');
 const RUNTIME_EXTENSION = 'ms-dotnettools.vscode-dotnet-runtime';
diff --git a/src/website/tools/profiler-film/encode.mjs b/src/website/tools/profiler-film/kit/encode.mjs
similarity index 53%
rename from src/website/tools/profiler-film/encode.mjs
rename to src/website/tools/profiler-film/kit/encode.mjs
index 9cd7df3f..a50fb4af 100644
--- a/src/website/tools/profiler-film/encode.mjs
+++ b/src/website/tools/profiler-film/kit/encode.mjs
@@ -1,18 +1,35 @@
 // Implements [WEB-DESIGN-MEDIA]. How every profiler video reaches the site: one
 // H.264 and one VP9 setting, a WebP poster per video, WebP stills.
 import { spawnSync } from 'node:child_process';
+import fs from 'node:fs';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
-const here = path.dirname(fileURLToPath(import.meta.url));
-export const out = path.join(here, 'out');
-export const videos = path.resolve(here, '../../src/assets/videos');
+const tool = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..');
+/** Every shoot's working files, gitignored: out/<film>/. */
+export const out = path.join(tool, 'out');
+export const videos = path.resolve(tool, '../../src/assets/videos');
+export const shots = path.resolve(tool, '../../src/assets/screenshots/profiler');
 
 /** H.264 for reach: every site video has an MP4. */
 export const H264 = ['-c:v', 'libx264', '-preset', 'veryslow', '-crf', '26', '-pix_fmt', 'yuv420p', '-movflags', '+faststart', '-an'];
 /** VP9 for size: the WebM a browser prefers when it can play it. */
 export const VP9 = ['-c:v', 'libvpx-vp9', '-crf', '40', '-b:v', '0', '-row-mt', '1', '-deadline', 'good', '-cpu-used', '2', '-an'];
 
+/** The narrated films' sound: AAC beside H.264, Opus beside VP9. */
+export const AAC = ['-c:a', 'aac', '-b:a', '160k'];
+export const OPUS = ['-c:a', 'libopus', '-b:a', '128k'];
+
+/** A video setting that keeps the soundtrack. */
+export const audible = (video) => video.filter((arg) => arg !== '-an');
+
+/** The length of `file` in seconds. */
+export function duration(file) {
+  const result = spawnSync('ffprobe', ['-v', 'error', '-show_entries', 'format=duration', '-of', 'csv=p=0', file], { encoding: 'utf8' });
+  if (result.status !== 0) throw new Error(`ffprobe ${file} failed: ${result.stderr}`);
+  return Number(result.stdout.trim());
+}
+
 export function ffmpeg(args, label) {
   const result = spawnSync('ffmpeg', ['-y', '-loglevel', 'error', ...args], { encoding: 'utf8' });
   if (result.status !== 0) throw new Error(`ffmpeg (${label}) failed: ${result.stderr}`);
@@ -29,3 +46,11 @@ export function poster(video, at, name) {
   ffmpeg(['-ss', String(at), '-i', video, '-frames:v', '1', frame], `${name} poster`);
   webp(frame, path.join(videos, `${name}-poster.webp`), 1920);
 }
+
+/** Every PNG still under `dir`, as the site's 2400px WebP of the same name. */
+export function publishStills(dir) {
+  fs.mkdirSync(shots, { recursive: true });
+  for (const file of fs.readdirSync(dir).filter((name) => name.endsWith('.png'))) {
+    webp(path.join(dir, file), path.join(shots, file.replace(/\.png$/, '.webp')), 2400);
+  }
+}
diff --git a/src/website/tools/profiler-film/overlay.mjs b/src/website/tools/profiler-film/kit/overlay.mjs
similarity index 98%
rename from src/website/tools/profiler-film/overlay.mjs
rename to src/website/tools/profiler-film/kit/overlay.mjs
index 6f8f2532..b185872a 100644
--- a/src/website/tools/profiler-film/overlay.mjs
+++ b/src/website/tools/profiler-film/kit/overlay.mjs
@@ -4,7 +4,7 @@
 // records them with the footage; nothing in the editor itself is staged.
 // The workbench enforces Trusted Types, so the overlay is built from nodes, CSSOM
 // styles and the Web Animations API: no HTML strings, no style sheets.
-import { PARK, sleep } from './studio.mjs';
+import { PARK, sleep } from './workbench.mjs';
 
 const BAR = {
   position: 'fixed', left: '72px', bottom: '40px', zIndex: '100000',
diff --git a/src/website/tools/profiler-film/kit/scenes.mjs b/src/website/tools/profiler-film/kit/scenes.mjs
new file mode 100644
index 00000000..4a0f9db8
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/scenes.mjs
@@ -0,0 +1,158 @@
+// Implements [WEB-DESIGN-MEDIA]. A walkthrough is a list of scenes. A scene is
+// either a clip, `{ clip, act, speed, retries }`, shot in real time and played
+// back at `speed`, or an `{ offCamera }` step between clips. shootWalkthrough
+// shoots the list on a demo's set; publishWalkthrough cuts the clips together,
+// lays a narrated film's voice, score and captions over the cut, and writes the
+// site's MP4, WebM and poster.
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { cueLog, record } from './camera.mjs';
+import { AAC, H264, OPUS, VP9, audible, duration, ffmpeg, poster, videos } from './encode.mjs';
+import { runCommand } from './editor.mjs';
+import { caption, ringClick } from './overlay.mjs';
+import { onSet } from './set.mjs';
+import { soundtrack } from './sound/soundtrack.mjs';
+import { writeCaptions } from './sound/voice.mjs';
+import { clickSharpLspIcon, demoRow, openFile, rowButton, sleep, waitForDemoRow } from './workbench.mjs';
+
+/**
+ * Workspace settings: snapshots every 10 seconds, the interval the guide
+ * recommends, so a reference walk never overlaps an auto-capture; and an editor
+ * that lets a fix be typed key by key, exactly as written.
+ */
+const WORKSPACE = {
+  'sharplsp.profiler.autoSnapshotInterval': 10,
+  'editor.autoClosingBrackets': 'never',
+  'editor.autoClosingQuotes': 'never',
+  'editor.autoSurround': 'never',
+  'editor.autoIndent': 'none',
+  'editor.formatOnType': false,
+  'editor.quickSuggestions': { other: 'off', comments: 'off', strings: 'off' },
+  'editor.suggestOnTriggerCharacters': false,
+  'editor.parameterHints.enabled': false,
+  'editor.inlineSuggest.enabled': false,
+  'editor.hover.enabled': false,
+};
+
+/**
+ * A scene that captions step `step` and clicks `action` on the live demo's row,
+ * then waits for the status bar to show `status`. Other processes come and go in
+ * the list, so a click that started nothing fails the take.
+ */
+export const startOnRow = (step, text, action, status) => async ({ page, set }) => {
+  await caption(page, step, text);
+  await demoRow(page).hover();
+  await sleep(2500);
+  await ringClick(page, set.cues, await rowButton(page, action), action);
+  await page.locator('.statusbar', { hasText: status }).waitFor({ timeout: 15_000 });
+  await sleep(1000);
+};
+
+/** Off camera: a fresh process, so an act starts from a small heap. */
+export async function restart({ page, app }) {
+  app.stop();
+  await app.start();
+  await waitForDemoRow(page);
+}
+
+/** Off camera: notifications silenced, the SharpLsp view open, `file` loaded, beside a fresh process. */
+export const prepare = (file) => async (shot) => {
+  await runCommand(shot.page, 'Notifications: Toggle Do Not Disturb Mode');
+  await clickSharpLspIcon(shot.page);
+  await openFile(shot.page, file);
+  await sleep(15_000);
+  await restart(shot);
+};
+
+/** Off camera: close every editor, open `file`, and restart the demo for the next act. */
+export const switchTo = (file) => async (shot) => {
+  await runCommand(shot.page, 'View: Close All Editors');
+  await openFile(shot.page, file);
+  await restart(shot);
+};
+
+/** Shoot a scene again when a refreshing dashboard closes its palette, or a type is not listed yet. */
+async function retried(attempts, shootScene) {
+  for (let attempt = 1; ; attempt++) {
+    try {
+      return await shootScene();
+    } catch (error) {
+      if (attempt >= attempts) throw error;
+      process.stdout.write(`retrying a take: ${error.message.split('\n')[0]}\n`);
+      await sleep(3500);
+    }
+  }
+}
+
+async function shootScenes(shot, scenes) {
+  for (const scene of scenes) {
+    if (scene.offCamera) await scene.offCamera(shot);
+    else await retried(scene.retries ?? 1, () => record(shot.set, scene.clip, () => scene.act(shot)));
+  }
+}
+
+/** Stage `demo`, open it in an isolated VS Code, and shoot `scenes` into `<out>/clips`, stills into `<out>/stills`. */
+export async function shootWalkthrough({ demo, out, scenes }) {
+  const clips = path.join(out, 'clips');
+  fs.mkdirSync(clips, { recursive: true });
+  await onSet({ demo, out, settings: WORKSPACE }, ({ page, cdp, app, workspace }) => {
+    const set = { cdp, cues: cueLog(clips), frames: path.join(out, 'frames'), clips };
+    return shootScenes({ page, set, app, workspace, stills: path.join(out, 'stills') }, scenes);
+  });
+}
+
+/** Each shot scene with its clip and its length on screen, in seconds, at its speed. */
+const shotsOf = (out, scenes) =>
+  scenes
+    .filter((scene) => scene.clip)
+    .map((scene) => {
+      const file = path.join(out, 'clips', `${scene.clip}.mp4`);
+      return { ...scene, file, length: duration(file) / (scene.speed ?? 1) };
+    });
+
+/** Cut the shots together at their speeds, each held on its last frame for its `hold`, into a lossless master. */
+function cut(shots, master) {
+  const inputs = shots.flatMap((shot) => ['-i', shot.file]);
+  const chains = shots.map(
+    (shot, i) => `[${i}:v]setpts=PTS/${shot.speed ?? 1},fps=30,scale=1920:-2:flags=lanczos,tpad=stop_mode=clone:stop_duration=${(shot.hold ?? 0).toFixed(3)}[v${i}]`,
+  );
+  const joined = `${shots.map((_, i) => `[v${i}]`).join('')}concat=n=${shots.length}:v=1:a=0[cut]`;
+  const lossless = ['-c:v', 'libx264', '-preset', 'slow', '-crf', '12', '-pix_fmt', 'yuv420p'];
+  ffmpeg([...inputs, '-filter_complex', `${chains.join(';')};${joined}`, '-map', '[cut]', ...lossless, master], path.basename(master));
+}
+
+/** The site's MP4 and WebM of the cut, with `audio` as their soundtrack when there is one. */
+function encodeFilm(name, out, shots, audio) {
+  const master = path.join(out, `${name}-master.mp4`);
+  cut(shots, master);
+  for (const [video, sound, extension] of [[H264, AAC, 'mp4'], [VP9, OPUS, 'webm']]) {
+    const inputs = audio ? ['-i', master, '-i', audio, '-map', '0:v', '-map', '1:a', ...audible(video), ...sound, '-shortest'] : ['-i', master, ...video];
+    ffmpeg([...inputs, path.join(videos, `${name}.${extension}`)], `${name} ${extension}`);
+  }
+}
+
+/** The narrated film: speech, score and captions laid over the cut, which holds each shot until its line is spoken. */
+async function narrated(name, out, shots, script) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), `${name}-sound-`));
+  try {
+    const film = await soundtrack(script, shots, dir);
+    encodeFilm(name, out, film.shots, film.audio);
+    writeCaptions(script, film.lines, videos, name);
+    return film.duration;
+  } finally {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+}
+
+/**
+ * Publish the MP4, the WebM and the poster; with a `narration` script, also its
+ * voice, score and captions. Resolves to the film's length in seconds.
+ */
+export async function publishWalkthrough({ name, out, scenes, posterAt, narration }) {
+  const shots = shotsOf(out, scenes);
+  const length = narration ? await narrated(name, out, shots, narration) : shots.reduce((total, shot) => total + shot.length, 0);
+  if (!narration) encodeFilm(name, out, shots);
+  poster(path.join(out, 'clips', `${posterAt.scene}.mp4`), posterAt.at, name);
+  return length;
+}
diff --git a/src/website/tools/profiler-film/screencast.mjs b/src/website/tools/profiler-film/kit/screencast.mjs
similarity index 100%
rename from src/website/tools/profiler-film/screencast.mjs
rename to src/website/tools/profiler-film/kit/screencast.mjs
diff --git a/src/website/tools/profiler-film/kit/set.mjs b/src/website/tools/profiler-film/kit/set.mjs
new file mode 100644
index 00000000..2a109cfc
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/set.mjs
@@ -0,0 +1,98 @@
+// Implements [WEB-DESIGN-MEDIA]. The set a film is shot on: a demo app from
+// demos/, staged and built at a neutral temp path and run beside an isolated
+// VS Code. Every film, whatever its story, is shot through onSet.
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { launchVsCode } from './editor.mjs';
+
+const demos = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../demos');
+
+/**
+ * The demo apps under demos/: a folder holding one project, run from its build
+ * output. The C# Storefront and its F# twin check out orders forever, with real
+ * hot paths and a cache that never evicts.
+ */
+export const STOREFRONT = { folder: 'storefront', project: 'Storefront' };
+export const FS_STOREFRONT = { folder: 'fs-storefront', project: 'FsStorefront' };
+
+/** Build the staged demo; a failed build stops the shoot. */
+export function buildDemo(workspace) {
+  const build = spawnSync('dotnet', ['build', '-c', 'Debug', '--nologo', '-v', 'q'], { cwd: workspace, encoding: 'utf8' });
+  if (build.status !== 0) throw new Error(`${path.basename(workspace)} build failed: ${build.stdout}`);
+}
+
+/**
+ * Copy `demo` to a neutral temp path and build it there, so no home-directory
+ * path (the user's name) can reach a frame name or tooltip on camera.
+ */
+export function stageDemo(demo) {
+  // The real path: macOS's tmpdir is a symlink the .NET runtime resolves, and
+  // heat-map decorations only land when both sides spell the file the same way.
+  const root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'film-'));
+  const workspace = path.join(root, demo.project);
+  fs.cpSync(path.join(demos, demo.folder), workspace, {
+    recursive: true,
+    filter: (source) => !['bin', 'obj', '.sharplsp'].includes(path.basename(source)),
+  });
+  buildDemo(workspace);
+  return { root, workspace };
+}
+
+/** Start the demo by absolute path (discovery needs it) and wait for its banner. */
+async function startDemo(workspace) {
+  const project = path.basename(workspace);
+  const app = spawn(path.join(workspace, `bin/Debug/net10.0/${project}`), [], { cwd: workspace, stdio: ['ignore', 'pipe', 'ignore'] });
+  await new Promise((resolve, reject) => {
+    app.stdout.once('data', resolve);
+    app.once('exit', (code) => reject(new Error(`${project} exited with ${code}`)));
+  });
+  return app;
+}
+
+/** The live demo's PID: its row, never a stale one from a restarted run. */
+let livePid = 0;
+
+export const demoPid = () => livePid;
+
+/** The staged demo app, restartable so a memory act starts from a fresh, small heap. */
+export function demoApp(workspace) {
+  let app;
+  return {
+    start: async () => {
+      app = await startDemo(workspace);
+      livePid = app.pid;
+    },
+    stop: () => app?.kill(),
+  };
+}
+
+function writeSettings(workspace, settings) {
+  fs.mkdirSync(path.join(workspace, '.vscode'), { recursive: true });
+  fs.writeFileSync(path.join(workspace, '.vscode/settings.json'), JSON.stringify(settings));
+}
+
+/**
+ * Stage `demo` with optional workspace `settings`, open it in an isolated VS Code
+ * beside the running app, and run `shoot({ page, cdp, app, workspace })`. A failed
+ * take leaves `<out>/failure.png`; the app, the editor and the staged copy always go.
+ */
+export async function onSet({ demo, out, settings }, shoot) {
+  const { root, workspace } = stageDemo(demo);
+  if (settings) writeSettings(workspace, settings);
+  const editor = await launchVsCode({ workspace });
+  const app = demoApp(workspace);
+  await app.start();
+  try {
+    await shoot({ page: editor.page, cdp: editor.cdp, app, workspace });
+  } catch (error) {
+    await editor.page.screenshot({ path: path.join(out, 'failure.png') }).catch(() => undefined);
+    throw error;
+  } finally {
+    app.stop();
+    await editor.close();
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+}
diff --git a/src/website/tools/profiler-film/kit/sound/score.mjs b/src/website/tools/profiler-film/kit/sound/score.mjs
new file mode 100644
index 00000000..98ff1137
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/sound/score.mjs
@@ -0,0 +1,137 @@
+// Implements [WEB-DESIGN-MEDIA]. An original score synthesised from code, so a film
+// carries no licensed or sampled music: a warm pad and bass on a two-bar chord
+// grid, felt-bell eighth notes once the story starts, and a shimmer that resolves
+// as the closing line begins. Stems are written as 16-bit PCM WAV.
+import { writeFile } from 'node:fs/promises';
+
+export const rate = 48_000;
+const tau = 2 * Math.PI;
+const tuning = { pitch: 440, note: 69, octave: 12, cents: 1_200 };
+const beat = 60 / 76;
+const eighth = beat / 2;
+const bar = 4 * beat;
+/** C major: Cmaj9, Am9, Fmaj9 and G sus, two bars each, resolving to Cmaj9. The first note is the bass. */
+const progression = [[36, 52, 55, 59, 62, 64], [33, 52, 55, 59, 60, 64], [41, 52, 57, 60, 64, 67], [31, 50, 55, 57, 60, 62]];
+const resolution = [36, 52, 55, 59, 62, 67];
+const pad = { detune: [-7, 0, 7], pan: [-0.6, 0, 0.6], weights: harmonics(6, 1.7), attack: 1.4, release: 1.8, level: 0.05, bars: 2 };
+const bass = { weights: harmonics(3, 1.2), level: 0.07 };
+const bell = { partials: [[1, 1, 1.1], [2, 0.3, 0.5], [3, 0.1, 0.25]], attack: 0.004, life: 4, level: 0.09, pan: 0.35,
+  pattern: [0, 2, 4, 3, 1, 3, 2, 4], offbeat: 0.65, octave: 12, strum: 0.08, ring: 2.5, entry: 2 };
+const master = { fadeIn: 1.2, fadeOut: 2.4, drive: 1.4, peak: 0.89 };
+const space = { length: 2.6, decay: 0.6, preDelay: 0.018, stretch: 12.9898, seed: 78.233, scale: 43_758.5453 };
+const pcm = { format: 1, width: Int16Array.BYTES_PER_ELEMENT, full: 32_767, chunk: 16, bitsPerByte: 8 };
+const sides = [-1, 1];
+const ratios = pad.detune.map((cents) => 2 ** (cents / tuning.cents));
+
+function harmonics(count, rolloff) {
+  return Array.from({ length: count }, (_, index) => 1 / (index + 1) ** rolloff);
+}
+
+const pitch = (note) => tuning.pitch * 2 ** ((note - tuning.note) / tuning.octave);
+const smooth = (x) => x * x * (3 - 2 * x);
+const clamp = (x) => Math.min(1, Math.max(0, x));
+const gain = (pan, side) => (1 + pan * side) / 2;
+const alternate = (step) => (step % 2 === 0 ? 1 : -1);
+
+const timbre = (frequency, t, weights) =>
+  weights.reduce((sum, weight, index) => sum + weight * Math.sin(tau * frequency * (index + 1) * t), 0);
+
+const swell = (t, section) => smooth(clamp((t - section.start) / pad.attack)) * smooth(clamp(1 - (t - section.end) / pad.release));
+
+function chord(section, t, side) {
+  const voices = (frequency) => ratios.reduce((sum, ratio, index) => sum + gain(pad.pan[index], side) * timbre(frequency * ratio, t, pad.weights), 0);
+  return section.pad.reduce((sum, frequency) => sum + voices(frequency), 0) * pad.level + timbre(section.bass, t, bass.weights) * bass.level;
+}
+
+const section = ([root, ...upper], start, end) => ({ start, end, bass: pitch(root), pad: upper.map(pitch), upper });
+
+/** The chord grid up to the closing line, then the resolution held to the end. */
+function sections({ resolve, duration }) {
+  const length = pad.bars * bar;
+  const count = Math.max(1, Math.round(resolve / length));
+  const span = resolve / count;
+  const grid = Array.from({ length: count }, (_, index) => section(progression[index % progression.length], index * span, (index + 1) * span));
+  return [...grid, section(resolution, resolve, duration + pad.release)];
+}
+
+/** Felt-bell eighth notes from the second chord until the closing line. */
+function arpeggio(chords, { resolve }) {
+  const start = chords[Math.min(bell.entry - 1, chords.length - 1)].start;
+  return Array.from({ length: Math.max(0, Math.floor((resolve - start) / eighth)) }, (_, step) => {
+    const time = start + step * eighth;
+    const note = chords.findLast((item) => item.start <= time).upper[bell.pattern[step % bell.pattern.length]];
+    return { time, frequency: pitch(note + bell.octave), level: bell.level * (step % 2 === 0 ? 1 : bell.offbeat), pan: alternate(step) * bell.pan, ring: 1 };
+  });
+}
+
+const shimmer = (chords, { resolve }) =>
+  chords.at(-1).upper.map((note, index) => ({ time: resolve + index * bell.strum, frequency: pitch(note + bell.octave), level: bell.level, pan: alternate(index) * bell.pan, ring: bell.ring }));
+
+function strike(event, t, side) {
+  const age = t - event.time;
+  const body = bell.partials.reduce((sum, [ratio, level, decay]) => sum + level * Math.exp(-age / (decay * event.ring)) * Math.sin(tau * event.frequency * ratio * age), 0);
+  return body * Math.min(1, age / bell.attack) * event.level * gain(event.pan, side);
+}
+
+const ringing = (events, t, side) =>
+  events.reduce((sum, event) => (t >= event.time && t < event.time + bell.life * event.ring ? sum + strike(event, t, side) : sum), 0);
+
+function sample(score, t, side) {
+  const harmony = score.chords.reduce((sum, item) => {
+    const level = swell(t, item);
+    return level > 0 ? sum + level * chord(item, t, side) : sum;
+  }, 0);
+  const fade = smooth(clamp(t / master.fadeIn)) * smooth(clamp((score.duration - t) / master.fadeOut));
+  return Math.tanh(master.drive * (harmony + ringing(score.bells, t, side))) * fade;
+}
+
+/** The stereo score for a film of `duration` seconds whose closing line starts at `resolve`. */
+export function compose(timeline) {
+  const chords = sections(timeline);
+  const score = { duration: timeline.duration, chords, bells: [...arpeggio(chords, timeline), ...shimmer(chords, timeline)] };
+  const frames = Math.round(timeline.duration * rate);
+  return sides.map((side) => Float32Array.from({ length: frames }, (_, index) => sample(score, index / rate, side)));
+}
+
+function noise(index, seed) {
+  const value = Math.sin(index * space.stretch + seed * space.seed) * space.scale;
+  return 2 * (value - Math.floor(value)) - 1;
+}
+
+/** A decaying stereo noise impulse response: a small, warm room for the score. */
+export function room() {
+  const frames = Math.round(space.length * rate);
+  return sides.map((side) =>
+    Float32Array.from({ length: frames }, (_, index) => {
+      const t = index / rate - space.preDelay;
+      return t < 0 ? 0 : noise(index, side) * Math.exp(-t / space.decay);
+    }),
+  );
+}
+
+const ascii = (value) => Buffer.from(value, 'ascii');
+
+function unsigned(value, width) {
+  const field = Buffer.alloc(width);
+  field.writeUIntLE(value, 0, width);
+  return field;
+}
+
+function header(count, sampleRate, bytes) {
+  const block = count * pcm.width;
+  const [short, long] = [Uint16Array.BYTES_PER_ELEMENT, Uint32Array.BYTES_PER_ELEMENT];
+  const body = Buffer.concat([ascii('WAVE'), ascii('fmt '), unsigned(pcm.chunk, long), unsigned(pcm.format, short), unsigned(count, short),
+    unsigned(sampleRate, long), unsigned(sampleRate * block, long), unsigned(block, short), unsigned(pcm.width * pcm.bitsPerByte, short),
+    ascii('data'), unsigned(bytes, long)]);
+  return Buffer.concat([ascii('RIFF'), unsigned(body.length + bytes, long), body]);
+}
+
+/** Writes 16-bit PCM, peak-normalised so every stem reaches the mix at the same headroom. */
+export async function wav(path, channels, sampleRate = rate) {
+  const peak = channels.reduce((top, samples) => samples.reduce((most, value) => Math.max(most, Math.abs(value)), top), 0);
+  const scale = peak > 0 ? (master.peak * pcm.full) / peak : 0;
+  const count = channels.length;
+  const samples = Int16Array.from({ length: channels[0].length * count }, (_, index) => Math.round(channels[index % count][Math.floor(index / count)] * scale));
+  const data = Buffer.from(samples.buffer);
+  await writeFile(path, Buffer.concat([header(count, sampleRate, data.length), data]));
+}
diff --git a/src/website/tools/profiler-film/kit/sound/soundtrack.mjs b/src/website/tools/profiler-film/kit/sound/soundtrack.mjs
new file mode 100644
index 00000000..df86a1b2
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/sound/soundtrack.mjs
@@ -0,0 +1,61 @@
+// Implements [WEB-DESIGN-MEDIA]. A narrated film's soundtrack: each spoken line
+// starts just after its scene's cut, a scene holds its last frame until its line
+// has finished, and the original score ducks under the voice.
+import { execFileSync } from 'node:child_process';
+import path from 'node:path';
+import { compose, rate, room, wav } from './score.mjs';
+import { pacing, speak } from './voice.mjs';
+
+const sound = {
+  voice: 'highpass=f=70,acompressor=threshold=0.1:ratio=3:attack=5:release=120:makeup=2',
+  music: 'highpass=f=40,equalizer=f=280:t=q:w=1.2:g=-3,volume=0.2',
+  wet: 0.35,
+  duck: 'threshold=0.03:ratio=5:attack=40:release=500',
+  gain: 1.15,
+  limit: 0.84,
+  /** Web loudness: -16 LUFS integrated, true peak under -1.5 dBTP. */
+  loudness: 'loudnorm=I=-16:TP=-1.5:LRA=11',
+};
+
+/** Place `spoken` after the scene's cut and after the line before it; returns the placed lines. */
+function placeLines(spoken, cut, lead, before) {
+  return spoken.reduce((lines, line) => {
+    const start = Math.max(cut + lead, ((lines.at(-1) ?? before)?.end ?? 0) + pacing.gap);
+    return [...lines, { ...line, start, end: start + line.length }];
+  }, []);
+}
+
+/** Each shot gets the `hold` its lines need; returns the shots, the placed lines and the film's length. */
+export function timeline(shots, takes) {
+  return shots.reduce(
+    (film, shot, index) => {
+      const lead = index === 0 ? pacing.opening : pacing.lead;
+      const placed = placeLines(takes.filter((line) => line.scene === shot.clip), film.duration, lead, film.lines.at(-1));
+      const tail = index === shots.length - 1 ? pacing.closing : pacing.tail;
+      const hold = Math.max(0, (placed.at(-1)?.end ?? 0) + tail - (film.duration + shot.length));
+      return { shots: [...film.shots, { ...shot, hold }], lines: [...film.lines, ...placed], duration: film.duration + shot.length + hold };
+    },
+    { shots: [], lines: [], duration: 0 },
+  );
+}
+
+/** Inputs: 0 is the score, 1 its room, then one per spoken line. The score ducks under the voice. */
+function mix(lines, duration) {
+  const voices = lines.map((line, i) => `[${i + 2}:a]aresample=${rate},adelay=${Math.round(line.start * 1000)}:all=1[v${i}]`).join(';');
+  const labels = lines.map((_, i) => `[v${i}]`).join('');
+  const voice = `${labels}amix=inputs=${lines.length}:normalize=0,${sound.voice},aformat=channel_layouts=stereo,asplit[voice][trigger];[trigger]apad[key]`;
+  const bed = `[0:a]asplit[dry][send];[send][1:a]afir[wet];[dry][wet]amix=inputs=2:weights=1 ${sound.wet}:normalize=0,${sound.music}[bed]`;
+  const master = `[voice][ducked]amix=inputs=2:normalize=0,volume=${sound.gain},alimiter=limit=${sound.limit}:level=0,${sound.loudness},aresample=${rate},atrim=end=${duration}[mix]`;
+  return `${voices};${voice};${bed};[bed][key]sidechaincompress=${sound.duck}[ducked];${master}`;
+}
+
+/** Speak `script`, score the film around it and mix both into `<dir>/soundtrack.wav`. */
+export async function soundtrack(script, shots, dir) {
+  const film = timeline(shots, await speak(script, dir));
+  const [score, space, output] = ['score', 'room', 'soundtrack'].map((name) => path.join(dir, `${name}.wav`));
+  await wav(score, compose({ resolve: film.lines.at(-1).start, duration: film.duration }));
+  await wav(space, room());
+  const inputs = [score, space, ...film.lines.map((line) => line.path)].flatMap((file) => ['-i', file]);
+  execFileSync('ffmpeg', ['-y', '-v', 'error', ...inputs, '-filter_complex', mix(film.lines, film.duration), '-map', '[mix]', output], { stdio: 'inherit' });
+  return { ...film, audio: output };
+}
diff --git a/src/website/tools/profiler-film/kit/sound/voice.mjs b/src/website/tools/profiler-film/kit/sound/voice.mjs
new file mode 100644
index 00000000..68673194
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/sound/voice.mjs
@@ -0,0 +1,52 @@
+// Implements [WEB-DESIGN-MEDIA]. A local voice model speaks a film's reviewed
+// narration, and the captions follow the measured speech in every site language.
+// Nothing leaves this machine: kokoro-js runs Kokoro-82M (Apache-2.0) on the CPU.
+import fs from 'node:fs';
+import path from 'node:path';
+import { KokoroTTS } from 'kokoro-js';
+import { wav } from './score.mjs';
+
+const model = { id: 'onnx-community/Kokoro-82M-v1.0-ONNX', dtype: 'fp32', device: 'cpu', silence: 0.01 };
+export const pacing = { opening: 1.2, lead: 0.35, gap: 0.4, tail: 0.5, hold: 0.3, closing: 2.5 };
+const clock = { minute: 60, digits: 3, minuteWidth: 2, secondWidth: 6 };
+
+function trim(samples) {
+  const audible = (value) => Math.abs(value) > model.silence;
+  return samples.slice(samples.findIndex(audible), samples.findLastIndex(audible) + 1);
+}
+
+/** The line as spoken: each `say` word in the script replaced by how it should sound. */
+const spoken = (script, text) => Object.entries(script.say).reduce((words, [word, sound]) => words.replaceAll(word, sound), text);
+
+/** Speak one line into `file`. */
+async function take(tts, script, line, file) {
+  const speech = await tts.generate(spoken(script, line.en), { voice: script.voice });
+  const samples = trim(speech.audio);
+  await wav(file, [samples], speech.sampling_rate);
+  return { ...line, path: file, length: samples.length / speech.sampling_rate };
+}
+
+/** Every line of `script` spoken into `dir`, in order: `{ scene, en, ja, zh, path, length }`. */
+export async function speak(script, dir) {
+  const tts = await KokoroTTS.from_pretrained(model.id, { dtype: model.dtype, device: model.device });
+  const takes = [];
+  for (const [index, line] of script.lines.entries()) takes.push(await take(tts, script, line, path.join(dir, `line${index}.wav`)));
+  return takes;
+}
+
+function stamp(seconds) {
+  const minutes = String(Math.floor(seconds / clock.minute)).padStart(clock.minuteWidth, '0');
+  return `${minutes}:${(seconds % clock.minute).toFixed(clock.digits).padStart(clock.secondWidth, '0')}`;
+}
+
+/** One WebVTT cue per spoken line in `lang`; the first also names the music that opens the film. */
+export function captions(script, lines, lang) {
+  const cue = (line, index) =>
+    [`${stamp(index === 0 ? 0 : line.start)} --> ${stamp(line.end + pacing.hold)}`, ...(index === 0 ? [script.music[lang]] : []), line[lang]].join('\n');
+  return `${['WEBVTT', ...lines.map(cue)].join('\n\n')}\n`;
+}
+
+/** `<name>.<lang>.vtt` beside the video, for each language the script is written in. */
+export function writeCaptions(script, lines, videos, name) {
+  for (const lang of Object.keys(script.music)) fs.writeFileSync(path.join(videos, `${name}.${lang}.vtt`), captions(script, lines, lang));
+}
diff --git a/src/website/tools/profiler-film/kit/workbench.mjs b/src/website/tools/profiler-film/kit/workbench.mjs
new file mode 100644
index 00000000..23a3063f
--- /dev/null
+++ b/src/website/tools/profiler-film/kit/workbench.mjs
@@ -0,0 +1,123 @@
+// Implements [WEB-DESIGN-MEDIA]. Moves in the isolated VS Code a film is shot
+// in: the SharpLsp Processes view and its demo row, editor groups, panels and
+// typing. Nothing here is staged; every move is a real click or keystroke.
+import { runCommand } from './editor.mjs';
+import { demoPid } from './set.mjs';
+
+/** Where the mouse rests between actions: empty title bar, hovering nothing. */
+export const PARK = { x: 1450, y: 22 };
+
+export const DASHBOARD = 'SharpLsp Memory Dashboard';
+
+export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+
+/** The frame inside a webview panel (the memory dashboard, the CPU results). */
+export const panel = (page) => page.frameLocator('iframe.webview').first().frameLocator('#active-frame');
+
+const processesHeader = (page) => page.locator('.pane-header', { hasText: 'Processes' });
+
+export const demoRow = (page) => page.getByRole('treeitem').filter({ hasText: new RegExp(`PID ${demoPid()}(?!\\d)`) }).first();
+
+export async function headerButton(page, name) {
+  await processesHeader(page).hover();
+  return processesHeader(page).getByRole('button', { name: new RegExp(`^${name}`) });
+}
+
+export async function rowButton(page, name) {
+  await demoRow(page).hover();
+  await sleep(250);
+  return demoRow(page).getByRole('button', { name: new RegExp(`^${name}`) });
+}
+
+/** Wait until the Processes view lists the live demo's row. */
+export async function waitForDemoRow(page) {
+  for (let attempt = 0; attempt < 30; attempt++) {
+    if (await demoRow(page).isVisible().catch(() => false)) return;
+    await (await headerButton(page, 'Refresh Processes')).click();
+    await sleep(1000);
+  }
+  throw new Error(`PID ${demoPid()} never appeared in the Processes view`);
+}
+
+/**
+ * Click the SharpLsp activity-bar icon. It opens the SharpLsp view; on the view
+ * already open it folds the side bar away. That is how a memory act hides it:
+ * the dashboard webview refreshes on every auto-snapshot and would close a
+ * palette, and the native menu owns Cmd+B, so a synthetic key never reaches it.
+ */
+export async function clickSharpLspIcon(page) {
+  await page.locator('.activitybar a[aria-label^="SharpLsp"]').first().click({ force: true });
+  await sleep(900);
+}
+
+export async function openFile(page, name) {
+  await page.keyboard.press('Meta+P');
+  await page.locator('.quick-input-widget input').fill(name);
+  await sleep(700);
+  await page.keyboard.press('Enter');
+  await sleep(1200);
+}
+
+/** Scroll the panel on the right of the editor (the dashboard or the results). */
+export async function scrollDashboard(page, pixels) {
+  await page.mouse.move(1300, 600);
+  await page.mouse.wheel(0, pixels);
+  await sleep(1200);
+}
+
+/**
+ * Start memory tracking on the demo's row and fold the side bar once the
+ * dashboard opens. `click(locator, label)` is the act's own way of clicking.
+ */
+export async function trackMemory(page, click) {
+  await click(await rowButton(page, 'Track Memory'), 'Track Memory');
+  await awaitDashboard(page);
+}
+
+/** Wait for the memory dashboard to open, then fold the side bar away from it. */
+export async function awaitDashboard(page) {
+  await page.locator('.tab', { hasText: DASHBOARD }).waitFor({ timeout: 60_000 });
+  await sleep(1500);
+  await clickSharpLspIcon(page);
+  await page.mouse.move(PARK.x, PARK.y);
+}
+
+/** Wait for the CPU results panel that a stop opens. */
+export const awaitResults = (page) => page.locator('.tab', { hasText: 'SharpLsp Profiler' }).waitFor({ timeout: 60_000 });
+
+/** How many editor groups are on screen: one while a group is maximised. */
+const shownGroups = (page) =>
+  page.locator('.part.editor .editor-group-container').evaluateAll((groups) => groups.filter((group) => group.offsetWidth > 0).length);
+
+/**
+ * Toggle `title`'s editor group maximised by double-clicking its tab — no
+ * palette, which a refreshing webview would close by stealing focus. A webview
+ * can swallow the double-click, so the toggle is checked and tried again.
+ */
+export async function toggleMaximised(page, title) {
+  const before = await shownGroups(page);
+  for (let attempt = 0; attempt < 3; attempt++) {
+    await page.locator('.tab', { hasText: title }).first().dblclick();
+    await sleep(1200);
+    if ((await shownGroups(page)) !== before) return;
+  }
+  throw new Error(`${title}'s editor group never toggled`);
+}
+
+export async function toggleSideBar(page) {
+  await runCommand(page, 'View: Toggle Primary Side Bar Visibility');
+  await sleep(800);
+}
+
+/** Go to `line` and type `text` over it, or after its end when the edit appends; key by key, as a person types. */
+export async function typeAt(page, { line, text, append = false }) {
+  await page.keyboard.press('Control+G');
+  await page.locator('.quick-input-widget input').fill(`:${line}`);
+  await page.keyboard.press('Enter');
+  await page.keyboard.press(append ? 'End' : 'Shift+End');
+  for (const [index, part] of text.split('\n').entries()) {
+    // Escape first: an editor widget left open would take the Enter instead of the line break.
+    if (index > 0) for (const key of ['Escape', 'Enter']) await page.keyboard.press(key);
+    await page.keyboard.type(part, { delay: 28 });
+  }
+}
diff --git a/src/website/tools/profiler-film/leak.mjs b/src/website/tools/profiler-film/leak.mjs
deleted file mode 100644
index 77eca62d..00000000
--- a/src/website/tools/profiler-film/leak.mjs
+++ /dev/null
@@ -1,286 +0,0 @@
-// Implements [WEB-DESIGN-MEDIA]. Shoots and publishes the memory-leak walkthrough
-// the "Fix a Memory Leak" guide plays: a real, isolated VS Code with the packaged
-// SharpLsp VSIX finds the Storefront demo's leak, follows it to the static field
-// that roots it, types the fix, rebuilds, and tracks the fixed build again.
-//
-//   make _build-vsix VSIX_PREBUILT=1
-//   node src/website/tools/profiler-film/leak.mjs              (shoot, then publish)
-//   node src/website/tools/profiler-film/leak.mjs --publish    (publish the last shoot)
-//
-// Clips land in tools/profiler-film/out/leak/ (gitignored). Every stretch the
-// published video fast-forwards carries a speed badge on screen.
-import fs from 'node:fs';
-import path from 'node:path';
-import { launchVsCode, runCommand } from './vscode.mjs';
-import { caption, ringClick } from './overlay.mjs';
-import { H264, VP9, ffmpeg, out as filmOut, poster, videos } from './encode.mjs';
-import {
-  awaitDashboard,
-  buildStorefront,
-  clickSharpLspIcon,
-  cueLog,
-  headerButton,
-  openFile,
-  record,
-  rowButton,
-  scrollDashboard,
-  sleep,
-  stageStorefront,
-  storefront,
-  storefrontRow,
-  waitForStorefrontRow,
-} from './studio.mjs';
-
-const out = path.join(filmOut, 'leak');
-const clips = path.join(out, 'clips');
-const NAME = 'profiler-fix-memory-leak';
-const GROW_SECONDS = 6;
-const VERIFY_SECONDS = 45;
-
-/** Each clip, in order, and its playback speed in the published video. */
-const SCENES = [
-  ['track', 1], ['grow', 8], ['suspect', 1], ['ask', 1], ['walk', 8], ['graph', 1],
-  ['fix', 1], ['retrack', 1], ['verify', 8], ['steady', 1],
-];
-const POSTER = { scene: 'graph', at: 5 };
-
-/**
- * Workspace settings: snapshots every 10 seconds, the interval the guide
- * recommends, so a reference walk never overlaps an auto-capture; and an editor
- * that lets the fix be typed key by key, exactly as written.
- */
-const WORKSPACE = {
-  'sharplsp.profiler.autoSnapshotInterval': 10,
-  'editor.autoClosingBrackets': 'never',
-  'editor.autoClosingQuotes': 'never',
-  'editor.autoSurround': 'never',
-  'editor.autoIndent': 'none',
-  'editor.formatOnType': false,
-  'editor.quickSuggestions': { other: 'off', comments: 'off', strings: 'off' },
-  'editor.suggestOnTriggerCharacters': false,
-  'editor.parameterHints.enabled': false,
-  'editor.inlineSuggest.enabled': false,
-  'editor.hover.enabled': false,
-};
-
-/** The fix: each entry replaces one line of SessionCache.cs. */
-const FIX = [
-  { line: 3, text: '// Remembers the last 1,000 orders "for analytics", and forgets older ones.' },
-  {
-    line: 8,
-    text: [
-      '    public static void Remember(Order order)',
-      '    {',
-      '        Sessions[order.Id] = new CustomerSession(order);',
-      '        Sessions.Remove(order.Id - 1_000);',
-      '    }',
-    ].join('\n'),
-  },
-];
-
-const dashboard = (page) => page.frameLocator('iframe.webview').first().frameLocator('#active-frame');
-
-/**
- * Hover the live Storefront row so its memory shows, then click Track Memory.
- * Other processes come and go in the list, so a click that started nothing
- * fails the take.
- */
-async function startTracking(page, cues) {
-  await storefrontRow(page).hover();
-  await sleep(2500);
-  await ringClick(page, cues, await rowButton(page, 'Track Memory'), 'Track Memory');
-  await page.locator('.statusbar', { hasText: 'Memory: tracking' }).waitFor({ timeout: 15_000 });
-  await sleep(1000);
-}
-
-async function trackScene(page, cues) {
-  await caption(page, 1, 'Track Memory on the process whose memory keeps climbing');
-  await startTracking(page, cues);
-}
-
-/** Runs until the autopilot ranks a suspect High (three growths in a row), and long enough to watch the climb. */
-async function growScene(page) {
-  await caption(page, 2, 'Let it run: SharpLsp snapshots the heap every 10 seconds', '8×');
-  await awaitDashboard(page);
-  const high = dashboard(page).locator('.leak-row .badge', { hasText: /high/i }).first();
-  await Promise.all([high.waitFor({ state: 'attached', timeout: 120_000 }), sleep(GROW_SECONDS * 1000)]);
-}
-
-async function suspectScene(page, cues) {
-  await caption(page, 3, 'Suspects rank by consistent growth. Click one to jump to its code');
-  await scrollDashboard(page, 8000);
-  await sleep(2500);
-  await ringClick(page, cues, dashboard(page).locator('.leak-row', { hasText: 'SessionCache.cs' }).first(), 'Suspect');
-  await sleep(3500);
-}
-
-/** Pick `type` from the types the latest snapshot reported; a take without it is shot again. */
-async function pickType(page, type) {
-  await page.locator('.quick-input-widget input').fill(type.split('.').at(-1));
-  await sleep(700);
-  if ((await page.locator('.quick-input-list .monaco-list-row', { hasText: type }).count()) === 0) {
-    await page.keyboard.press('Escape');
-    throw new Error(`${type} is not in the latest snapshot yet`);
-  }
-  await page.keyboard.press('Enter');
-}
-
-const GRAPH_CAPTION = 'Ask what keeps it alive: SharpLsp: Show Reference Graph';
-
-async function askScene(page) {
-  await caption(page, 4, GRAPH_CAPTION);
-  await capturing(page).waitFor({ state: 'detached', timeout: 60_000 });
-  await sleep(600);
-  await runCommand(page, 'SharpLsp: Show Reference Graph');
-  await pickType(page, 'Storefront.CustomerSession');
-}
-
-/** The walk over a live heap of a hundred megabytes takes a while: fast-forwarded. */
-async function walkScene(page) {
-  await caption(page, 4, GRAPH_CAPTION, '8×');
-  await page.locator('.tab', { hasText: 'Retention Graph' }).waitFor({ timeout: 240_000 });
-  await sleep(1000);
-}
-
-async function graphScene(page) {
-  await caption(page, 4, GRAPH_CAPTION);
-  await sleep(7000);
-}
-
-/** Go to `line`, select it, and type `text` over it. */
-async function typeOver(page, line, text) {
-  await page.keyboard.press('Control+G');
-  await page.locator('.quick-input-widget input').fill(`:${line}`);
-  await page.keyboard.press('Enter');
-  await page.keyboard.press('Shift+End');
-  await page.keyboard.type(text, { delay: 28 });
-}
-
-async function fixScene(page) {
-  await caption(page, 5, 'Fix it: keep a bounded window and evict the rest');
-  await sleep(2000);
-  for (const { line, text } of FIX) await typeOver(page, line, text);
-  await page.keyboard.press('Meta+S');
-  await sleep(3000);
-}
-
-async function retrackScene(page, cues) {
-  await caption(page, 6, 'Rebuild, run, and track memory again');
-  await startTracking(page, cues);
-}
-
-async function verifyScene(page) {
-  await caption(page, 6, 'Rebuild, run, and track memory again', '8×');
-  await awaitDashboard(page);
-  await sleep(VERIFY_SECONDS * 1000);
-}
-
-async function steadyScene(page) {
-  await caption(page, 7, 'The heap holds steady, and no suspect climbs past Low');
-  await sleep(2500);
-  await scrollDashboard(page, 8000);
-  await sleep(4000);
-}
-
-/** The status-bar progress of an auto-capture still talking to the target. */
-const capturing = (page) => page.locator('.statusbar', { hasText: 'Auto-capturing memory' });
-
-/**
- * Off camera: stop tracking, let any in-flight capture finish before the
- * leaking app exits, and reopen a clean SessionCache.cs.
- */
-async function stopAndReopen(page, app) {
-  await clickSharpLspIcon(page);
-  await (await headerButton(page, 'Stop Memory Tracking')).click();
-  await capturing(page).waitFor({ state: 'detached', timeout: 60_000 });
-  app.stop();
-  await openFile(page, 'SessionCache.cs');
-  await runCommand(page, 'File: Revert File');
-  await runCommand(page, 'View: Close All Editors');
-  await openFile(page, 'SessionCache.cs');
-  await clickSharpLspIcon(page);
-  await page.locator('.monaco-editor .view-lines').first().click();
-}
-
-/** Off camera: build the fixed code and start it with the Processes view open. */
-async function relaunch(page, app, workspace) {
-  buildStorefront(workspace);
-  await app.start();
-  await clickSharpLspIcon(page);
-  await waitForStorefrontRow(page);
-}
-
-/** Shoot a scene again when a refreshing dashboard closes its palette, or the type is not listed yet. */
-async function retried(attempts, shootScene) {
-  for (let attempt = 1; ; attempt++) {
-    try {
-      return await shootScene();
-    } catch (error) {
-      if (attempt >= attempts) throw error;
-      process.stdout.write(`retrying a take: ${error.message.split('\n')[0]}\n`);
-      await sleep(3500);
-    }
-  }
-}
-
-async function prepare(page, app) {
-  await runCommand(page, 'Notifications: Toggle Do Not Disturb Mode');
-  await clickSharpLspIcon(page);
-  await openFile(page, 'SessionCache.cs');
-  await sleep(15_000);
-  app.stop();
-  await app.start();
-  await waitForStorefrontRow(page);
-}
-
-async function shoot(page, set, app, workspace) {
-  await prepare(page, app);
-  await retried(3, () => record(set, 'track', () => trackScene(page, set.cues)));
-  await record(set, 'grow', () => growScene(page));
-  await record(set, 'suspect', () => suspectScene(page, set.cues));
-  await retried(5, () => record(set, 'ask', () => askScene(page)));
-  await record(set, 'walk', () => walkScene(page));
-  await record(set, 'graph', () => graphScene(page));
-  await stopAndReopen(page, app);
-  await record(set, 'fix', () => fixScene(page));
-  await relaunch(page, app, workspace);
-  await retried(3, () => record(set, 'retrack', () => retrackScene(page, set.cues)));
-  await record(set, 'verify', () => verifyScene(page));
-  await record(set, 'steady', () => steadyScene(page));
-}
-
-async function shootAll() {
-  fs.mkdirSync(clips, { recursive: true });
-  const { root, workspace } = stageStorefront();
-  fs.mkdirSync(path.join(workspace, '.vscode'), { recursive: true });
-  fs.writeFileSync(path.join(workspace, '.vscode/settings.json'), JSON.stringify(WORKSPACE));
-  const editor = await launchVsCode({ workspace });
-  const app = storefront(workspace);
-  await app.start();
-  try {
-    await shoot(editor.page, { cdp: editor.cdp, cues: cueLog(clips), frames: path.join(out, 'frames'), clips }, app, workspace);
-  } catch (error) {
-    await editor.page.screenshot({ path: path.join(out, 'failure.png') }).catch(() => undefined);
-    throw error;
-  } finally {
-    app.stop();
-    await editor.close();
-    fs.rmSync(root, { recursive: true, force: true });
-  }
-}
-
-/** Cut the scenes together at their speeds, then publish the MP4, the WebM and the poster. */
-function publish() {
-  const inputs = SCENES.flatMap(([name]) => ['-i', path.join(clips, `${name}.mp4`)]);
-  const chains = SCENES.map(([, speed], i) => `[${i}:v]setpts=PTS/${speed},fps=30,scale=1920:-2:flags=lanczos[v${i}]`);
-  const joined = `${SCENES.map((_, i) => `[v${i}]`).join('')}concat=n=${SCENES.length}:v=1:a=0[cut]`;
-  const master = path.join(out, `${NAME}-master.mp4`);
-  const lossless = ['-c:v', 'libx264', '-preset', 'slow', '-crf', '12', '-pix_fmt', 'yuv420p'];
-  ffmpeg([...inputs, '-filter_complex', `${chains.join(';')};${joined}`, '-map', '[cut]', ...lossless, master], 'leak master');
-  ffmpeg(['-i', master, ...H264, path.join(videos, `${NAME}.mp4`)], 'leak mp4');
-  ffmpeg(['-i', master, ...VP9, path.join(videos, `${NAME}.webm`)], 'leak webm');
-  poster(path.join(clips, `${POSTER.scene}.mp4`), POSTER.at, NAME);
-}
-
-if (!process.argv.includes('--publish')) await shootAll();
-publish();
diff --git a/src/website/tools/profiler-film/package-lock.json b/src/website/tools/profiler-film/package-lock.json
new file mode 100644
index 00000000..4aa01570
--- /dev/null
+++ b/src/website/tools/profiler-film/package-lock.json
@@ -0,0 +1,1129 @@
+{
+  "name": "sharplsp-profiler-film",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "sharplsp-profiler-film",
+      "devDependencies": {
+        "kokoro-js": "1.2.1"
+      }
+    },
+    "node_modules/@emnapi/runtime": {
+      "version": "1.11.3",
+      "resolved": "https://registry.npmjs.org/@emnapi/runtime/-/runtime-1.11.3.tgz",
+      "integrity": "sha512-Xz4Tpyki7XyrpbUK1jR1AhdAdaXyhhY4lZ3neLodmhpuWfy2PAQN5B46sAiU4liOXGLkHypn/qU+jvfWSCYYLA==",
+      "dev": true,
+      "license": "MIT",
+      "optional": true,
+      "dependencies": {
+        "tslib": "^2.4.0"
+      }
+    },
+    "node_modules/@huggingface/jinja": {
+      "version": "0.5.10",
+      "resolved": "https://registry.npmjs.org/@huggingface/jinja/-/jinja-0.5.10.tgz",
+      "integrity": "sha512-SgS1D1bglQ94ceD4ZCL6eayUDy9uV1xuyk61OjgSxU5GJh7upqZCKII0JoTYMc6wWsg3JUgaPRX0ElQzXPk3Cw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@huggingface/transformers": {
+      "version": "3.8.1",
+      "resolved": "https://registry.npmjs.org/@huggingface/transformers/-/transformers-3.8.1.tgz",
+      "integrity": "sha512-tsTk4zVjImqdqjS8/AOZg2yNLd1z9S5v+7oUPpXaasDRwEDhB+xnglK1k5cad26lL5/ZIaeREgWWy0bs9y9pPA==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@huggingface/jinja": "^0.5.3",
+        "onnxruntime-node": "1.21.0",
+        "onnxruntime-web": "1.22.0-dev.20250409-89f8206ba4",
+        "sharp": "^0.34.1"
+      }
+    },
+    "node_modules/@img/colour": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@img/colour/-/colour-1.1.0.tgz",
+      "integrity": "sha512-Td76q7j57o/tLVdgS746cYARfSyxk8iEfRxewL9h4OMzYhbW4TAcppl0mT4eyqXddh6L/jwoM75mo7ixa/pCeQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/@img/sharp-darwin-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-arm64/-/sharp-darwin-arm64-0.34.5.tgz",
+      "integrity": "sha512-imtQ3WMJXbMY4fxb/Ndp6HBTNVtWCUI0WdobyheGf5+ad6xX8VIDO8u2xE4qc/fr08CKG/7dDseFtn6M6g/r3w==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-darwin-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-darwin-x64/-/sharp-darwin-x64-0.34.5.tgz",
+      "integrity": "sha512-YNEFAF/4KQ/PeW0N+r+aVVsoIY0/qxxikF2SWdp+NRkmMB7y9LBZAVqQ4yhGCm/H3H270OSykqmQMKLBhBJDEw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-darwin-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-arm64/-/sharp-libvips-darwin-arm64-1.2.4.tgz",
+      "integrity": "sha512-zqjjo7RatFfFoP0MkQ51jfuFZBnVE2pRiaydKJ1G/rHZvnsrHAOcQALIi9sA5co5xenQdTugCvtb1cuf78Vf4g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-darwin-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-darwin-x64/-/sharp-libvips-darwin-x64-1.2.4.tgz",
+      "integrity": "sha512-1IOd5xfVhlGwX+zXv2N93k0yMONvUlANylbJw1eTah8K/Jtpi15KC+WSiaX/nBmbm2HxRM1gZ0nSdjSsrZbGKg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "darwin"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm/-/sharp-libvips-linux-arm-1.2.4.tgz",
+      "integrity": "sha512-bFI7xcKFELdiNCVov8e44Ia4u2byA+l3XtsAj+Q8tfCwO6BQ8iDojYdvoPMqsKDkuoOo+X6HZA0s0q11ANMQ8A==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-arm64/-/sharp-libvips-linux-arm64-1.2.4.tgz",
+      "integrity": "sha512-excjX8DfsIcJ10x1Kzr4RcWe1edC9PquDRRPx3YVCvQv+U5p7Yin2s32ftzikXojb1PIFc/9Mt28/y+iRklkrw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-ppc64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-ppc64/-/sharp-libvips-linux-ppc64-1.2.4.tgz",
+      "integrity": "sha512-FMuvGijLDYG6lW+b/UvyilUWu5Ayu+3r2d1S8notiGCIyYU/76eig1UfMmkZ7vwgOrzKzlQbFSuQfgm7GYUPpA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-riscv64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-riscv64/-/sharp-libvips-linux-riscv64-1.2.4.tgz",
+      "integrity": "sha512-oVDbcR4zUC0ce82teubSm+x6ETixtKZBh/qbREIOcI3cULzDyb18Sr/Wcyx7NRQeQzOiHTNbZFF1UwPS2scyGA==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-s390x": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-s390x/-/sharp-libvips-linux-s390x-1.2.4.tgz",
+      "integrity": "sha512-qmp9VrzgPgMoGZyPvrQHqk02uyjA0/QrTO26Tqk6l4ZV0MPWIW6LTkqOIov+J1yEu7MbFQaDpwdwJKhbJvuRxQ==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linux-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linux-x64/-/sharp-libvips-linux-x64-1.2.4.tgz",
+      "integrity": "sha512-tJxiiLsmHc9Ax1bz3oaOYBURTXGIRDODBqhveVHonrHJ9/+k89qbLl0bcJns+e4t4rvaNBxaEZsFtSfAdquPrw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-arm64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-arm64/-/sharp-libvips-linuxmusl-arm64-1.2.4.tgz",
+      "integrity": "sha512-FVQHuwx1IIuNow9QAbYUzJ+En8KcVm9Lk5+uGUQJHaZmMECZmOlix9HnH7n1TRkXMS0pGxIJokIVB9SuqZGGXw==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-libvips-linuxmusl-x64": {
+      "version": "1.2.4",
+      "resolved": "https://registry.npmjs.org/@img/sharp-libvips-linuxmusl-x64/-/sharp-libvips-linuxmusl-x64-1.2.4.tgz",
+      "integrity": "sha512-+LpyBk7L44ZIXwz/VYfglaX/okxezESc6UxDSoyo2Ks6Jxc4Y7sGjpgU9s4PMgqgjj1gZCylTieNamqA1MF7Dg==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm/-/sharp-linux-arm-0.34.5.tgz",
+      "integrity": "sha512-9dLqsvwtg1uuXBGZKsxem9595+ujv0sJ6Vi8wcTANSFpwV/GONat5eCkzQo/1O6zRIkh0m/8+5BjrRr7jDUSZw==",
+      "cpu": [
+        "arm"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-arm64/-/sharp-linux-arm64-0.34.5.tgz",
+      "integrity": "sha512-bKQzaJRY/bkPOXyKx5EVup7qkaojECG6NLYswgktOZjaXecSAeCWiZwwiFf3/Y+O1HrauiE3FVsGxFg8c24rZg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-ppc64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-ppc64/-/sharp-linux-ppc64-0.34.5.tgz",
+      "integrity": "sha512-7zznwNaqW6YtsfrGGDA6BRkISKAAE1Jo0QdpNYXNMHu2+0dTrPflTLNkpc8l7MUP5M16ZJcUvysVWWrMefZquA==",
+      "cpu": [
+        "ppc64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-ppc64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-riscv64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-riscv64/-/sharp-linux-riscv64-0.34.5.tgz",
+      "integrity": "sha512-51gJuLPTKa7piYPaVs8GmByo7/U7/7TZOq+cnXJIHZKavIRHAP77e3N2HEl3dgiqdD/w0yUfiJnII77PuDDFdw==",
+      "cpu": [
+        "riscv64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-riscv64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-s390x": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-s390x/-/sharp-linux-s390x-0.34.5.tgz",
+      "integrity": "sha512-nQtCk0PdKfho3eC5MrbQoigJ2gd1CgddUMkabUj+rBevs8tZ2cULOx46E7oyX+04WGfABgIwmMC0VqieTiR4jg==",
+      "cpu": [
+        "s390x"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-s390x": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linux-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linux-x64/-/sharp-linux-x64-0.34.5.tgz",
+      "integrity": "sha512-MEzd8HPKxVxVenwAa+JRPwEC7QFjoPWuS5NZnBt6B3pu7EG2Ge0id1oLHZpPJdn3OQK+BQDiw9zStiHBTJQQQQ==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linux-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-arm64/-/sharp-linuxmusl-arm64-0.34.5.tgz",
+      "integrity": "sha512-fprJR6GtRsMt6Kyfq44IsChVZeGN97gTD331weR1ex1c1rypDEABN6Tm2xa1wE6lYb5DdEnk03NZPqA7Id21yg==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-arm64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-linuxmusl-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-linuxmusl-x64/-/sharp-linuxmusl-x64-0.34.5.tgz",
+      "integrity": "sha512-Jg8wNT1MUzIvhBFxViqrEhWDGzqymo3sV7z7ZsaWbZNDLXRJZoRGrjulp60YYtV4wfY8VIKcWidjojlLcWrd8Q==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0",
+      "optional": true,
+      "os": [
+        "linux"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-libvips-linuxmusl-x64": "1.2.4"
+      }
+    },
+    "node_modules/@img/sharp-wasm32": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-wasm32/-/sharp-wasm32-0.34.5.tgz",
+      "integrity": "sha512-OdWTEiVkY2PHwqkbBI8frFxQQFekHaSSkUIJkwzclWZe64O1X4UlUjqqqLaPbUpMOQk6FBu/HtlGXNblIs0huw==",
+      "cpu": [
+        "wasm32"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later AND MIT",
+      "optional": true,
+      "dependencies": {
+        "@emnapi/runtime": "^1.7.0"
+      },
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-arm64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-arm64/-/sharp-win32-arm64-0.34.5.tgz",
+      "integrity": "sha512-WQ3AgWCWYSb2yt+IG8mnC6Jdk9Whs7O0gxphblsLvdhSpSTtmu69ZG1Gkb6NuvxsNACwiPV6cNSZNzt0KPsw7g==",
+      "cpu": [
+        "arm64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-ia32": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-ia32/-/sharp-win32-ia32-0.34.5.tgz",
+      "integrity": "sha512-FV9m/7NmeCmSHDD5j4+4pNI8Cp3aW+JvLoXcTUo0IqyjSfAZJ8dIUmijx1qaJsIiU+Hosw6xM5KijAWRJCSgNg==",
+      "cpu": [
+        "ia32"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@img/sharp-win32-x64": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/@img/sharp-win32-x64/-/sharp-win32-x64-0.34.5.tgz",
+      "integrity": "sha512-+29YMsqY2/9eFEiW93eqWnuLcWcufowXewwSNIT6UwZdUUCrM3oFjMWH/Z6/TMmb4hlFenmfAVbpWeup2jryCw==",
+      "cpu": [
+        "x64"
+      ],
+      "dev": true,
+      "license": "Apache-2.0 AND LGPL-3.0-or-later",
+      "optional": true,
+      "os": [
+        "win32"
+      ],
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      }
+    },
+    "node_modules/@isaacs/fs-minipass": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/@isaacs/fs-minipass/-/fs-minipass-4.0.1.tgz",
+      "integrity": "sha512-wgm9Ehl2jpeqP3zw/7mo3kRHFp5MEDhqAdwy1fTGkHAwnkGOVsgpvQhL8B5n1qlb01jV3n/bI0ZfZp5lWA1k4w==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "minipass": "^7.0.4"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/@protobufjs/aspromise": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/aspromise/-/aspromise-1.1.2.tgz",
+      "integrity": "sha512-j+gKExEuLmKwvz3OgROXtrJ2UG2x8Ch2YZUxahh+s1F2HZ+wAceUNLkvy6zKCPVRkU++ZWQrdxsUeQXmcg4uoQ==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/base64": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/base64/-/base64-1.1.2.tgz",
+      "integrity": "sha512-AZkcAA5vnN/v4PDqKyMR5lx7hZttPDgClv83E//FMNhR2TMcLUhfRUBHCmSl0oi9zMgDDqRUJkSxO3wm85+XLg==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/codegen": {
+      "version": "2.0.5",
+      "resolved": "https://registry.npmjs.org/@protobufjs/codegen/-/codegen-2.0.5.tgz",
+      "integrity": "sha512-zgXFLzW3Ap33e6d0Wlj4MGIm6Ce8O89n/apUaGNB/jx+hw+ruWEp7EwGUshdLKVRCxZW12fp9r40E1mQrf/34g==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/eventemitter": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/eventemitter/-/eventemitter-1.1.1.tgz",
+      "integrity": "sha512-vW1GmwMZNnL+gMRaovlh9yZX74kc+TTU3FObkkurpMaRtBfLP3ldjS9KQWlwZgraRE0+dheEEoAxdzcJQ8eXZg==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/fetch": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/@protobufjs/fetch/-/fetch-1.1.1.tgz",
+      "integrity": "sha512-GpptLrs57adMSuHi3VNj0mAF8dwh36LMaYF6XyJ6JMWlVsc+t42tm1HSEDmOs3A8fC9yyeisgLhsTVQokOZ0zw==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.1"
+      }
+    },
+    "node_modules/@protobufjs/float": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/float/-/float-1.0.2.tgz",
+      "integrity": "sha512-Ddb+kVXlXst9d+R9PfTIxh1EdNkgoRe5tOX6t01f1lYWOvJnSPDBlG241QLzcyPdoNTsblLUdujGSE4RzrTZGQ==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/path": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/path/-/path-1.1.2.tgz",
+      "integrity": "sha512-6JOcJ5Tm08dOHAbdR3GrvP+yUUfkjG5ePsHYczMFLq3ZmMkAD98cDgcT2iA1lJ9NVwFd4tH/iSSoe44YWkltEA==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/pool": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/@protobufjs/pool/-/pool-1.1.0.tgz",
+      "integrity": "sha512-0kELaGSIDBKvcgS4zkjz1PeddatrjYcmMWOlAuAPwAeccUrPHdUqo/J6LiymHHEiJT5NrF1UVwxY14f+fy4WQw==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@protobufjs/utf8": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/@protobufjs/utf8/-/utf8-1.1.2.tgz",
+      "integrity": "sha512-b1UQwcEZ4yCnMCD8DAL1VlbvBJE9/IX4FTIp7BG1xYpf29SLazLSrqUkj4w7Y5y7cCVP6E5tcqqcI0xemPkHug==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/@types/node": {
+      "version": "26.6.5",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-26.6.5.tgz",
+      "integrity": "sha512-uMzsv9stDdofIZBx4UGh4Z9ZgXnGC9seRDscilBcTHAeOFk67MZg/k9bWVfO+bk4qZmG+l52hRnLwUiH2LnJTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~8.9.0"
+      }
+    },
+    "node_modules/boolean": {
+      "version": "3.2.0",
+      "resolved": "https://registry.npmjs.org/boolean/-/boolean-3.2.0.tgz",
+      "integrity": "sha512-d0II/GO9uf9lfUHH2BQsjxzRJZBdsjgsBiW4BvhWk/3qoKwQFjIDVN19PfX8F2D/r9PCMTtLWjYVCFrpeYUzsw==",
+      "deprecated": "Package no longer supported. Contact Support at https://www.npmjs.com/support for more info.",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/chownr": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/chownr/-/chownr-3.0.0.tgz",
+      "integrity": "sha512-+IxzY9BZOQd/XuYPRmrvEVjF/nqj5kgT4kEq7VofrDoM1MxoRjEWkrCC3EtLi59TVawxTAn+orJwFQcrqEN1+g==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/define-data-property": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/define-data-property/-/define-data-property-1.1.4.tgz",
+      "integrity": "sha512-rBMvIzlpA8v6E+SJZoo++HAYqsLrkg7MSfIinMPFhmkorw7X+dOXVJQs+QT69zGkzMyfDnIMN2Wid1+NbL3T+A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/define-properties": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/define-properties/-/define-properties-1.2.1.tgz",
+      "integrity": "sha512-8QmQKqEASLd5nx0U1B1okLElbUuuttJ/AnYmRXbbbGDWh6uS208EjD4Xqq/I9wK7u0v6O08XhTWnt5XtEbR6Dg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "define-data-property": "^1.0.1",
+        "has-property-descriptors": "^1.0.0",
+        "object-keys": "^1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/detect-libc": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/detect-libc/-/detect-libc-2.1.2.tgz",
+      "integrity": "sha512-Btj2BOOO83o3WyH59e8MgXsxEQVcarkUOpEYrubB0urwnN10yQ364rsiByU11nZlqWYZm05i/of7io4mzihBtQ==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/detect-node": {
+      "version": "2.1.0",
+      "resolved": "https://registry.npmjs.org/detect-node/-/detect-node-2.1.0.tgz",
+      "integrity": "sha512-T0NIuQpnTvFDATNuHN5roPwSBG83rFsuO+MXXH9/3N1eFbn4wcPjttvjMLEPWJ0RGUYgQE7cGgS3tNxbqCGM7g==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es6-error": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/es6-error/-/es6-error-4.1.1.tgz",
+      "integrity": "sha512-Um/+FxMr9CISWh0bi5Zv0iOD+4cFh5qLeks1qhAopKVAJw3drgKbKySikp7wGhDL0HPeaja0P5ULZrxLkniUVg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/escape-string-regexp": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/escape-string-regexp/-/escape-string-regexp-4.0.0.tgz",
+      "integrity": "sha512-TtpcNJ3XAzx3Gq8sWRzJaVajRs0uVxA2YAkdb1jm2YkPz4G6egUFAyA3n5vtEIZefPk5Wa4UXbKuS5fKkJWdgA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/flatbuffers": {
+      "version": "25.9.23",
+      "resolved": "https://registry.npmjs.org/flatbuffers/-/flatbuffers-25.9.23.tgz",
+      "integrity": "sha512-MI1qs7Lo4Syw0EOzUl0xjs2lsoeqFku44KpngfIduHBYvzm8h2+7K8YMQh1JtVVVrUvhLpNwqVi4DERegUJhPQ==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/global-agent": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/global-agent/-/global-agent-3.0.0.tgz",
+      "integrity": "sha512-PT6XReJ+D07JvGoxQMkT6qji/jVNfX/h364XHZOWeRzy64sSFr+xJ5OX7LI3b4MPQzdL4H8Y8M0xzPpsVMwA8Q==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "boolean": "^3.0.1",
+        "es6-error": "^4.1.1",
+        "matcher": "^3.0.0",
+        "roarr": "^2.15.3",
+        "semver": "^7.3.2",
+        "serialize-error": "^7.0.1"
+      },
+      "engines": {
+        "node": ">=10.0"
+      }
+    },
+    "node_modules/globalthis": {
+      "version": "1.0.4",
+      "resolved": "https://registry.npmjs.org/globalthis/-/globalthis-1.0.4.tgz",
+      "integrity": "sha512-DpLKbNU4WylpxJykQujfCcwYWiV/Jhm50Goo0wrVILAv5jOr9d+H+UR3PhSCD2rCCEIg0uc+G+muBTwD54JhDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "define-properties": "^1.2.1",
+        "gopd": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/guid-typescript": {
+      "version": "1.0.9",
+      "resolved": "https://registry.npmjs.org/guid-typescript/-/guid-typescript-1.0.9.tgz",
+      "integrity": "sha512-Y8T4vYhEfwJOTbouREvG+3XDsjr8E3kIr7uf+JZ0BYloFsttiHU0WfvANVsR7TxNUJa/WpCnw/Ino/p+DeBhBQ==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/has-property-descriptors": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/has-property-descriptors/-/has-property-descriptors-1.0.2.tgz",
+      "integrity": "sha512-55JNKuIW+vq4Ke1BjOTjM2YctQIvCT7GFzHwmfZPGo5wnrgkid0YQtnAleFSqumZm4az3n2BS+erby5ipJdgrg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "es-define-property": "^1.0.0"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/json-stringify-safe": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/json-stringify-safe/-/json-stringify-safe-5.0.1.tgz",
+      "integrity": "sha512-ZClg6AaYvamvYEE82d3Iyd3vSSIjQ+odgjaTzRuO3s7toCdFKczob2i0zCh7JE8kWn17yvAWhUVxvqGwUalsRA==",
+      "dev": true,
+      "license": "ISC"
+    },
+    "node_modules/kokoro-js": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/kokoro-js/-/kokoro-js-1.2.1.tgz",
+      "integrity": "sha512-oq0HZJWis3t8lERkMJh84WLU86dpYD0EuBPtqYnLlQzyFP1OkyBRDcweAqCfhNOpltyN9j/azp1H6uuC47gShw==",
+      "dev": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@huggingface/transformers": "^3.5.1",
+        "phonemizer": "^1.2.1"
+      }
+    },
+    "node_modules/long": {
+      "version": "5.3.2",
+      "resolved": "https://registry.npmjs.org/long/-/long-5.3.2.tgz",
+      "integrity": "sha512-mNAgZ1GmyNhD7AuqnTG3/VQ26o760+ZYBPKjPvugO8+nLbYfX6TVpJPseBvopbdY+qpZ/lKUnmEc1LeZYS3QAA==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/matcher": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/matcher/-/matcher-3.0.0.tgz",
+      "integrity": "sha512-OkeDaAZ/bQCxeFAozM55PKcKU0yJMPGifLwV4Qgjitu+5MoAfSQN4lsLJeXZ1b8w0x+/Emda6MZgXS1jvsapng==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "escape-string-regexp": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/minipass": {
+      "version": "7.1.3",
+      "resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+      "integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      }
+    },
+    "node_modules/minizlib": {
+      "version": "3.1.0",
+      "resolved": "https://registry.npmjs.org/minizlib/-/minizlib-3.1.0.tgz",
+      "integrity": "sha512-KZxYo1BUkWD2TVFLr0MQoM8vUUigWD3LlD83a/75BqC+4qE0Hb1Vo5v1FgcfaNXvfXzr+5EhQ6ing/CaBijTlw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minipass": "^7.1.2"
+      },
+      "engines": {
+        "node": ">= 18"
+      }
+    },
+    "node_modules/object-keys": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/object-keys/-/object-keys-1.1.1.tgz",
+      "integrity": "sha512-NuAESUOUMrlIXOfHKzD6bpPu3tYt3xvjNdRIQ+FeT0lNb4K8WR70CaDxhuNguS2XG+GjkyMwOzsN5ZktImfhLA==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/onnxruntime-common": {
+      "version": "1.21.0",
+      "resolved": "https://registry.npmjs.org/onnxruntime-common/-/onnxruntime-common-1.21.0.tgz",
+      "integrity": "sha512-Q632iLLrtCAVOTO65dh2+mNbQir/QNTVBG3h/QdZBpns7mZ0RYbLRBgGABPbpU9351AgYy7SJf1WaeVwMrBFPQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/onnxruntime-node": {
+      "version": "1.21.0",
+      "resolved": "https://registry.npmjs.org/onnxruntime-node/-/onnxruntime-node-1.21.0.tgz",
+      "integrity": "sha512-NeaCX6WW2L8cRCSqy3bInlo5ojjQqu2fD3D+9W5qb5irwxhEyWKXeH2vZ8W9r6VxaMPUan+4/7NDwZMtouZxEw==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "MIT",
+      "os": [
+        "win32",
+        "darwin",
+        "linux"
+      ],
+      "dependencies": {
+        "global-agent": "^3.0.0",
+        "onnxruntime-common": "1.21.0",
+        "tar": "^7.0.1"
+      }
+    },
+    "node_modules/onnxruntime-web": {
+      "version": "1.22.0-dev.20250409-89f8206ba4",
+      "resolved": "https://registry.npmjs.org/onnxruntime-web/-/onnxruntime-web-1.22.0-dev.20250409-89f8206ba4.tgz",
+      "integrity": "sha512-0uS76OPgH0hWCPrFKlL8kYVV7ckM7t/36HfbgoFw6Nd0CZVVbQC4PkrR8mBX8LtNUFZO25IQBqV2Hx2ho3FlbQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "flatbuffers": "^25.1.24",
+        "guid-typescript": "^1.0.9",
+        "long": "^5.2.3",
+        "onnxruntime-common": "1.22.0-dev.20250409-89f8206ba4",
+        "platform": "^1.3.6",
+        "protobufjs": "^7.2.4"
+      }
+    },
+    "node_modules/onnxruntime-web/node_modules/onnxruntime-common": {
+      "version": "1.22.0-dev.20250409-89f8206ba4",
+      "resolved": "https://registry.npmjs.org/onnxruntime-common/-/onnxruntime-common-1.22.0-dev.20250409-89f8206ba4.tgz",
+      "integrity": "sha512-vDJMkfCfb0b1A836rgHj+ORuZf4B4+cc2bASQtpeoJLueuFc5DuYwjIZUBrSvx/fO5IrLjLz+oTrB3pcGlhovQ==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/phonemizer": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/phonemizer/-/phonemizer-1.2.1.tgz",
+      "integrity": "sha512-v0KJ4mi2T4Q7eJQ0W15Xd4G9k4kICSXE8bpDeJ8jisL4RyJhNWsweKTOi88QXFc4r4LZlz5jVL5lCHhkpdT71A==",
+      "dev": true,
+      "license": "Apache-2.0"
+    },
+    "node_modules/platform": {
+      "version": "1.3.6",
+      "resolved": "https://registry.npmjs.org/platform/-/platform-1.3.6.tgz",
+      "integrity": "sha512-fnWVljUchTro6RiCFvCXBbNhJc2NijN7oIQxbwsyL0buWJPG85v81ehlHI9fXrJsMNgTofEoWIQeClKpgxFLrg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/protobufjs": {
+      "version": "7.6.6",
+      "resolved": "https://registry.npmjs.org/protobufjs/-/protobufjs-7.6.6.tgz",
+      "integrity": "sha512-dYDWdjSl5RNb7SgPxGQcRU+GtvP7s2fpkrY0r432PcOIaZ0/rBcxEZnQN67iJhFuQiVw754JDoPruPCNdGsbjg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "@protobufjs/aspromise": "^1.1.2",
+        "@protobufjs/base64": "^1.1.2",
+        "@protobufjs/codegen": "^2.0.5",
+        "@protobufjs/eventemitter": "^1.1.1",
+        "@protobufjs/fetch": "^1.1.1",
+        "@protobufjs/float": "^1.0.2",
+        "@protobufjs/path": "^1.1.2",
+        "@protobufjs/pool": "^1.1.0",
+        "@protobufjs/utf8": "^1.1.1",
+        "@types/node": ">=13.7.0",
+        "long": "^5.3.2"
+      },
+      "engines": {
+        "node": ">=12.0.0"
+      }
+    },
+    "node_modules/roarr": {
+      "version": "2.15.4",
+      "resolved": "https://registry.npmjs.org/roarr/-/roarr-2.15.4.tgz",
+      "integrity": "sha512-CHhPh+UNHD2GTXNYhPWLnU8ONHdI+5DI+4EYIAOaiD63rHeYlZvyh8P+in5999TTSFgUYuKUAjzRI4mdh/p+2A==",
+      "dev": true,
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "boolean": "^3.0.1",
+        "detect-node": "^2.0.4",
+        "globalthis": "^1.0.1",
+        "json-stringify-safe": "^5.0.1",
+        "semver-compare": "^1.0.0",
+        "sprintf-js": "^1.1.2"
+      },
+      "engines": {
+        "node": ">=8.0"
+      }
+    },
+    "node_modules/semver": {
+      "version": "7.8.5",
+      "resolved": "https://registry.npmjs.org/semver/-/semver-7.8.5.tgz",
+      "integrity": "sha512-Y7/KDsb8LjooZpwaqGyulO6DQlksgCncchHGk+sZIY4SBvUocMBEFH5Ur1fI4dV+Jvl0w6cjvucaIi40puRioA==",
+      "dev": true,
+      "license": "ISC",
+      "bin": {
+        "semver": "bin/semver.js"
+      },
+      "engines": {
+        "node": ">=10"
+      }
+    },
+    "node_modules/semver-compare": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/semver-compare/-/semver-compare-1.0.0.tgz",
+      "integrity": "sha512-YM3/ITh2MJ5MtzaM429anh+x2jiLVjqILF4m4oyQB18W7Ggea7BfqdH/wGMK7dDiMghv/6WG7znWMwUDzJiXow==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/serialize-error": {
+      "version": "7.0.1",
+      "resolved": "https://registry.npmjs.org/serialize-error/-/serialize-error-7.0.1.tgz",
+      "integrity": "sha512-8I8TjW5KMOKsZQTvoxjuSIa7foAwPWGOts+6o7sgjz41/qMD9VQHEDxi6PBvK2l0MXUmqZyNpUK+T2tQaaElvw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "type-fest": "^0.13.1"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/sharp": {
+      "version": "0.34.5",
+      "resolved": "https://registry.npmjs.org/sharp/-/sharp-0.34.5.tgz",
+      "integrity": "sha512-Ou9I5Ft9WNcCbXrU9cMgPBcCK8LiwLqcbywW3t4oDV37n1pzpuNLsYiAV8eODnjbtQlSDwZ2cUEeQz4E54Hltg==",
+      "dev": true,
+      "hasInstallScript": true,
+      "license": "Apache-2.0",
+      "dependencies": {
+        "@img/colour": "^1.0.0",
+        "detect-libc": "^2.1.2",
+        "semver": "^7.7.3"
+      },
+      "engines": {
+        "node": "^18.17.0 || ^20.3.0 || >=21.0.0"
+      },
+      "funding": {
+        "url": "https://opencollective.com/libvips"
+      },
+      "optionalDependencies": {
+        "@img/sharp-darwin-arm64": "0.34.5",
+        "@img/sharp-darwin-x64": "0.34.5",
+        "@img/sharp-libvips-darwin-arm64": "1.2.4",
+        "@img/sharp-libvips-darwin-x64": "1.2.4",
+        "@img/sharp-libvips-linux-arm": "1.2.4",
+        "@img/sharp-libvips-linux-arm64": "1.2.4",
+        "@img/sharp-libvips-linux-ppc64": "1.2.4",
+        "@img/sharp-libvips-linux-riscv64": "1.2.4",
+        "@img/sharp-libvips-linux-s390x": "1.2.4",
+        "@img/sharp-libvips-linux-x64": "1.2.4",
+        "@img/sharp-libvips-linuxmusl-arm64": "1.2.4",
+        "@img/sharp-libvips-linuxmusl-x64": "1.2.4",
+        "@img/sharp-linux-arm": "0.34.5",
+        "@img/sharp-linux-arm64": "0.34.5",
+        "@img/sharp-linux-ppc64": "0.34.5",
+        "@img/sharp-linux-riscv64": "0.34.5",
+        "@img/sharp-linux-s390x": "0.34.5",
+        "@img/sharp-linux-x64": "0.34.5",
+        "@img/sharp-linuxmusl-arm64": "0.34.5",
+        "@img/sharp-linuxmusl-x64": "0.34.5",
+        "@img/sharp-wasm32": "0.34.5",
+        "@img/sharp-win32-arm64": "0.34.5",
+        "@img/sharp-win32-ia32": "0.34.5",
+        "@img/sharp-win32-x64": "0.34.5"
+      }
+    },
+    "node_modules/sprintf-js": {
+      "version": "1.1.3",
+      "resolved": "https://registry.npmjs.org/sprintf-js/-/sprintf-js-1.1.3.tgz",
+      "integrity": "sha512-Oo+0REFV59/rz3gfJNKQiBlwfHaSESl1pcGyABQsnnIfWOFt6JNj5gCog2U6MLZ//IGYD+nA8nI+mTShREReaA==",
+      "dev": true,
+      "license": "BSD-3-Clause"
+    },
+    "node_modules/tar": {
+      "version": "7.5.22",
+      "resolved": "https://registry.npmjs.org/tar/-/tar-7.5.22.tgz",
+      "integrity": "sha512-MFO/QzvtAOmJbkhOaCTvbGcFN9L9b+JunIsDwaKljSOdcLMea3NJ1k9Usz/rjdfSXTq4dfzfeS7W4p4YOAAHeA==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "dependencies": {
+        "@isaacs/fs-minipass": "^4.0.0",
+        "chownr": "^3.0.0",
+        "minipass": "^7.1.2",
+        "minizlib": "^3.1.0",
+        "yallist": "^5.0.0"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/tslib": {
+      "version": "2.8.1",
+      "resolved": "https://registry.npmjs.org/tslib/-/tslib-2.8.1.tgz",
+      "integrity": "sha512-oJFu94HQb+KVduSUQL7wnpmqnfmLsOA/nAh6b6EH0wCEoK0/mPeXU6c3wKDV83MkOuHPRHtSXKKU99IBazS/2w==",
+      "dev": true,
+      "license": "0BSD",
+      "optional": true
+    },
+    "node_modules/type-fest": {
+      "version": "0.13.1",
+      "resolved": "https://registry.npmjs.org/type-fest/-/type-fest-0.13.1.tgz",
+      "integrity": "sha512-34R7HTnG0XIJcBSn5XhDd7nNFPRcXYRZrBB2O2jdKqYODldSzBAqzsWoZYYvduky73toYS/ESqxPvkDf/F0XMg==",
+      "dev": true,
+      "license": "(MIT OR CC0-1.0)",
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "8.9.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-8.9.0.tgz",
+      "integrity": "sha512-KTDyRTYX8sWmKXAikPHHSyc63CRPETMctyjKFupcC6OBLXT3xsN0e9aF7m+mIXutFWpUXuedtowG7iLOzp0kQg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/yallist": {
+      "version": "5.0.0",
+      "resolved": "https://registry.npmjs.org/yallist/-/yallist-5.0.0.tgz",
+      "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw==",
+      "dev": true,
+      "license": "BlueOak-1.0.0",
+      "engines": {
+        "node": ">=18"
+      }
+    }
+  }
+}
diff --git a/src/website/tools/profiler-film/package.json b/src/website/tools/profiler-film/package.json
new file mode 100644
index 00000000..5a9c8d01
--- /dev/null
+++ b/src/website/tools/profiler-film/package.json
@@ -0,0 +1,9 @@
+{
+  "name": "sharplsp-profiler-film",
+  "private": true,
+  "type": "module",
+  "description": "Local tools that shoot and narrate the website's profiler films. Narration runs on this machine; nothing is sent to a speech service.",
+  "devDependencies": {
+    "kokoro-js": "1.2.1"
+  }
+}
diff --git a/src/website/tools/profiler-film/studio.mjs b/src/website/tools/profiler-film/studio.mjs
deleted file mode 100644
index b47cb967..00000000
--- a/src/website/tools/profiler-film/studio.mjs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Implements [WEB-DESIGN-MEDIA]. The set every profiler film is shot on: the
-// Storefront demo staged and built at a neutral temp path, the isolated VS Code's
-// Processes view and editor moves, and the real-time screencast recorder.
-// capture.mjs (the profiler film) and leak.mjs (the leak walkthrough) both shoot here.
-import { spawn, spawnSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { runCommand } from './vscode.mjs';
-import { startScreencast } from './screencast.mjs';
-
-const here = path.dirname(fileURLToPath(import.meta.url));
-
-/** Where the mouse rests between actions: empty title bar, hovering nothing. */
-export const PARK = { x: 1450, y: 22 };
-
-export const DASHBOARD = 'SharpLsp Memory Dashboard';
-
-export const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-
-/** Build the staged Storefront; a failed build stops the shoot. */
-export function buildStorefront(workspace) {
-  const build = spawnSync('dotnet', ['build', '-c', 'Debug', '--nologo', '-v', 'q'], {
-    cwd: workspace,
-    encoding: 'utf8',
-  });
-  if (build.status !== 0) throw new Error(`Storefront build failed: ${build.stdout}`);
-}
-
-/**
- * Copy the demo to a neutral temp path and build it there, so no home-directory
- * path (the user's name) can reach a frame name or tooltip on camera.
- */
-export function stageStorefront() {
-  // The real path: macOS's tmpdir is a symlink the .NET runtime resolves, and
-  // heat-map decorations only land when both sides spell the file the same way.
-  const root = fs.mkdtempSync(path.join(fs.realpathSync(os.tmpdir()), 'film-'));
-  const workspace = path.join(root, 'Storefront');
-  fs.cpSync(path.join(here, 'storefront'), workspace, {
-    recursive: true,
-    filter: (source) => !['bin', 'obj', '.sharplsp'].includes(path.basename(source)),
-  });
-  buildStorefront(workspace);
-  return { root, workspace };
-}
-
-/** Start Storefront by absolute path (discovery needs it) and wait for its banner. */
-async function startStorefront(workspace) {
-  const app = spawn(path.join(workspace, 'bin/Debug/net10.0/Storefront'), [], {
-    cwd: workspace,
-    stdio: ['ignore', 'pipe', 'ignore'],
-  });
-  await new Promise((resolve, reject) => {
-    app.stdout.once('data', resolve);
-    app.once('exit', (code) => reject(new Error(`Storefront exited with ${code}`)));
-  });
-  return app;
-}
-
-/** The live Storefront's PID: its row, never a stale one from a restarted run. */
-let storefrontPid = 0;
-
-/** The demo app, restartable so a memory act starts from a fresh, small heap. */
-export function storefront(workspace) {
-  let app;
-  return {
-    start: async () => {
-      app = await startStorefront(workspace);
-      storefrontPid = app.pid;
-    },
-    stop: () => app?.kill(),
-  };
-}
-
-/** Click-cue log: where and when the (invisible) mouse acted, relative to a clip's start. */
-export function cueLog(clips) {
-  let start = Date.now();
-  const cues = [];
-  return {
-    restart: () => {
-      start = Date.now();
-      cues.length = 0;
-    },
-    async click(page, locator, label) {
-      const box = await locator.boundingBox();
-      if (box) cues.push({ t: (Date.now() - start) / 1000, x: box.x + box.width / 2, y: box.y + box.height / 2, label });
-      await locator.click({ force: true });
-      await page.waitForTimeout(350);
-      await page.mouse.move(PARK.x, PARK.y);
-    },
-    save: (name) => fs.writeFileSync(path.join(clips, `${name}.cues.json`), JSON.stringify(cues, null, 2)),
-  };
-}
-
-/**
- * Record `act` as a real-time clip `<clips>/<name>.mp4`, its frames under `<frames>/<name>`.
- * A failed act still ends the screencast, so the take can be shot again.
- */
-export async function record({ cdp, cues, frames, clips }, name, act) {
-  cues.restart();
-  const stop = await startScreencast(cdp, path.join(frames, name));
-  const clip = path.join(clips, `${name}.mp4`);
-  try {
-    await act();
-  } catch (error) {
-    await stop(clip).catch(() => undefined);
-    throw error;
-  }
-  await stop(clip);
-  cues.save(name);
-}
-
-const processesHeader = (page) => page.locator('.pane-header', { hasText: 'Processes' });
-
-export const storefrontRow = (page) =>
-  page.getByRole('treeitem').filter({ hasText: `Storefront — StorefrontPID ${storefrontPid}` }).first();
-
-export async function headerButton(page, name) {
-  await processesHeader(page).hover();
-  return processesHeader(page).getByRole('button', { name: new RegExp(`^${name}`) });
-}
-
-export async function rowButton(page, name) {
-  await storefrontRow(page).hover();
-  await sleep(250);
-  return storefrontRow(page).getByRole('button', { name: new RegExp(`^${name}`) });
-}
-
-/** Wait until the Processes view lists the live Storefront row. */
-export async function waitForStorefrontRow(page) {
-  for (let attempt = 0; attempt < 30; attempt++) {
-    if (await storefrontRow(page).isVisible().catch(() => false)) return;
-    await (await headerButton(page, 'Refresh Processes')).click();
-    await sleep(1000);
-  }
-  throw new Error('Storefront never appeared in the Processes view');
-}
-
-/** A clean frame: no hover (Do Not Disturb keeps toasts off screen). */
-export async function still(page, dir, name) {
-  await page.mouse.move(PARK.x, PARK.y);
-  await sleep(700);
-  await page.screenshot({ path: path.join(dir, `${name}.png`) });
-}
-
-/**
- * Click the SharpLsp activity-bar icon. It opens the SharpLsp view; on the view
- * already open it folds the side bar away. That is how a memory act hides it:
- * the dashboard webview refreshes on every auto-snapshot and would close a
- * palette, and the native menu owns Cmd+B, so a synthetic key never reaches it.
- */
-export async function clickSharpLspIcon(page) {
-  await page.locator('.activitybar a[aria-label^="SharpLsp"]').first().click({ force: true });
-  await sleep(900);
-}
-
-export async function openFile(page, name) {
-  await page.keyboard.press('Meta+P');
-  await page.locator('.quick-input-widget input').fill(name);
-  await sleep(700);
-  await page.keyboard.press('Enter');
-  await sleep(1200);
-}
-
-export async function scrollDashboard(page, pixels) {
-  await page.mouse.move(1300, 600);
-  await page.mouse.wheel(0, pixels);
-  await sleep(1200);
-}
-
-/**
- * Start memory tracking on the Storefront row and fold the side bar once the
- * dashboard opens. `click(locator, label)` is the act's own way of clicking.
- */
-export async function trackMemory(page, click) {
-  await click(await rowButton(page, 'Track Memory'), 'Track Memory');
-  await awaitDashboard(page);
-}
-
-/** Wait for the memory dashboard to open, then fold the side bar away from it. */
-export async function awaitDashboard(page) {
-  await page.locator('.tab', { hasText: DASHBOARD }).waitFor({ timeout: 60_000 });
-  await sleep(1500);
-  await clickSharpLspIcon(page);
-  await page.mouse.move(PARK.x, PARK.y);
-}
-
-export async function toggleSideBar(page) {
-  await runCommand(page, 'View: Toggle Primary Side Bar Visibility');
-  await sleep(800);
-}
diff --git a/src/website/video-figure.js b/src/website/video-figure.js
index 17295f1a..93a533de 100644
--- a/src/website/video-figure.js
+++ b/src/website/video-figure.js
@@ -5,11 +5,14 @@
 // The catalogue lists every video on the site once: its encodings, size, length
 // and the words that describe it in each language. A page names a video with
 // `{% video "<id>" %}` and never repeats its markup; files live at
-// /assets/videos/<id>.<encoding> beside /assets/videos/<id>-poster.webp.
-// The profiler media is rendered by tools/profiler-film/render.mjs. The tour is
+// /assets/videos/<id>.<encoding> beside /assets/videos/<id>-poster.webp, and a
+// narrated video's captions at /assets/videos/<id>.<lang>.vtt.
+// The profiler media is shot and published by tools/profiler-film (film.mjs and
+// films/profiler/render.mjs). The tour is
 // the Marketplace GIF (assets/images/marketplace/sharplsp-tour.gif) re-encoded
 // with the same H.264/VP9 settings, because a GIF is eight times the bytes.
 import markdownIt from "markdown-it";
+import languages from "./src/_data/languages.json" with { type: "json" };
 import site from "./src/_data/site.json" with { type: "json" };
 import videos from "./src/_data/videos.json" with { type: "json" };
 
@@ -18,8 +21,18 @@ const { escapeHtml } = markdownIt().utils;
 const asset = (id, suffix) => `/assets/videos/${id}${suffix}`;
 
 /**
- * Docs and articles get a still film with controls. A marketing page may pass
- * `autoplay` for a muted loop; custom.js stills it under reduced motion.
+ * A narrated video's captions, one track per language its `captions` lists,
+ * at /assets/videos/<id>.<lang>.vtt; the page's own language shows by default.
+ */
+const tracks = (id, video, lang) =>
+  (video.captions ?? []).map(
+    (code) => `<track kind="captions" src="${asset(id, `.${code}.vtt`)}" srclang="${code}" label="${languages[code].nativeName}"${code === lang ? " default" : ""}>`,
+  );
+
+/**
+ * Docs and articles get a still film with controls, its narration audible. A
+ * marketing page may pass `autoplay` for a muted loop; custom.js stills it
+ * under reduced motion.
  */
 export function videoFigure(id, lang, { caption, autoplay = false } = {}) {
   const video = videos[id];
@@ -27,8 +40,9 @@ export function videoFigure(id, lang, { caption, autoplay = false } = {}) {
   const text = video.text[lang] ?? video.text.en;
   return [
     `<figure class="${autoplay ? "product-shot" : "article-figure"}">`,
-    `<video ${autoplay ? "autoplay loop" : "controls"} muted playsinline preload="metadata" poster="${asset(id, "-poster.webp")}" width="${video.width}" height="${video.height}" aria-label="${escapeHtml(text.label)}">`,
+    `<video ${autoplay ? "autoplay loop muted" : "controls"} playsinline preload="metadata" poster="${asset(id, "-poster.webp")}" width="${video.width}" height="${video.height}" aria-label="${escapeHtml(text.label)}">`,
     ...video.encodings.map((encoding) => `<source src="${asset(id, `.${encoding}`)}" type="video/${encoding}">`),
+    ...tracks(id, video, lang),
     "</video>",
     `<figcaption>${caption ?? escapeHtml(text.caption)}</figcaption>`,
     "</figure>",
diff --git a/tools/ci/security-gates.test.mjs b/tools/ci/security-gates.test.mjs
index 3348b228..d8c1028f 100644
--- a/tools/ci/security-gates.test.mjs
+++ b/tools/ci/security-gates.test.mjs
@@ -79,6 +79,20 @@ test("the terminal gate fails when code changed but the build or test phase did
     assert.match(gate.run, /exit 1/);
 });
 
+// [DIST-CI-DEPENDABOT]: the whole pipeline skips a Dependabot PR, so a green CI
+// would be a pass of nothing. Every one CI sees targets `main`, where the only
+// route in is the tested `dependabot-upgrades` consolidation PR.
+test("the terminal gate fails a Dependabot PR to main, whose pipeline ran nothing", () => {
+    assert.deepEqual(ci.on.pull_request.branches, ["main"], "every PR CI sees targets main");
+    assert.equal(ci.jobs["detect-changes"].if, "github.actor != 'dependabot[bot]'");
+    const steps = ci.jobs.ci.steps;
+    const gate = steps.find((step) => step.if?.includes("github.actor == 'dependabot[bot]'"));
+    assert.ok(gate, "a Dependabot PR must not report green");
+    assert.ok(steps.indexOf(gate) < steps.findIndex((step) => step.name === "Report"));
+    assert.match(gate.run, /dependabot-upgrades/, "the failure names the route that IS tested");
+    assert.match(gate.run, /exit 1/);
+});
+
 test("all compiled test consumers opt into their non-building runners", () => {
     for (const job of Object.values(workflow("ci-test-dotnet").jobs)) {
         const run = job.steps.find((step) => step.run?.startsWith("make _test-dotnet"));