@markii/host 0.17.0-next.4 → 0.17.0-next.6

package/dist/conformance/host/17-export-linked-set/expected.json

@@ -0,0 +1,17 @@
+{
+  "outcomes": [
+    {
+      "kind": "exported",
+      "noteCount": 2,
+      "entries": ["index.html", "note.html", "second.html"]
+    }
+  ],
+  "diagnostics": [
+    "Cascade export wrote",
+    "Exported",
+    "Rendered with the static engine because no pack components are loaded",
+    "Exported",
+    "Rendered with the static engine because no pack components are loaded"
+  ],
+  "prompts": []
+}

package/dist/conformance/host/17-export-linked-set/files/second.mk.md

@@ -0,0 +1,3 @@
+# Second note
+
+A page that the root note links to.

package/dist/conformance/host/17-export-linked-set/note.mk.md

@@ -0,0 +1,4 @@
+# Linked set
+
+This note links to [a second note](files/second.mk.md) and to
+[a page outside the set](https://example.com/page).

package/dist/conformance/host/17-export-linked-set/scenario.json

@@ -0,0 +1,6 @@
+{
+  "id": "export-linked-set",
+  "invariant": "a note and the notes it links to export as one archive with an index page, and a host that does not offer the export reports it unsupported",
+  "clock": 1700000000000,
+  "actions": [{ "type": "exportLinkedSet" }]
+}

package/dist/conformance/host/18-last-run-and-grants/expected.json

@@ -0,0 +1,42 @@
+{
+  "outcomes": [
+    { "kind": "lastRun", "values": {} },
+    {
+      "kind": "ran",
+      "values": { "total": 3 },
+      "failureKinds": [],
+      "traceOk": true
+    },
+    {
+      "kind": "lastRun",
+      "values": { "total": 3 },
+      "valueStatuses": { "total": "stale" },
+      "traceOk": true
+    },
+    {
+      "kind": "ran",
+      "values": { "total": 3 },
+      "failureKinds": [],
+      "traceOk": true
+    },
+    { "kind": "forgotten" },
+    {
+      "kind": "ran",
+      "values": { "total": 3 },
+      "failureKinds": [],
+      "traceOk": true
+    }
+  ],
+  "diagnostics": [
+    "manual run: net declaration mismatch",
+    "uses net access to api.example.com",
+    "manual run: net declaration mismatch",
+    "uses net access to api.example.com",
+    "manual run: net declaration mismatch",
+    "uses net access to api.example.com"
+  ],
+  "prompts": [
+    "This note's scripts can send data to api.example.com. Allow?",
+    "This note's scripts can send data to api.example.com. Allow?"
+  ]
+}

package/dist/conformance/host/18-last-run-and-grants/note.mk.md

@@ -0,0 +1,5 @@
+# Last run and grants
+
+```lua {name=total}
+return net.fetch_json("https://api.example.com/orders")
+```

package/dist/conformance/host/18-last-run-and-grants/scenario.json

@@ -0,0 +1,27 @@
+{
+  "id": "last-run-and-grants",
+  "invariant": "a run's values and trace can be read back with no storage key, and clearing the stored grants makes the next manual run prompt again",
+  "clock": 1700000000000,
+  "actions": [
+    { "type": "lastRun" },
+    {
+      "type": "run",
+      "trigger": "manual",
+      "answers": ["allow"],
+      "simulate": { "name": "total", "value": 3, "requiresHost": "api.example.com" }
+    },
+    { "type": "lastRun" },
+    {
+      "type": "run",
+      "trigger": "manual",
+      "simulate": { "name": "total", "value": 3, "requiresHost": "api.example.com" }
+    },
+    { "type": "forgetGrants" },
+    {
+      "type": "run",
+      "trigger": "manual",
+      "answers": ["allow"],
+      "simulate": { "name": "total", "value": 3, "requiresHost": "api.example.com" }
+    }
+  ]
+}

package/dist/conformance/host/README.md

@@ -47,8 +47,11 @@ needs, is the runner's own `ACTION_CAPABILITY` map:
 |---|---|
 | `open` | (always supported) |
 | `run` | `isolate` |
+| `lastRun` | (always supported) |
+| `forgetGrants` | (always supported) |
 | `exportHtml` | `export-format` (`html`) |
 | `exportAnsi` | `export-format` (`ansi`) |
+| `exportLinkedSet` | `linked-set-export` (a `resolveLinkedSetTarget`) |
 | `installPack` | `packs` (and an `installRoot`) |
 | `loadPacks` | `packs` |
 | `removePack` | `packs` (and an `installRoot` plus `removeFolder`) |
@@ -97,12 +100,12 @@ would have produced:
   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
+  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
+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.
 
@@ -136,15 +139,21 @@ coarse, matching each `kind`:
   (`{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.
+- `lastRun`: `values` compares the stored values shown on open, by name,
+  like `ran`. `valueStatuses` compares each value's status by name, and
+  `traceOk` compares the recorded trace's `ok` flag.
 - `exported`: `contains`/`excludes` are substrings checked against the
-  written file's content, never the whole document — the render corpora
+  written file's content, never the whole document, the render corpora
   already pin bytes. `valueCount` is how many last-run values were baked
   in, and `renderEngine` (`static` or `react`) is which engine drew the body.
+  A linked-set export is an `exported` outcome too: `noteCount` is how many
+  notes the archive holds, and `entries` is its sorted file names.
 - `installed`: `namespace` and `replaced`, and `installedDirName`, the name
   of the folder the pack was unzipped into.
 - `declined`: `step` (`'consent'`/`'replace'`, or absent for the
   scripts-disabled synthetic outcome) and `reasonContains`, a substring of
-  the user-facing reason.
+  the user-facing reason. A user's "no" to a prompt and a cancelled picker
+  are both `declined`.
 - `listed`: `enabled` and `notEnabled`, namespace lists, order-independent.
 - `enabled`, `disabled`, `placed`, `removed`: `namespace`.
 - `loaded`: `namespaces`, order-independent.
@@ -156,12 +165,12 @@ coarse, matching each `kind`:
   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.
+- every other `kind` (`opened`, `none`, `not-found`, `failed`, `invalid`,
+  `reserved`, `forgotten`, `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
+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.
 
@@ -173,11 +182,11 @@ 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
+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
+questions, worded the same way, in the same order, the single most
 security-relevant parity property in this batch.
 
 ## Capability handling (the crux)
@@ -197,7 +206,7 @@ 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
+## The scenarios
 
 | id | what it proves |
 |---|---|
@@ -217,7 +226,8 @@ rather than a skipped test or a faked empty answer.
 | `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` |
+| `17-export-linked-set` | a note and the notes it links to export as one archive with an index page; a host with no linked-set target reports `unsupported` |
+| `18-last-run-and-grants` | a run's values and trace read back through `lastRun` with no storage key, and clearing the grants makes the next manual run prompt again |
 
-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).
+The capabilities an adapter declares decide which scenarios report
+`unsupported` on that host. That is a reported gap and not a corpus defect.

package/dist/conformance.d.ts

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

package/dist/conformance.js

@@ -2,4 +2,4 @@
 // 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';
+export { assertHostScenario, createAnswerQueue, hostConformanceDir, listHostScenarioNames, loadHostScenario, runHostScenario, } from './host/conformance-runner.js';

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

@@ -1,6 +1,6 @@
 /**
  * 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).
+ * diagnostics surface (docs/hosts.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

package/dist/host/adapter.d.ts

@@ -54,9 +54,9 @@ export type HostIsolate = {
      */
     workerPath(): string;
     /**
-     * Creates the worker-thread isolate: `workerThreadIsolate` from
-     * `@markii/host/node`. Injected so the shared run path imports
-     * nothing from `node:*`.
+     * Creates the worker-thread isolate. `createNodeHostIsolate()` from
+     * `@markii/host/node` supplies it. Injected so the shared run path
+     * imports nothing from `node:*`.
      */
     readonly spawnIsolate: IsolateSpawner;
 } | {
@@ -155,12 +155,34 @@ export interface HostPackSource {
 }
 /** Every export format any host offers today. */
 export type HostExportFormat = 'html' | 'pdf' | 'ansi' | 'md-plain';
+/**
+ * What a host declares to offer exports. A request can carry its own
+ * `targetPath`, so a host with no picker (the command line tool, or a call
+ * site that already knows where the file goes) leaves the resolvers out.
+ *
+ * A single-note export needs `exports` declared with the format in
+ * `formats`, and a destination: either a `resolveTarget` or the request's
+ * `targetPath`. Without a destination it answers `unsupported`.
+ *
+ * The linked-set export is offered when `exports` is declared and the host
+ * has a `resolveLinkedSetTarget` or the request carries a `targetPath`.
+ * Without either it answers `unsupported`. A host that declares `exports`
+ * with neither resolver, such as the command line tool, therefore offers
+ * the linked-set export only to a caller that names the path.
+ */
 export interface HostExportCapabilities {
     readonly formats: ReadonlySet<HostExportFormat>;
-    /** GUI hosts show a picker; the CLI returns the path it was given. */
-    resolveTarget(suggestedFileName: string, format: HostExportFormat): Promise<string | undefined>;
+    /** GUI hosts show a picker; the CLI returns the path it was given. Resolves `undefined` when the user cancels. Absent for a host whose callers always pass `targetPath`. */
+    resolveTarget?(suggestedFileName: string, format: HostExportFormat): Promise<string | undefined>;
     /** Only present on a host declaring `'pdf'`. The one Electron-touching seam. */
     htmlToPdf?(html: string): Promise<Uint8Array>;
+    /**
+     * Names the zip archive of a linked-set export, or resolves `undefined`
+     * when the user cancels. A host can offer single-note export without it
+     * (the command line tool does), so it is a member of its own rather than
+     * a `HostExportFormat`.
+     */
+    resolveLinkedSetTarget?(suggestedFileName: string): Promise<string | undefined>;
 }
 /**
  * The wording nouns every shared behavior's message templates interpolate
@@ -210,7 +232,7 @@ export interface HostAdapter {
      * through with no adapter wrapper at all.
      */
     readonly memento: GrantMemento;
-    /** One diagnostics line on this host's designated surface (docs/integration.md). */
+    /** One diagnostics line on this host's designated surface (docs/hosts.md). */
     diagnostics(line: string): void;
     now(): number;
     readonly isolate?: HostIsolate;

package/dist/host/cascade-export-behavior.d.ts

@@ -5,11 +5,12 @@
  * produces. Written once so the hosts cannot drift on what a cascade is
  * or what it says.
  *
- * Deliberately outside `createMarkiiHost`: choosing where the archive goes
- * and writing it are each host's own picker and file-system business, so
- * this module builds the bytes and words the outcome, and the host writes
- * and displays. The per-host nouns (which surface holds the details) come
- * from `HostLabels`, never from a literal here.
+ * `createMarkiiHost`'s `exportLinkedSet` drives it: the host's picker
+ * names the archive's path (`adapter.exports.resolveLinkedSetTarget`), the
+ * notes are read through `adapter.readFile`, the archive is written through
+ * `adapter.writeFile`, and the diagnostics lines go to `adapter.diagnostics`.
+ * The per-host nouns (which surface holds the details) come from
+ * `HostLabels`, never from a literal here.
  *
  * BOUNDS ARE FIXED. The walk always uses `DEFAULT_CASCADE_MAX_DEPTH` and
  * `DEFAULT_CASCADE_MAX_NOTES`; nothing here lets a caller override them.
@@ -19,7 +20,8 @@ import type { OnDiagnostic, UnavailableComponent } from '@markii/stdlib';
 import type { CascadeLinkResolver, CascadeNoteReader, CascadeTruncation } from '../export/cascade.js';
 import type { HtmlExportEngine, ExportBodyRenderer, ExportPackStylesheet, ExportRenderInfo, StaticExportReason } from '../export/note-export.js';
 import type { EmbeddedImageReport, ExportImageReader } from '../export/image-embed.js';
-import type { HostLabels } from './adapter.js';
+import type { HostAdapter, HostLabels } from './adapter.js';
+import type { ExportLinkedSetOutcome } from './create-host.js';
 /** One note the cascade exported, for the diagnostics surface. */
 export interface CascadeExportedNote {
     /** The note's own path, in the same form the reader and resolver use. */
@@ -37,7 +39,7 @@ export interface UnreadableCascadeNote {
 }
 /** What one cascade export attempt did, for both the message and the diagnostics lines. */
 export type CascadeExportOutcome = {
-    readonly kind: 'written';
+    readonly kind: 'exported';
     /** The written archive's display path. */
     readonly path: string;
     readonly bytes: number;
@@ -109,7 +111,7 @@ export declare function buildCascadeArchive(request: CascadeArchiveRequest): Pro
  * failure says what failed and points at the same surface, never at a
  * stack trace.
  */
-export declare function cascadeResultMessage(outcome: CascadeExportOutcome, labels: HostLabels, where?: string): string;
+export declare function cascadeResultMessage(outcome: ExportLinkedSetOutcome, labels: HostLabels, where?: string): string;
 /**
  * The lines for the host's diagnostics surface for one cascade export:
  * every note reached named with the file it became, every note skipped
@@ -118,3 +120,19 @@ export declare function cascadeResultMessage(outcome: CascadeExportOutcome, labe
  * deliberately omits.
  */
 export declare function cascadeDiagnosticLines(outcome: CascadeExportOutcome): string[];
+/** What `exportLinkedSetViaAdapter` needs beyond the adapter: the static engine and the request's own seams. */
+export interface LinkedSetExportInputs extends Omit<CascadeArchiveRequest, 'readNote'> {
+    /** The suggested archive file name handed to the host's picker. */
+    readonly suggestedFileName: string;
+    /** Where to write the archive. When present the adapter's `resolveLinkedSetTarget` is not asked. */
+    readonly targetPath?: string;
+}
+/**
+ * Exports a note and the notes it links to as one archive: resolves the
+ * target through the adapter's picker, builds the archive reading every
+ * note through `adapter.readFile`, writes it through `adapter.writeFile`,
+ * and sends the diagnostics lines to `adapter.diagnostics`. Resolves
+ * `undefined` when the host has no linked-set target or its picker was
+ * cancelled. A `targetPath` skips the picker. Never throws.
+ */
+export declare function exportLinkedSetViaAdapter(adapter: HostAdapter, inputs: LinkedSetExportInputs): Promise<CascadeExportOutcome | undefined>;

package/dist/host/cascade-export-behavior.js

@@ -109,7 +109,7 @@ export async function buildCascadeArchive(request) {
  * stack trace.
  */
 export function cascadeResultMessage(outcome, labels, where) {
-    if (outcome.kind === 'failed') {
+    if (outcome.kind !== 'exported') {
         return `Markii: could not export this cascade. Open ${labels.diagnosticsSurface} for details.`;
     }
     const name = fileNameOf(outcome.path);
@@ -149,3 +149,66 @@ export function cascadeDiagnosticLines(outcome) {
     }
     return lines;
 }
+/**
+ * Exports a note and the notes it links to as one archive: resolves the
+ * target through the adapter's picker, builds the archive reading every
+ * note through `adapter.readFile`, writes it through `adapter.writeFile`,
+ * and sends the diagnostics lines to `adapter.diagnostics`. Resolves
+ * `undefined` when the host has no linked-set target or its picker was
+ * cancelled. A `targetPath` skips the picker. Never throws.
+ */
+export async function exportLinkedSetViaAdapter(adapter, inputs) {
+    const resolveTarget = adapter.exports?.resolveLinkedSetTarget;
+    const { suggestedFileName, targetPath, ...archiveRequest } = inputs;
+    if (targetPath === undefined && resolveTarget === undefined) {
+        return undefined;
+    }
+    let path;
+    let outcome;
+    try {
+        path =
+            targetPath ??
+                (await resolveTarget?.call(adapter.exports, suggestedFileName));
+        if (path === undefined)
+            return undefined;
+        const target = path;
+        const archive = await buildCascadeArchive({
+            ...archiveRequest,
+            readNote: async (notePath) => {
+                try {
+                    return new TextDecoder().decode(await adapter.readFile(notePath));
+                }
+                catch {
+                    return undefined;
+                }
+            },
+        });
+        if (archive.kind === 'failed') {
+            outcome = { kind: 'failed', path: target, reason: archive.reason };
+        }
+        else {
+            await adapter.writeFile(target, archive.bytes);
+            outcome = {
+                kind: 'exported',
+                path: target,
+                bytes: archive.bytes.byteLength,
+                notes: archive.notes,
+                unreadable: archive.unreadable,
+                ...(archive.truncated !== undefined
+                    ? { truncated: archive.truncated }
+                    : {}),
+            };
+        }
+    }
+    catch (error) {
+        outcome = {
+            kind: 'failed',
+            ...(path !== undefined ? { path } : {}),
+            reason: cascadeReasonOf(error),
+        };
+    }
+    for (const line of cascadeDiagnosticLines(outcome)) {
+        adapter.diagnostics(line);
+    }
+    return outcome;
+}

package/dist/host/conformance-runner.d.ts

@@ -31,10 +31,20 @@ export type HostScenarioAction = {
     /** When `true`, this action never reaches `host.run` at all — see this file's top comment on the scripts-disabled scenario. */
     readonly scriptsDisabled?: boolean;
     readonly simulate?: RunSimulation;
+}
+/** Reads what the note's last run left: the values to show on open and the trace. */
+ | {
+    readonly type: 'lastRun';
+}
+/** Clears the note's stored script grants. */
+ | {
+    readonly type: 'forgetGrants';
 } | {
     readonly type: 'exportHtml';
 } | {
     readonly type: 'exportAnsi';
+} | {
+    readonly type: 'exportLinkedSet';
 } | {
     readonly type: 'installPack';
     /** A directory under the scenario's own folder (e.g. `"files/ana-1.0.0"`), zipped into `.mkp` bytes by this module — never a committed binary. */
@@ -98,7 +108,7 @@ export interface LoadedHostScenario {
 export declare function loadHostScenario(name: string, baseDir?: string): LoadedHostScenario;
 /** Zips a scenario's `files/<name>` directory into `.mkp` archive bytes on the fly — this is how the corpus ships pack fixtures as plain files instead of a committed binary. */
 export declare function zipArchiveDirectory(archiveDir: string): Uint8Array;
-export type HostScenarioCapability = 'isolate' | 'editor' | 'packs' | 'pack-trust' | 'export-format';
+export type HostScenarioCapability = 'isolate' | 'editor' | 'packs' | 'pack-trust' | 'export-format' | 'linked-set-export';
 /** The one static map from an action's type to the capability it needs. `undefined` means every host supports it (there is nothing to decline). */
 export declare const ACTION_CAPABILITY: Readonly<Record<HostScenarioAction['type'], HostScenarioCapability | undefined>>;
 /** Whether `adapter` declares the capability `action` needs. Never consults the scenario or `expected.json` — only the adapter under test. */

package/dist/host/conformance-runner.js

@@ -37,14 +37,14 @@
  * Every OTHER action runs through the real, unmocked shared behavior code.
  */
 import { existsSync, readFileSync, readdirSync } from 'node:fs';
-import { dirname } from 'node:path';
+import { dirname, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { createHtmlExportEngine } from '../html-engine.js';
 import { usesPackTrust } from './pack-trust-behavior.js';
 import { join, relative, sep } from 'node:path';
-import { zipSync } from 'fflate';
+import { unzipSync, zipSync } from 'fflate';
 import { conformanceDir } from '@markii/core/corpus';
-import { createMarkiiHost, } from './create-host.js';
+import { createMarkiiHostWithSeams, } from './create-host.js';
 import { scriptsDisabledDiagnosticLine, scriptsDisabledNotice, } from './script-execution.js';
 // --- corpus location ----------------------------------------------------
 /**
@@ -99,8 +99,11 @@ export function zipArchiveDirectory(archiveDir) {
 export const ACTION_CAPABILITY = {
     open: undefined,
     run: 'isolate',
+    lastRun: undefined,
+    forgetGrants: undefined,
     exportHtml: 'export-format',
     exportAnsi: 'export-format',
+    exportLinkedSet: 'linked-set-export',
     installPack: 'packs',
     loadPacks: 'packs',
     removePack: 'packs',
@@ -136,6 +139,9 @@ export function hostDeclaresCapability(adapter, action) {
         return adapter.isolate !== undefined;
     if (capability === 'editor')
         return adapter.editor !== undefined;
+    if (capability === 'linked-set-export') {
+        return adapter.exports?.resolveLinkedSetTarget !== undefined;
+    }
     if (capability === 'packs') {
         if (adapter.packs === undefined)
             return false;
@@ -254,7 +260,7 @@ export async function runHostScenario(adapter, scenario, noteText, scenarioDir,
         },
     };
     let currentSimulation;
-    const host = createMarkiiHost(recording, {
+    const host = createMarkiiHostWithSeams(recording, {
         // The runner is Node-only test tooling, so it supplies the real Node
         // implementations of the seams the host layer takes by injection.
         htmlEngine: createHtmlExportEngine(),
@@ -320,6 +326,18 @@ async function runOneAction(host, adapter, action, ctx) {
                 trigger: action.trigger,
             });
         }
+        case 'lastRun': {
+            const last = host.lastRun(ctx.notePath);
+            return {
+                kind: 'lastRun',
+                values: last.values,
+                persistedValues: last.persistedValues,
+                ...(last.trace !== undefined ? { trace: last.trace } : {}),
+            };
+        }
+        case 'forgetGrants':
+            await host.forgetGrants(ctx.notePath);
+            return { kind: 'forgotten' };
         case 'exportHtml':
         case 'exportAnsi': {
             const outcome = await host.exportNote({
@@ -329,6 +347,24 @@ async function runOneAction(host, adapter, action, ctx) {
             });
             return augmentExportOutcome(outcome, ctx.writtenFiles);
         }
+        case 'exportLinkedSet': {
+            const outcome = await host.exportLinkedSet({
+                rootPath: ctx.notePath,
+                // A markdown link to a note file that exists beside the linking
+                // note: the same rule for every host, so the archive's contents
+                // do not depend on which host runs the scenario.
+                resolveLink: (link, fromNotePath) => {
+                    if (link.kind !== 'markdown')
+                        return undefined;
+                    const target = resolve(dirname(fromNotePath), link.path);
+                    return target.endsWith('.md') && existsSync(target)
+                        ? target
+                        : undefined;
+                },
+                readValues: () => ({}),
+            });
+            return augmentLinkedSetOutcome(outcome, ctx.writtenFiles);
+        }
         case 'installPack': {
             const archiveBytes = zipArchiveDirectory(join(ctx.scenarioDir, action.archive));
             return host.installPack({ archiveBytes, archivePath: action.archive });
@@ -361,6 +397,13 @@ async function runOneAction(host, adapter, action, ctx) {
             return host.insertComponent({ name: action.name });
     }
 }
+function augmentLinkedSetOutcome(outcome, writtenFiles) {
+    if (outcome.kind !== 'exported')
+        return outcome;
+    const bytes = writtenFiles.get(outcome.path);
+    const entries = bytes === undefined ? undefined : Object.keys(unzipSync(bytes)).sort();
+    return { ...outcome, noteCount: outcome.notes.length, entries };
+}
 function augmentExportOutcome(outcome, writtenFiles) {
     if (outcome.kind !== 'exported')
         return outcome;
@@ -446,6 +489,30 @@ export function outcomeMismatches(actual, expected) {
             }
             break;
         }
+        case 'lastRun': {
+            const wantValues = expected['values'] ?? {};
+            const gotValues = landedValues(actualRecord['values']);
+            if (JSON.stringify(gotValues) !== JSON.stringify(wantValues)) {
+                mismatches.push(`values: expected ${JSON.stringify(wantValues)}, got ${JSON.stringify(gotValues)}`);
+            }
+            if (expected['valueStatuses'] !== undefined) {
+                const statuses = {};
+                const raw = (actualRecord['values'] ?? {});
+                for (const [name, entry] of Object.entries(raw)) {
+                    statuses[name] = entry.status;
+                }
+                if (JSON.stringify(statuses) !== JSON.stringify(expected['valueStatuses'])) {
+                    mismatches.push(`value statuses: expected ${JSON.stringify(expected['valueStatuses'])}, got ${JSON.stringify(statuses)}`);
+                }
+            }
+            if (expected['traceOk'] !== undefined) {
+                const trace = actualRecord['trace'];
+                if (trace?.ok !== expected['traceOk']) {
+                    mismatches.push(`trace.ok: expected ${String(expected['traceOk'])}, got ${String(trace?.ok)}`);
+                }
+            }
+            break;
+        }
         case 'exported': {
             if (expected['valueCount'] !== undefined &&
                 actualRecord['valueCount'] !== expected['valueCount']) {
@@ -457,6 +524,15 @@ export function outcomeMismatches(actual, expected) {
                     mismatches.push(`render engine: expected "${String(expected['renderEngine'])}", got "${String(render?.engine)}"`);
                 }
             }
+            if (expected['noteCount'] !== undefined &&
+                actualRecord['noteCount'] !== expected['noteCount']) {
+                mismatches.push(`noteCount: expected ${String(expected['noteCount'])}, got ${String(actualRecord['noteCount'])}`);
+            }
+            if (expected['entries'] !== undefined &&
+                JSON.stringify(actualRecord['entries']) !==
+                    JSON.stringify(expected['entries'])) {
+                mismatches.push(`archive entries: expected ${JSON.stringify(expected['entries'])}, got ${JSON.stringify(actualRecord['entries'])}`);
+            }
             const content = String(actualRecord['content'] ?? '');
             for (const needle of expected['contains'] ?? []) {
                 if (!content.includes(needle)) {