@markii/host 0.0.1 → 0.17.0-next.3

package/dist/conformance/host/13-install-pack-declined/files/ana-1.0.0/pack.json

@@ -0,0 +1,13 @@
+{
+  "name": "ana",
+  "engine": "react",
+  "version": "1.0.0",
+  "components": {
+    "timeline": {
+      "sources": {
+        "react": "./Timeline.tsx",
+        "ansi": "./Timeline.ansi.tsx"
+      }
+    }
+  }
+}

package/dist/conformance/host/13-install-pack-declined/files/ana-1.0.0/webview.js

@@ -0,0 +1 @@
+window.__markiiRegisterPack(() => ({}));

package/dist/conformance/host/13-install-pack-declined/note.mk.md

@@ -0,0 +1,5 @@
+# Install a pack, then load it
+
+::ana_timeline
+Rendered once "ana" is installed and loaded.
+::

package/dist/conformance/host/13-install-pack-declined/scenario.json

@@ -0,0 +1,10 @@
+{
+  "id": "install-pack-declined",
+  "invariant": "declining the install consent writes nothing: the pack stays uninstalled and removing it reports that it was never installed",
+  "clock": 1700000000000,
+  "actions": [
+    { "type": "open" },
+    { "type": "installPack", "archive": "files/ana-1.0.0", "answers": ["deny"] },
+    { "type": "removePack", "namespace": "ana" }
+  ]
+}

package/dist/conformance/host/14-remove-pack/expected.json

@@ -0,0 +1,14 @@
+{
+  "outcomes": [
+    { "kind": "opened" },
+    { "kind": "installed", "namespace": "ana", "replaced": false },
+    { "kind": "removed", "namespace": "ana" },
+    { "kind": "not-installed", "namespace": "ana" }
+  ],
+  "diagnostics": [
+    "Install pack from file installed pack \"ana\"",
+    "Remove pack removed \"ana\"",
+    "Remove pack found no installed pack \"ana\""
+  ],
+  "prompts": ["Installing \"ana\" lets its code run inside"]
+}

package/dist/conformance/host/14-remove-pack/files/ana-1.0.0/pack.json

@@ -0,0 +1,13 @@
+{
+  "name": "ana",
+  "engine": "react",
+  "version": "1.0.0",
+  "components": {
+    "timeline": {
+      "sources": {
+        "react": "./Timeline.tsx",
+        "ansi": "./Timeline.ansi.tsx"
+      }
+    }
+  }
+}

package/dist/conformance/host/14-remove-pack/files/ana-1.0.0/webview.js

@@ -0,0 +1 @@
+window.__markiiRegisterPack(() => ({}));

package/dist/conformance/host/14-remove-pack/note.mk.md

@@ -0,0 +1,5 @@
+# Install a pack, then load it
+
+::ana_timeline
+Rendered once "ana" is installed and loaded.
+::

package/dist/conformance/host/14-remove-pack/scenario.json

@@ -0,0 +1,11 @@
+{
+  "id": "remove-pack",
+  "invariant": "removing an installed pack deletes its folder; removing it again reports that it is not installed",
+  "clock": 1700000000000,
+  "actions": [
+    { "type": "open" },
+    { "type": "installPack", "archive": "files/ana-1.0.0", "answers": ["allow"] },
+    { "type": "removePack", "namespace": "ana" },
+    { "type": "removePack", "namespace": "ana" }
+  ]
+}

package/dist/conformance/host/15-load-packs-engine-views/expected.json

@@ -0,0 +1,19 @@
+{
+  "outcomes": [
+    { "kind": "opened" },
+    { "kind": "installed", "namespace": "duo", "replaced": false },
+    {
+      "kind": "loaded",
+      "namespaces": ["duo"],
+      "componentCount": 2,
+      "unavailableCount": 1
+    }
+  ],
+  "diagnostics": [
+    "Install pack from file installed pack \"duo\" from \"files/duo-1.0.0\"",
+    "Loaded pack \"duo\" (namespace: duo, 1 component)"
+  ],
+  "prompts": [
+    "Installing \"duo\" lets its code run inside"
+  ]
+}

package/dist/conformance/host/15-load-packs-engine-views/files/duo-1.0.0/pack.json

@@ -0,0 +1,9 @@
+{
+  "name": "duo",
+  "engine": "react",
+  "version": "1.0.0",
+  "components": {
+    "rview": { "sources": { "react": "./RView.tsx" } },
+    "tview": { "sources": { "ansi": "./TView.ansi.tsx" } }
+  }
+}

