@markii/host 0.17.0-next.3 → 0.17.0-next.5

package/dist/browser.d.ts

@@ -11,7 +11,7 @@ export interface FetchNetProviderOptions {
      * every request. Entries that do not parse as an http(s) URL are ignored.
      */
     allowedOrigins?: readonly string[];
-    /** How a policy refusal is built. Defaults to a plain `Error`; the isolate bridge marks every refusal as a denial on the wire either way. */
+    /** How a policy refusal is built. Defaults to a plain `Error`. The provider marks every refusal it throws, so the isolate bridge sends it as a denial. A transport failure is never marked. */
     denial?: (message: string) => Error;
     /** The `fetch` to use. Defaults to the global one; injectable for tests. */
     fetch?: typeof fetch;

package/dist/browser.js

@@ -14,6 +14,7 @@
 // `new URL(..., import.meta.url)` references below resolve in a consumer's
 // bundler without configuration where that bundler treats them as assets.
 import { createBrowserIsolate } from './run/browser-isolate.js';
+import { netRefusal } from './run/net-refusal.js';
 function originOf(entry) {
     try {
         const url = new URL(entry);
@@ -82,7 +83,10 @@ export function createFetchNetProvider(options = {}) {
     const allowed = new Set((options.allowedOrigins ?? [])
         .map(originOf)
         .filter((origin) => origin !== undefined));
-    const denial = options.denial ?? ((message) => new Error(message));
+    const build = options.denial ?? ((message) => new Error(message));
+    // Every policy refusal is marked so the net bridge can tell it from a
+    // transport failure (a plain `Error`).
+    const denial = (message) => netRefusal(build(message));
     return (netAllowlist, maxFetchBytes, _policy, signal) => {
         // The run's granted hosts, re-checked here on the page side: the worker
         // checks them too, but the worker is the isolate a hostile script runs
@@ -110,7 +114,7 @@ export function createFetchNetProvider(options = {}) {
                 throw denial(`origin "${url.origin}" is not on the host's allowlist`);
             }
             if (signal?.aborted)
-                throw denial('the run has ended');
+                throw new Error('the run has ended');
             const doFetch = options.fetch ?? fetch;
             let response;
             try {
@@ -126,7 +130,10 @@ export function createFetchNetProvider(options = {}) {
                 });
             }
             catch (error) {
-                throw denial(`request failed: ${error instanceof Error ? error.message : String(error)}`);
+                // A transport failure (network down, connection refused, CORS,
+                // abort): an ordinary runtime failure with the reason, not a policy
+                // refusal.
+                throw new Error(`request failed: ${error instanceof Error ? error.message : String(error)}`);
             }
             if (response.type === 'opaqueredirect') {
                 throw denial('redirects are not followed in a browser');

package/dist/conformance/host/05-export-html-pack-directive/expected.json

@@ -2,6 +2,8 @@
   "outcomes": [
     {
       "kind": "exported",
+      "valueCount": 0,
+      "renderEngine": "static",
       "contains": ["mk-unknown", "ana_timeline"],
       "excludes": ["<script"]
     }

package/dist/conformance/host/06-install-pack-then-render/expected.json

@@ -1,7 +1,12 @@
 {
   "outcomes": [
     { "kind": "opened" },
-    { "kind": "installed", "namespace": "ana", "replaced": false },
+    {
+      "kind": "installed",
+      "namespace": "ana",
+      "replaced": false,
+      "installedDirName": "ana"
+    },
     { "kind": "loaded", "namespaces": ["ana"] },
     { "kind": "installed", "namespace": "ana", "replaced": true }
   ],

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/README.md

@@ -49,6 +49,7 @@ needs, is the runner's own `ACTION_CAPABILITY` map:
 | `run` | `isolate` |
 | `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 +98,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.
 
@@ -137,9 +138,13 @@ coarse, matching each `kind`:
   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`.
+  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.
@@ -159,7 +164,7 @@ coarse, matching each `kind`:
 
 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.
 
@@ -171,11 +176,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)
@@ -215,7 +220,7 @@ 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` |
 
-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/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/export/note-export.d.ts

@@ -71,7 +71,7 @@ export declare const EXPORT_HIDE_SCRIPT_BLOCKS_CLASS = "mk-export--hide-scripts"
 export declare const EXPORT_PAGE_CSS = "\nbody {\n  margin: 0;\n  background: #fff;\n}\n.doc {\n  box-sizing: border-box;\n  max-width: 46rem;\n  margin: 0 auto;\n  padding: 2.5rem 1.5rem 4rem;\n}\n.doc.mk-export--hide-scripts .mk-script {\n  display: none;\n}\n@page {\n  margin: 2cm;\n}\n@media print {\n  .doc {\n    max-width: none;\n    margin: 0;\n    padding: 0;\n  }\n  .doc .mk-card,\n  .doc .mk-callout,\n  .doc .mk-stat,\n  .doc .mk-figure,\n  .doc .mk-unknown,\n  .doc table {\n    break-inside: avoid;\n  }\n  /* A collapsed `details` prints as its summary alone, which loses the\n     content the author wrote. On paper there is nothing to expand, so\n     every disclosure prints open. */\n  .doc details > *:not(summary) {\n    display: block;\n  }\n  .doc .mk-script,\n  .doc .mk-preview__run-marker {\n    display: none;\n  }\n}\n";
 /**
  * The static HTML engine, injected so this module imports no renderer.
- * A host passes `createHtmlExportEngine()` from `@markii/host/node`, which
+ * A host passes `createHtmlExportEngine()` from `@markii/host/html-engine`, which
  * wraps `@markii/html`; a test may pass a stub.
  */
 export interface HtmlExportEngine {

package/dist/host/adapter.d.ts

@@ -150,7 +150,7 @@ export interface HostPackSource {
      * `authorizedFolders` names.
      */
     bundledPacks?(): readonly DiscoveredPack[];
-    /** Removes an installed pack folder. Required when `installRoot` is present. */
+    /** Removes an installed pack folder and everything under it. Required when `installRoot` is present: a replacing install clears the old folder through it, and removing a pack uses it. */
     removeFolder?(path: string): Promise<void>;
 }
 /** Every export format any host offers today. */
@@ -161,6 +161,14 @@ export interface HostExportCapabilities {
     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. Present only on a host that offers the
+     * linked-set export; 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
@@ -194,10 +202,12 @@ export interface HostLabels {
  *.
  */
 export interface HostAdapter {
-    readonly id: 'vscode' | 'obsidian' | 'cli' | (string & {});
+    /** A short name for the host, used in diagnostics wording. */
+    readonly id: string;
     readonly labels: HostLabels;
     readFile(path: string): Promise<Uint8Array>;
     exists(path: string): Promise<boolean>;
+    /** Writes `bytes` to `path` and creates any missing parent folder first. Exports and pack installs both write through it. */
     writeFile(path: string, bytes: Uint8Array): Promise<void>;
     /** A missing folder resolves to an empty list — never throws, matching the existing `PackDirectoryLister` contract. */
     listFolder(path: string): Promise<readonly HostDirEntry[]>;
@@ -208,7 +218,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,17 @@ 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;
+}
+/**
+ * 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. 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,63 @@ 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. Never throws.
+ */
+export async function exportLinkedSetViaAdapter(adapter, inputs) {
+    const resolveTarget = adapter.exports?.resolveLinkedSetTarget;
+    if (resolveTarget === undefined)
+        return undefined;
+    const { suggestedFileName, ...archiveRequest } = inputs;
+    let path;
+    let outcome;
+    try {
+        path = 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

@@ -1,4 +1,3 @@
-import type { ArchiveExtractFs } from './pack-archive.js';
 import type { RunTrigger } from '@markii/runtime';
 import type { HostAdapter } from './adapter.js';
 /**
@@ -36,6 +35,8 @@ export type HostScenarioAction = {
     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. */
@@ -99,7 +100,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. */
@@ -135,8 +136,6 @@ export interface HostScenarioRunResult {
  */
 export declare function runHostScenario(adapter: HostAdapter, scenario: HostScenario, noteText: string, scenarioDir: string, options?: {
     readonly renderAnsi?: (text: string) => Promise<string>;
-    /** Where an installed pack archive is extracted. Defaults to the Node file system, which is right for an adapter that reads and writes real files. An adapter over another store (memory, a virtual file system) passes the matching writer. */
-    readonly archiveExtractFs?: ArchiveExtractFs;
 }): Promise<HostScenarioRunResult>;
 /** `expected[i]` compared against `actual[i]` for each index up to `expected`'s own length; a length mismatch is reported once rather than index-by-index noise. */
 export declare function containsInOrder(actual: readonly string[], expected: readonly string[]): string[];

package/dist/host/conformance-runner.js

@@ -37,13 +37,12 @@
  * 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 { createNodeArchiveExtractFs } from '../node-fs.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 { scriptsDisabledDiagnosticLine, scriptsDisabledNotice, } from './script-execution.js';
@@ -102,6 +101,7 @@ export const ACTION_CAPABILITY = {
     run: 'isolate',
     exportHtml: 'export-format',
     exportAnsi: 'export-format',
+    exportLinkedSet: 'linked-set-export',
     installPack: 'packs',
     loadPacks: 'packs',
     removePack: 'packs',
@@ -137,13 +137,13 @@ 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;
-        if (action.type === 'installPack') {
-            return adapter.packs.installRoot !== undefined;
-        }
-        if (action.type === 'removePack') {
+        if (action.type === 'installPack' || action.type === 'removePack') {
             return (adapter.packs.installRoot !== undefined &&
                 adapter.packs.removeFolder !== undefined);
         }
@@ -262,7 +262,6 @@ export async function runHostScenario(adapter, scenario, noteText, scenarioDir,
         // 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(),
-        archiveExtractFs: options.archiveExtractFs ?? createNodeArchiveExtractFs(),
         spawnRun: (spawnOptions) => Promise.resolve(simulatedRunResult(currentSimulation, spawnOptions)),
         ...(options.renderAnsi ? { renderAnsi: options.renderAnsi } : {}),
     });
@@ -334,6 +333,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 });
@@ -366,6 +383,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;
@@ -452,6 +476,25 @@ export function outcomeMismatches(actual, expected) {
             break;
         }
         case 'exported': {
+            if (expected['valueCount'] !== undefined &&
+                actualRecord['valueCount'] !== expected['valueCount']) {
+                mismatches.push(`valueCount: expected ${String(expected['valueCount'])}, got ${String(actualRecord['valueCount'])}`);
+            }
+            if (expected['renderEngine'] !== undefined) {
+                const render = actualRecord['render'];
+                if (render?.engine !== expected['renderEngine']) {
+                    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)) {
@@ -466,6 +509,13 @@ export function outcomeMismatches(actual, expected) {
             break;
         }
         case 'installed': {
+            if (expected['installedDirName'] !== undefined) {
+                const dir = String(actualRecord['installedDir'] ?? '');
+                const name = dir.split(/[/\\]/).pop();
+                if (name !== expected['installedDirName']) {
+                    mismatches.push(`installedDir: expected a folder named "${String(expected['installedDirName'])}", got "${dir}"`);
+                }
+            }
             if (expected['namespace'] !== undefined &&
                 actualRecord['namespace'] !== expected['namespace']) {
                 mismatches.push(`namespace: expected "${String(expected['namespace'])}", got "${String(actualRecord['namespace'])}"`);