package/dist/conformance/host/15-load-packs-engine-views/files/duo-1.0.0/webview.js

@@ -0,0 +1 @@
+window.__markiiRegisterPack(() => ({}));

package/dist/conformance/host/15-load-packs-engine-views/note.mk.md

@@ -0,0 +1,9 @@
+# A pack with a view for one engine only
+
+::duo_rview
+Drawn by react hosts, labeled "no view" in the terminal.
+::
+
+::duo_tview
+Drawn by the terminal, labeled "no view" in editors.
+::

package/dist/conformance/host/15-load-packs-engine-views/scenario.json

@@ -0,0 +1,10 @@
+{
+  "id": "load-packs-engine-views",
+  "invariant": "loading packs reports every installed component and the ones this host's engine has no view for",
+  "clock": 1700000000000,
+  "actions": [
+    { "type": "open" },
+    { "type": "installPack", "archive": "files/duo-1.0.0", "answers": ["allow"] },
+    { "type": "loadPacks" }
+  ]
+}

package/dist/conformance/host/16-pack-trust/expected.json

@@ -0,0 +1,37 @@
+{
+  "outcomes": [
+    { "kind": "opened" },
+    { "kind": "installed", "namespace": "ana", "replaced": false },
+    { "kind": "placed", "namespace": "sneaky" },
+    { "kind": "listed", "enabled": ["ana"], "notEnabled": ["sneaky"] },
+    { "kind": "loaded", "namespaces": ["ana"] },
+    { "kind": "enabled", "namespace": "sneaky" },
+    { "kind": "loaded", "namespaces": ["ana", "sneaky"] },
+    { "kind": "disabled", "namespace": "ana" },
+    { "kind": "listed", "enabled": ["sneaky"], "notEnabled": ["ana"] },
+    { "kind": "loaded", "namespaces": ["sneaky"] },
+    { "kind": "enabled", "namespace": "ana" },
+    { "kind": "removed", "namespace": "sneaky" },
+    { "kind": "listed", "enabled": ["ana"], "notEnabled": [] },
+    { "kind": "not-installed", "namespace": "ghost" }
+  ],
+  "diagnostics": [
+    "Install pack from file installed pack \"ana\"",
+    "Loaded pack \"ana\" (namespace: ana, 1 component)",
+    "Pack \"sneaky\" is present but not enabled on this device; it was not loaded.",
+    "Enable pack enabled \"sneaky\"",
+    "Loaded pack \"ana\" (namespace: ana, 1 component)",
+    "Loaded pack \"sneaky\" (namespace: sneaky, 1 component)",
+    "Disable pack disabled \"ana\"",
+    "Loaded pack \"sneaky\" (namespace: sneaky, 1 component)",
+    "Pack \"ana\" is present but not enabled on this device; it was not loaded.",
+    "Enable pack enabled \"ana\"",
+    "Remove pack removed \"sneaky\"",
+    "Enable pack found no installed pack \"ghost\""
+  ],
+  "prompts": [
+    "Installing \"ana\" lets its code run inside",
+    "Installing \"sneaky\" lets its code run inside",
+    "Installing \"ana\" lets its code run inside"
+  ]
+}

package/dist/conformance/host/16-pack-trust/files/ana-1.0.0/pack.json

@@ -0,0 +1,12 @@
+{
+  "name": "ana",
+  "engine": "react",
+  "version": "1.0.0",
+  "components": {
+    "widget": {
+      "sources": {
+        "react": "./Widget.tsx"
+      }
+    }
+  }
+}

package/dist/conformance/host/16-pack-trust/files/ana-1.0.0/webview.js

@@ -0,0 +1 @@
+window.__markiiRegisterPack(() => ({}));

package/dist/conformance/host/16-pack-trust/files/sneaky-1.0.0/pack.json

@@ -0,0 +1,12 @@
+{
+  "name": "sneaky",
+  "engine": "react",
+  "version": "1.0.0",
+  "components": {
+    "widget": {
+      "sources": {
+        "react": "./Widget.tsx"
+      }
+    }
+  }
+}

package/dist/conformance/host/16-pack-trust/files/sneaky-1.0.0/webview.js

@@ -0,0 +1 @@
+window.__markiiRegisterPack(() => ({}));

package/dist/conformance/host/16-pack-trust/note.mk.md

@@ -0,0 +1,5 @@
+# Trust a pack on this device
+
+::ana_widget
+Rendered only while "ana" is enabled on this device.
+::

package/dist/conformance/host/16-pack-trust/scenario.json

@@ -0,0 +1,26 @@
+{
+  "id": "pack-trust",
+  "invariant": "an installed pack folder loads only while this device's trust list names it: a folder that arrives without consent is listed as present and never loaded, and enable, disable, re-enable and remove move the list accordingly",
+  "clock": 1700000000000,
+  "actions": [
+    { "type": "open" },
+    {
+      "type": "installPack",
+      "archive": "files/ana-1.0.0",
+      "answers": ["allow"],
+      "requiresTrust": true
+    },
+    { "type": "placePack", "archive": "files/sneaky-1.0.0", "namespace": "sneaky" },
+    { "type": "listPacks" },
+    { "type": "loadPacks", "requiresTrust": true },
+    { "type": "enablePack", "namespace": "sneaky", "answers": ["allow"] },
+    { "type": "loadPacks", "requiresTrust": true },
+    { "type": "disablePack", "namespace": "ana" },
+    { "type": "listPacks" },
+    { "type": "loadPacks", "requiresTrust": true },
+    { "type": "enablePack", "namespace": "ana", "answers": ["allow"] },
+    { "type": "removePack", "namespace": "sneaky", "requiresTrust": true },
+    { "type": "listPacks" },
+    { "type": "enablePack", "namespace": "ghost" }
+  ]
+}

package/dist/conformance/host/README.md

@@ -0,0 +1,221 @@
+# Host conformance corpus (seed)
+
+Language-agnostic scenarios proving that any `HostAdapter` (VS Code,
+Obsidian, the CLI, or a future host) drives `@markii/host`'s shared
+behaviors the same way. Per the repo rule, this directory is plain data:
+no TypeScript. `packages/markii-host/src/host/conformance-runner.ts` is
+the one place that reads it, drives it through a real adapter, and
+compares the outcome.
+
+## Directory shape
+
+```
+conformance/host/<nn>-<slug>/note.mk.md      the note under test
+conformance/host/<nn>-<slug>/scenario.json   the ordered actions
+conformance/host/<nn>-<slug>/expected.json   the outcomes
+conformance/host/<nn>-<slug>/files/…         optional extra inputs
+```
+
+A scenario that installs a pack ships its archive as a plain `files/<name>/`
+directory (a `pack.json`, a `webview.js`, and so on) rather than a
+committed `.mkp` binary. The runner zips that directory into archive bytes
+at test time (`zipArchiveDirectory`).
+
+## `scenario.json`
+
+```json
+{
+  "id": "run-grant-accepted",
+  "invariant": "one sentence: what every conforming host must do here",
+  "clock": 1700000000000,
+  "actions": [
+    { "type": "open" },
+    {
+      "type": "run",
+      "trigger": "manual",
+      "answers": ["allow"],
+      "simulate": { "name": "total", "value": 3, "requiresHost": "api.example.com" }
+    }
+  ]
+}
+```
+
+Every action has a `type`. The full set, and the capability each one
+needs, is the runner's own `ACTION_CAPABILITY` map:
+
+| action | needs |
+|---|---|
+| `open` | (always supported) |
+| `run` | `isolate` |
+| `exportHtml` | `export-format` (`html`) |
+| `exportAnsi` | `export-format` (`ansi`) |
+| `installPack` | `packs` (and an `installRoot`) |
+| `loadPacks` | `packs` |
+| `removePack` | `packs` (and an `installRoot` plus `removeFolder`) |
+| `placePack` | `pack-trust` |
+| `listPacks` | `pack-trust` |
+| `enablePack` | `pack-trust` |
+| `disablePack` | `pack-trust` |
+| `completeAt` | `editor` |
+| `hoverAt` | `editor` |
+| `insertComponent` | `editor` |
+
+`pack-trust` is declared by an adapter whose pack source sets
+`trust: 'device-list'` (and an `installRoot`): installed packs load only
+while this device's trust list names them. `placePack` copies a scenario
+directory into the install root with no consent and no trust entry, the way
+a pack arrives through a file sync. An `installPack`, `loadPacks` or
+`removePack` action may carry `"requiresTrust": true`, which makes the
+runner treat it as a `pack-trust` action, so a scenario built around the
+trust list reports `unsupported` as a whole on a host that trusts its own
+install store.
+
+`clock` fixes `adapter.now()` for the whole scenario, so a `RunTrace`
+write is byte-stable.
+
+`run` and `installPack` actions carry an optional `answers` array:
+`"allow"`/`"deny"`, consumed by the grant/consent prompts in document
+order across the WHOLE scenario, not just within one action (a scenario
+with two consecutive prompts pulls its second answer from the same
+queue). A prompt asked with no answer left is an ERROR the runner
+reports, never a silent deny: it means the scenario and the
+implementation disagree about how many questions get asked, which is
+exactly the drift this corpus exists to catch.
+
+A `run` action's `simulate` field stands in for what a real Lua isolate
+would have produced:
+
+```json
+{ "name": "total", "value": 3, "requiresHost": "api.example.com", "requiresManualTier": false }
+```
+
+- `name`: the script/value name the simulated run reports on.
+- `value`: what a successful simulated run stores (default `1`).
+- `requiresHost`: the run reports `capability-denied` unless this host is
+  in the run's granted allowlist. The allowlist itself is REAL: the note's
+  own script is scanned for `net.*` calls, and the grant flow prompts for
+  and persists exactly what it always does. Only the isolate that would
+  execute the script is faked.
+- `requiresManualTier`: the run reports `tier-blocked` under any trigger
+  but `'manual'`, regardless of grants — the same enforcement the real
+  sandbox applies to an effectful call under a read-only trigger.
+
+Faking the isolate keeps this corpus fast and deterministic. It proves the
+HOST-LEVEL plumbing — grant prompts, wording, capability declarations,
+trigger forwarding — is identical across hosts. Real sandbox enforcement
+(the tier gate, the net allowlist, the marshal boundary) is
+`conformance/executor/`'s job and is not duplicated here.
+
+A `run` action can also carry `"scriptsDisabled": true`. This is not a
+`HostAdapter` capability: the device-local scripts-off switch is decided
+by each app's own call site before it ever reaches the isolate, over the
+shared, host-neutral wording in `@markii/host`'s `script-execution.ts`.
+The runner reproduces that same pre-check here, over the same functions
+and the adapter's own `labels`, so the scenario proves wording parity
+without inventing a capability the contract does not have. When this
+field is set, the action never reaches `host.run` at all.
+
+## `expected.json`
+
+```json
+{
+  "outcomes": [
+    { "kind": "opened" },
+    { "kind": "ran", "values": { "total": 3 }, "failureKinds": [] },
+    { "kind": "exported", "contains": ["mk-callout"], "excludes": ["<script"] }
+  ],
+  "diagnostics": ["one line per expected diagnostics write, in order"],
+  "prompts": ["the message text of each prompt asked, in order"]
+}
+```
+
+`outcomes[i]` corresponds to `actions[i]`. Comparisons are deliberately
+coarse, matching each `kind`:
+
+- `ran`: `values` compares the landed, non-error `StoredValue`s by name
+  (`{name: value}`); `failureKinds` compares the closed `FailureKind`
+  taxonomy only, never a raw message or a timing; an optional `traceOk`
+  compares the recorded run trace's `ok` flag.
+- `exported`: `contains`/`excludes` are substrings checked against the
+  written file's content, never the whole document — the render corpora
+  already pin bytes.
+- `installed`: `namespace` and `replaced`.
+- `declined`: `step` (`'consent'`/`'replace'`, or absent for the
+  scripts-disabled synthetic outcome) and `reasonContains`, a substring of
+  the user-facing reason.
+- `listed`: `enabled` and `notEnabled`, namespace lists, order-independent.
+- `enabled`, `disabled`, `placed`, `removed`: `namespace`.
+- `loaded`: `namespaces`, order-independent.
+- `completions`: `labels`, checked as "every one of these appears",
+  not an exact set (a pack-aware host's catalog is a superset of the
+  standard one). Optional `replaceStart`, `replaceEnd`, and `tokenStart`
+  compare the column span an accepted item replaces and where filtering
+  starts; `fenceEditCount` compares how many fence rewrites travel with an
+  accepted container item.
+- `hover`: `contains`, a substring of the hover text. Optional `start` and
+  `end` compare the hovered name's columns.
+- every other `kind` (`opened`, `none`, `not-found`, `failed`, `rejected`,
+  `reserved`, `cancelled`, `inserted`): `kind` equality is the whole check.
+
+An action whose capability the adapter under test does not declare is
+never diffed against `expected.json` at all (see "Capability handling"
+below) — `expected.json` always describes the FULLY CAPABLE host's
+correct behavior, even for a scenario where one real host today has
+nothing to compare it to.
+
+`diagnostics` and `prompts` are matched pairwise, in order, by substring
+containment (`actual[i].includes(expected[i])`), with the array LENGTHS
+required to match exactly. Substring containment absorbs a host's own
+sink additions (Obsidian's `[markii] ` console prefix, a device noun
+difference) without the corpus having to spell out three wordings for
+one behavior. Diagnostics lines written by a capability decline itself
+(`declined (<capability> unsupported on <host>): …`) are filtered out of
+the actual list before this comparison, since that line exists only
+because the capability was ABSENT — it is not part of what
+`expected.json` describes.
+
+`prompts` is load-bearing: it proves all three hosts ask the same
+questions, worded the same way, in the same order — the single most
+security-relevant parity property in this batch.
+
+## Capability handling (the crux)
+
+The corpus never encodes per-host knowledge. `ACTION_CAPABILITY`
+(`conformance-runner.ts`) is the one static map from an action's type to
+the capability it needs. When the adapter under test does not declare
+that capability, the runner produces `{ "kind": "unsupported",
+"capability": "<name>" }` for that action and never diffs it against
+`expected.json`. An app's conformance test asserts: for every action
+whose capability this adapter declares, the outcome equals
+`expected.json`'s; for every other action, the outcome is exactly the
+`unsupported` record.
+
+This is what lets the CLI, which declares no `editor`,
+run the whole corpus honestly: its result records say `unsupported`
+where it genuinely offers nothing, which is the truth and is visible,
+rather than a skipped test or a faked empty answer.
+
+## The sixteen scenarios
+
+| id | what it proves |
+|---|---|
+| `01-plain-open` | a note with no scripts and no packs opens, renders, writes no diagnostics |
+| `02-run-manual-grant-accepted` | manual tier, one network host, prompt asked with the canonical wording, grant stored, value lands |
+| `03-run-manual-grant-refused` | the same prompt, refused, no value lands, the run reports on both surfaces |
+| `04-run-auto-write-denied` | an auto trigger is read-only: a write attempt is denied by the tier gate, not by luck |
+| `05-export-html-pack-directive` | a pack directive the host did not load exports as the unknown-component fallback, and the export excludes script machinery |
+| `06-install-pack-then-render` | installing a `.mkp` loads its namespace; a second install of the same namespace asks before replacing |
+| `07-complete-in-directive` | completion inside a directive returns the standard set |
+| `08-hover-standard-component` | hover on a standard component returns its documented attributes |
+| `09-insert-skeleton` | inserting a component applies one edit |
+| `10-scripts-disabled` | the device switch blocks the run before the isolate, and says so on both surfaces |
+| `11-complete-closing-fence` | a bare colon run that closes an open container offers nothing, as `none` rather than a failure |
+| `12-complete-nested-container` | completing a container inside an equal-length container carries the fence edits that keep the pair legal |
+| `13-install-pack-declined` | declining the install consent writes nothing, and removing the never-installed pack reports it |
+| `14-remove-pack` | removing an installed pack deletes it; removing it again reports it is not installed |
+| `15-load-packs-engine-views` | loading packs reports every installed component and, as `unavailable`, the ones this host's engine has no view for |
+| `16-pack-trust` | a folder that arrives without consent is listed as present and never loaded; enable, disable, re-enable and remove move the device trust list; a host without the list reports the whole scenario `unsupported` |
+
+See `tmp/W11-phase3.md` for which capabilities each of the three real
+adapters currently declares, and which scenarios are consequently
+`unsupported` on every host today (a reported gap, not a corpus defect).

package/dist/conformance.d.ts

@@ -0,0 +1,2 @@
+export { ACTION_CAPABILITY, assertHostScenario, containsInOrder, createAnswerQueue, hostConformanceDir, hostDeclaresCapability, listHostScenarioNames, loadHostScenario, outcomeMismatches, runHostScenario, zipArchiveDirectory, } from './host/conformance-runner.js';
+export type { HostScenario, HostScenarioAction, HostScenarioCapability, HostScenarioExpected, HostScenarioRunResult, LoadedHostScenario, RunSimulation, } from './host/conformance-runner.js';

package/dist/conformance.js

@@ -0,0 +1,5 @@
+// @markii/host/conformance: the host conformance runner. Node only (it reads
+// the corpus from disk and drives a real adapter). A host's adapter test
+// imports this to run `conformance/host/` against its own `HostAdapter`.
+// The corpus ships inside the package at `dist/conformance/host/`.
+export { ACTION_CAPABILITY, assertHostScenario, containsInOrder, createAnswerQueue, hostConformanceDir, hostDeclaresCapability, listHostScenarioNames, loadHostScenario, outcomeMismatches, runHostScenario, zipArchiveDirectory, } from './host/conformance-runner.js';

package/dist/diagnostics/render-diagnostics.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The one place a render-time diagnostic event becomes a line on a host's
+ * diagnostics surface (docs/integration.md's host checklist, item 9).
+ *
+ * Both renderers report a quiet in-page marker through their `onDiagnostic`
+ * render option (`@markii/stdlib`'s `DiagnosticEvent`). The marker alone
+ * satisfies half of AGENTS.md's "clean is not silent" rule: the other half
+ * is a full diagnostic somewhere a reader can find without opening
+ * developer tools. This module turns one event into the line both hosts
+ * write, so the VS Code output channel and the Obsidian console cannot word
+ * the same finding differently.
+ *
+ * Node-free, so `../browser.ts` can export it to a browser bundle (the VS
+ * Code webview, which is where the React render actually runs).
+ */
+import type { DiagnosticEvent, OnDiagnostic } from '@markii/stdlib';
+/**
+ * One diagnostic event as a single line. The event's own `message` is the
+ * engine's failure-presentation wording, reused verbatim rather than
+ * reworded here; this only adds who it happened to.
+ */
+export declare function renderDiagnosticLine(event: DiagnosticEvent): string;
+/**
+ * An `onDiagnostic` callback that writes each DISTINCT line once through
+ * `log`. A preview re-renders on every keystroke, and a note with one bad
+ * attribute value would otherwise write the same line hundreds of times
+ * into a log a reader is supposed to be able to scan. The dedupe is per
+ * collector, so a host creates one per note and drops it when the note
+ * closes.
+ */
+export declare function createRenderDiagnosticReporter(log: (line: string) => void): OnDiagnostic;
+/**
+ * A collector for a host that cannot log during the render itself, such as
+ * a webview that has to post its findings to an extension host afterwards.
+ * `onDiagnostic` goes to the render; `lines()` is read once the render has
+ * returned, already deduped and in the order the renderer found them.
+ */
+export declare function createRenderDiagnosticCollector(): {
+    readonly onDiagnostic: OnDiagnostic;
+    readonly lines: () => string[];
+};

package/dist/diagnostics/render-diagnostics.js

@@ -0,0 +1,46 @@
+/** The prefix every render-diagnostic line carries, so a reader can tell it from a pack or run line in the same log. */
+const RENDER_DIAGNOSTIC_PREFIX = 'Render';
+/**
+ * One diagnostic event as a single line. The event's own `message` is the
+ * engine's failure-presentation wording, reused verbatim rather than
+ * reworded here; this only adds who it happened to.
+ */
+export function renderDiagnosticLine(event) {
+    const where = event.directive === undefined
+        ? ''
+        : event.attribute === undefined
+            ? ` in ${event.directive}`
+            : ` in ${event.directive}'s ${event.attribute}`;
+    return `${RENDER_DIAGNOSTIC_PREFIX}${where}: ${event.message}`;
+}
+/**
+ * An `onDiagnostic` callback that writes each DISTINCT line once through
+ * `log`. A preview re-renders on every keystroke, and a note with one bad
+ * attribute value would otherwise write the same line hundreds of times
+ * into a log a reader is supposed to be able to scan. The dedupe is per
+ * collector, so a host creates one per note and drops it when the note
+ * closes.
+ */
+export function createRenderDiagnosticReporter(log) {
+    const reported = new Set();
+    return (event) => {
+        const line = renderDiagnosticLine(event);
+        if (reported.has(line))
+            return;
+        reported.add(line);
+        log(line);
+    };
+}
+/**
+ * A collector for a host that cannot log during the render itself, such as
+ * a webview that has to post its findings to an extension host afterwards.
+ * `onDiagnostic` goes to the render; `lines()` is read once the render has
+ * returned, already deduped and in the order the renderer found them.
+ */
+export function createRenderDiagnosticCollector() {
+    const collected = [];
+    const onDiagnostic = createRenderDiagnosticReporter((line) => {
+        collected.push(line);
+    });
+    return { onDiagnostic, lines: () => [...collected] };
+}