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

package/dist/browser.d.ts

@@ -1,7 +1,9 @@
 import type { NetProvider } from '@markii/lua';
 import type { HostIsolate } from './host/adapter.js';
 /** Builds the provider for one run from the job's host allowlist, byte cap and pin policy (the policy is meaningless in a browser and ignored). */
-export type BrowserNetProviderFactory = (netAllowlist: string[], maxFetchBytes: number, netPolicy: unknown) => NetProvider;
+export type BrowserNetProviderFactory = (netAllowlist: string[], maxFetchBytes: number, netPolicy: unknown, 
+/** Aborted when the isolate is killed or disposed. A provider cancels its in-flight requests on it. */
+signal?: AbortSignal) => NetProvider;
 export interface FetchNetProviderOptions {
     /**
      * The origins (`https://api.example.com`, `http://127.0.0.1:8080`) a
@@ -9,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;
@@ -33,7 +35,9 @@ export interface FetchNetProviderOptions {
  * manual redirect's target, so it cannot be checked against the allowlist,
  * and a redirect is therefore a denial.
  *
- * Returns a factory because the byte cap arrives per job.
+ * Returns a factory because the byte cap arrives per job. Every request
+ * carries the run's `AbortSignal`, so killing the isolate cancels requests
+ * still in flight.
  */
 export declare function createFetchNetProvider(options?: FetchNetProviderOptions): BrowserNetProviderFactory;
 export interface BrowserHostIsolateOptions {

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);
@@ -74,14 +75,19 @@ async function readCapped(response, maxBytes, denial) {
  * manual redirect's target, so it cannot be checked against the allowlist,
  * and a redirect is therefore a denial.
  *
- * Returns a factory because the byte cap arrives per job.
+ * Returns a factory because the byte cap arrives per job. Every request
+ * carries the run's `AbortSignal`, so killing the isolate cancels requests
+ * still in flight.
  */
 export function createFetchNetProvider(options = {}) {
     const allowed = new Set((options.allowedOrigins ?? [])
         .map(originOf)
         .filter((origin) => origin !== undefined));
-    const denial = options.denial ?? ((message) => new Error(message));
-    return (netAllowlist, maxFetchBytes) => {
+    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
         // in, so the page is the boundary (the same rule the Node provider
@@ -107,6 +113,8 @@ export function createFetchNetProvider(options = {}) {
             if (!allowed.has(url.origin)) {
                 throw denial(`origin "${url.origin}" is not on the host's allowlist`);
             }
+            if (signal?.aborted)
+                throw new Error('the run has ended');
             const doFetch = options.fetch ?? fetch;
             let response;
             try {
@@ -118,10 +126,14 @@ export function createFetchNetProvider(options = {}) {
                     redirect: 'manual',
                     credentials: 'omit',
                     referrerPolicy: 'no-referrer',
+                    ...(signal !== undefined ? { signal } : {}),
                 });
             }
             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/README.md

@@ -138,8 +138,10 @@ coarse, matching each `kind`:
   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`.
+  already pin bytes. `valueCount` is how many last-run values were baked
+  in, and `renderEngine` (`static` or `react`) is which engine drew the body.
+- `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.

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

@@ -3,8 +3,7 @@
  * the CLI, or a future one) provides so `createMarkiiHost` can run every
  * shared behavior once. Nothing in this file names a `vscode`, `obsidian`,
  * Electron or TTY type — an adapter is built from injected dependencies,
- * so a test can construct the REAL adapter over fakes (batch 11's
- * `tmp/W11-adapter-design.md`, section 2).
+ * so a test can construct the REAL adapter over fakes.
  *
  * A capability group (`isolate`, `editor`, `packs`, `exports`) is absent
  * when a host does not offer it. `createMarkiiHost` never assumes one is
@@ -23,9 +22,7 @@ export interface HostDirEntry {
 }
 /**
  * One yes/no question. Every grant, consent, and replace prompt in the
- * whole app surface routes through this single method (survey finding A1:
- * nine near-identical prompt adapters across three apps collapse to one
- * call each). `message`, `allowLabel`, and `denyLabel` are already fully
+ * whole app surface routes through this single method. `message`, `allowLabel`, and `denyLabel` are already fully
  * built by `@markii/host`; the adapter only has to show them.
  */
 export interface HostPromptRequest {
@@ -43,7 +40,7 @@ export interface HostPromptRequest {
 }
 /**
  * A discriminated union: `workerPath` and `workerBytes` are mutually
- * exclusive per host (survey section C). A Node host (VS Code, the CLI)
+ * exclusive per host. A Node host (VS Code, the CLI)
  * gives a synchronous path lookup; a host whose runtime cannot create
  * worker threads (an Electron renderer, which is what the Obsidian plugin
  * runs in) gives an async, disposable Web Worker spawner instead.
@@ -51,15 +48,14 @@ export interface HostPromptRequest {
 export type HostIsolate = {
     readonly kind: 'node';
     /**
-     * The worker entry on disk. A host with a packaged worker resolves it
-     * here; a development or test run falls back to
-     * `defaultWorkerPath()` from `@markii/host/node`, in the host's own
-     * adapter (the shared run path has no Node dependency to do it).
+     * The worker entry on disk. A host with its own bundled worker
+     * resolves it here. `createNodeHostIsolate()` from
+     * `@markii/host/node` supplies the packaged one.
      */
     workerPath(): string;
     /**
-     * Creates the worker-thread isolate. Always `workerThreadIsolate`
-     * from `@markii/host/node`; injected so the shared run path imports
+     * Creates the worker-thread isolate: `workerThreadIsolate` from
+     * `@markii/host/node`. Injected so the shared run path imports
      * nothing from `node:*`.
      */
     readonly spawnIsolate: IsolateSpawner;
@@ -106,7 +102,7 @@ export interface HostEditor {
 }
 /**
  * Pack POLICY (which folders are even candidates) is irreducibly
- * host-specific (survey section D); everything after the list exists is
+ * host-specific; everything after the list exists is
  * already shared in `../packs/discover.ts` and friends. The adapter
  * supplies only the list and the install destination.
  */
@@ -124,12 +120,13 @@ export interface HostPackSource {
      * `'device-list'`: a folder in `installRoot` loads only when the trust
      * list in the adapter's `memento` names its namespace, and the host
      * gains `installedPacks`, `enablePack` and `disablePack`. An install
-     * trusts the pack it installs. Requires `installRoot`. `'none'` (or
-     * absent): every folder this host's own policy authorizes loads, which
-     * is right for a host that trusts its own install store (VS Code, the
-     * CLI). A host states its choice explicitly.
+     * trusts the pack it installs. Requires `installRoot`. `'none'`: every
+     * folder this host's own policy authorizes loads, which is right for a
+     * host that trusts its own install store (VS Code, the CLI). A web host
+     * that installs packs from users picks `'device-list'`. Required: a
+     * host states its choice explicitly.
      */
-    readonly trust?: 'device-list' | 'none';
+    readonly trust: 'device-list' | 'none';
     /**
      * Folders this host currently AUTHORIZES. Under `trust: 'device-list'`
      * these are the folders beyond the install root (the host adds the
@@ -153,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. */
@@ -167,10 +164,8 @@ export interface HostExportCapabilities {
 }
 /**
  * The wording nouns every shared behavior's message templates interpolate
- * (`./labels.ts`). This is the one answer to the survey's wording-drift
- * risk: near-identical copy across the three apps collapses into one
- * template plus these per-host nouns, instead of a per-host
- * reimplementation of the sentence itself.
+ * (`./labels.ts`). One template plus these per-host nouns
+ * replaces a per-host copy of each sentence.
  */
 export interface HostLabels {
     /** "extension" | "plugin" | "command line tool" */
@@ -196,13 +191,15 @@ export interface HostLabels {
  * Everything an adapter provides. An adapter is constructible from
  * injected dependencies (no module-scope global reads), which is what
  * lets a conformance test build the REAL adapter over a fake editor
- * (batch 11 Phase 3).
+ *.
  */
 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[]>;

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

@@ -110,7 +110,7 @@ export declare function hostDeclaresCapability(adapter: HostAdapter, action: Hos
  * `next()` THROWS once exhausted rather than returning a default: an
  * unanswered prompt means the scenario and the implementation disagree
  * about how many questions get asked, which must never be silently read
- * as a deny (`tmp/W11-corpus-design.md`, "The prompt policy").
+ * as a deny.
  */
 export declare function createAnswerQueue(scenario: HostScenario): {
     next(): boolean;

package/dist/host/conformance-runner.js

@@ -1,6 +1,5 @@
 /**
- * Executes one `conformance/host/<scenario>` case (batch 11 Phase 3,
- * `tmp/W11-corpus-design.md`) against any real `HostAdapter`, so a single
+ * Executes one `conformance/host/<scenario>` case against any real `HostAdapter`, so a single
  * plain-data corpus proves the three apps' adapters behave the same.
  *
  * `conformance/host/` itself stays plain data (no TypeScript, matching the
@@ -26,8 +25,7 @@
  * pre-check here, over the same shared functions and the SAME
  * `adapter.labels` a real call site would use, so the scenario proves
  * wording parity across hosts without inventing a capability the contract
- * does not have. See `tmp/W11-phase3.md` for why this is a reported
- * finding, not a silent workaround.
+ * does not have. The scenario `10-scripts-disabled` holds the behavior.
  *
  * SIMULATED EXECUTION. A `run` action's `simulate` field (plain data) tells
  * this module what the isolate would have produced, instead of spawning a
@@ -42,7 +40,6 @@ import { existsSync, readFileSync, readdirSync } from 'node:fs';
 import { dirname } 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';
@@ -142,10 +139,7 @@ export function hostDeclaresCapability(adapter, action) {
     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);
         }
@@ -162,7 +156,7 @@ export function hostDeclaresCapability(adapter, action) {
  * `next()` THROWS once exhausted rather than returning a default: an
  * unanswered prompt means the scenario and the implementation disagree
  * about how many questions get asked, which must never be silently read
- * as a deny (`tmp/W11-corpus-design.md`, "The prompt policy").
+ * as a deny.
  */
 export function createAnswerQueue(scenario) {
     const answers = [];
@@ -264,7 +258,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: createNodeArchiveExtractFs(),
         spawnRun: (spawnOptions) => Promise.resolve(simulatedRunResult(currentSimulation, spawnOptions)),
         ...(options.renderAnsi ? { renderAnsi: options.renderAnsi } : {}),
     });
@@ -454,6 +447,16 @@ 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)}"`);
+                }
+            }
             const content = String(actualRecord['content'] ?? '');
             for (const needle of expected['contains'] ?? []) {
                 if (!content.includes(needle)) {
@@ -468,6 +471,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'])}"`);

package/dist/host/create-host.d.ts

@@ -3,13 +3,11 @@
  * its own run/export/pack/editor wiring. Everything it touches (files, prompts,
  * the isolate) arrives through the adapter, so the main entry stays
  * environment-neutral. VS Code's webview imports only the pure pieces and
- * never calls this function (`tmp/W11-adapter-design.md`, section 1).
+ * never calls this function.
  *
- * Phase 1a implemented `run`, `diagnostics`, and `open`. This phase
- * (1b) fills in `exportNote`, `installPack`, `loadPacks`, `completeAt`,
- * `hoverAt`, and `insertComponent`, over the behavior modules built in
- * this same pass (`./export-behavior.js`, `./pack-install.js`,
- * `./pack-load.js`, `./editor-behavior.js`). Every one of them still
+ * It provides `run`, `diagnostics`, `open`, `exportNote`, `installPack`, `loadPacks`, `completeAt`,
+ * `hoverAt`, and `insertComponent`, over the behavior modules (`./export-behavior.js`, `./pack-install.js`,
+ * `./pack-load.js`, `./editor-behavior.js`). Every one of them
  * returns the shared `Unsupported` outcome, with one diagnostics line,
  * when the adapter lacks the capability it needs — AGENTS.md's "clean is
  * not silent": a decline is never a silent no-op.
@@ -20,9 +18,9 @@ import type { StoredValue } from '@markii/runtime';
 import type { OnDiagnostic, UnavailableComponent } from '@markii/stdlib';
 import type { CompletionItem, ComponentDocumentation, LineColumn } from '@markii/stdlib/editor';
 import { type RunViaAdapterRequest, type RunViaAdapterResult } from './run-behavior.js';
-import { type ArchiveExtractFs } from './pack-archive.js';
 import { type PackDiscoveryIo } from './pack-load.js';
-import type { HtmlExportEngine } from '../export/note-export.js';
+import type { ExportBodyRenderer, ExportPackStylesheet, ExportRenderInfo, HtmlExportEngine, StaticExportReason } from '../export/note-export.js';
+import type { EmbeddedImageReport, ExportImageReader } from '../export/image-embed.js';
 import type { DiscoveredPack, SkippedPackFolder } from '../packs/discover.js';
 import { type TerminalPackScript } from './terminal-packs.js';
 import { type RemovePackOutcome } from './pack-remove.js';
@@ -63,11 +61,31 @@ export interface ExportRequest {
     readonly unavailableComponents?: readonly UnavailableComponent[];
     /** Receives the static engine's render diagnostics, such as the `no-engine-view` event. */
     readonly onDiagnostic?: OnDiagnostic;
+    /** The host's own render of the body (a React pass bound to its loaded packs). Omitted means the static engine renders, and `staticReason` says why. Used by the `html` and `pdf` formats. */
+    readonly renderBody?: ExportBodyRenderer;
+    /** Why the static engine renders when `renderBody` is omitted. Defaults to `no-packs`. */
+    readonly staticReason?: StaticExportReason;
+    /** The loaded packs' stylesheets, embedded only when `renderBody` ran. */
+    readonly packStylesheets?: readonly ExportPackStylesheet[];
+    /** How many loaded packs contributed to the render. Diagnostics only. */
+    readonly packCount?: number;
+    /** Reads one of the note's local images so the export embeds it as a `data:` URI. Omitted leaves every image source as written. */
+    readonly embedImages?: ExportImageReader;
+    /** Hides the collapsed script marker in the exported file. Defaults to `false`. */
+    readonly hideScriptBlocks?: boolean;
 }
 export type ExportOutcome = {
     readonly kind: 'exported';
     readonly path: string;
     readonly bytes: number;
+    /** How many last-run values were baked into the file. */
+    readonly valueCount: number;
+    /** `true` when the note contains a script fence. */
+    readonly hasScripts?: boolean;
+    /** Which engine rendered the body, and why when it was the static one. */
+    readonly render: ExportRenderInfo;
+    /** What image embedding did. */
+    readonly images: EmbeddedImageReport;
 } | {
     readonly kind: 'failed';
     readonly reason: string;
@@ -84,6 +102,8 @@ export interface InstallPackRequest {
 export type InstallPackOutcome = {
     readonly kind: 'installed';
     readonly namespace: string;
+    /** The folder the pack now lives in, under the adapter's install root. */
+    readonly installedDir: string;
     readonly replaced: boolean;
 } | {
     readonly kind: 'declined';
@@ -239,9 +259,7 @@ export interface MarkiiHost {
  */
 export interface MarkiiHostOptions {
     readonly spawnRun?: (options: SpawnRunRequest) => Promise<RunResult>;
-    /** The `.mkp` extraction filesystem `installPack` writes through. Required for a host that installs packs (`createNodeArchiveExtractFs()` from `@markii/host/node`); without it `installPack` is `Unsupported`. */
-    readonly archiveExtractFs?: ArchiveExtractFs;
-    /** The static HTML engine behind the `html` and `pdf` exports (`createHtmlExportEngine()` from `@markii/host/node`). Without it those formats decline, like `renderAnsi` for `ansi`. */
+    /** The static HTML engine behind the `html` and `pdf` exports (`createHtmlExportEngine()` from `@markii/host/html-engine`). Without it those formats decline, like `renderAnsi` for `ansi`. */
     readonly htmlEngine?: HtmlExportEngine;
     /** Pack discovery's file reads. Defaults to reads through the adapter's own `readFile` and `listFolder`. */
     readonly packDiscoveryIo?: PackDiscoveryIo;

package/dist/host/create-host.js

@@ -95,6 +95,24 @@ export function createMarkiiHost(adapter, options = {}) {
                 ...(request.onDiagnostic !== undefined
                     ? { onDiagnostic: request.onDiagnostic }
                     : {}),
+                ...(request.renderBody !== undefined
+                    ? { renderBody: request.renderBody }
+                    : {}),
+                ...(request.staticReason !== undefined
+                    ? { staticReason: request.staticReason }
+                    : {}),
+                ...(request.packStylesheets !== undefined
+                    ? { packStylesheets: request.packStylesheets }
+                    : {}),
+                ...(request.packCount !== undefined
+                    ? { packCount: request.packCount }
+                    : {}),
+                ...(request.embedImages !== undefined
+                    ? { embedImages: request.embedImages }
+                    : {}),
+                ...(request.hideScriptBlocks !== undefined
+                    ? { hideScriptBlocks: request.hideScriptBlocks }
+                    : {}),
             }, options.renderAnsi);
             if (outcome === undefined) {
                 adapter.diagnostics(`export declined: format "${request.format}" has no working export path on ${adapter.id} (a cancelled picker, or a missing renderer/PDF seam).`);
@@ -106,47 +124,40 @@ export function createMarkiiHost(adapter, options = {}) {
             if (outcome.kind === 'failed') {
                 return { kind: 'failed', reason: outcome.reason };
             }
-            return { kind: 'exported', path: outcome.path, bytes: outcome.bytes };
+            return {
+                kind: 'exported',
+                path: outcome.path,
+                bytes: outcome.bytes,
+                valueCount: outcome.valueCount,
+                ...(outcome.hasScripts !== undefined
+                    ? { hasScripts: outcome.hasScripts }
+                    : {}),
+                render: outcome.render,
+                images: outcome.images,
+            };
         },
         async installPack(request) {
             if (!adapter.packs?.installRoot) {
                 return unsupported(adapter, 'packs', 'this host has no pack-install destination configured.');
             }
             const archivePath = request.archivePath ?? 'the selected archive';
-            const extractFs = options.archiveExtractFs;
-            if (extractFs === undefined) {
-                return unsupported(adapter, 'packs', 'this host was given no archive extraction filesystem.');
+            const removeFolder = adapter.packs.removeFolder;
+            if (removeFolder === undefined) {
+                return unsupported(adapter, 'packs', 'this host has no way to remove an installed pack folder.');
             }
             const outcome = await installPackFromArchive(adapter, {
                 archiveBytes: request.archiveBytes,
                 archivePath,
                 installRoot: adapter.packs.installRoot(),
                 exists: (path) => adapter.exists(path),
-                extractFs,
+                removeFolder: (path) => removeFolder.call(adapter.packs, path),
                 reservedNamespaces: adapter.packs.reservedNamespaces(),
             });
             catalogCache.invalidate();
             for (const line of installPackDiagnosticLines(outcome, archivePath)) {
                 adapter.diagnostics(line);
             }
-            if (outcome.kind === 'installed') {
-                return {
-                    kind: 'installed',
-                    namespace: outcome.packName,
-                    replaced: outcome.replaced,
-                };
-            }
-            if (outcome.kind === 'declined') {
-                return {
-                    kind: 'declined',
-                    step: outcome.step,
-                    namespace: outcome.packName,
-                };
-            }
-            if (outcome.kind === 'reserved') {
-                return { kind: 'reserved', namespace: outcome.packName };
-            }
-            return { kind: 'rejected', reason: outcome.reason };
+            return outcome;
         },
         async loadPacks() {
             if (!adapter.packs) {

package/dist/host/editor-behavior.d.ts

@@ -4,12 +4,8 @@ import type { HostEditor, HostTextEdit } from './adapter.js';
 export declare const STANDARD_ORIGIN_TAG = "standard";
 export declare const LAYOUT_ORIGIN_TAG = "layout";
 /**
- * Survey finding A5: `apps/vscode/src/completion.ts:completionOriginTag`
- * and `apps/obsidian/src/complete-component.ts:completionOriginTag` had
- * IDENTICAL function bodies, differing only in which locally-defined
- * constant stood in for the standard/layout tag string. Both apps'
- * constants held the same lower-case values (`'standard'`/`'layout'`),
- * so there was never a wording difference to preserve.
+ * The origin tag a completion item carries: the lower-case
+ * `'standard'`/`'layout'` strings above, or the pack name.
  */
 export declare function completionOriginTag(item: CompletionItem): string;
 /** A small cache in front of `buildComponentCatalog` (`../insert/component-catalog.js`), so a completion/hover provider does not re-discover packs from disk on every keystroke. */

package/dist/host/editor-behavior.js

@@ -2,16 +2,16 @@
  * The `completeAt`/`hoverAt`/`insertComponent` behaviors' shared half,
  * merged from `apps/vscode/src/completion.ts` + `completion-catalog.ts`,
  * `apps/obsidian/src/complete-component.ts`, and both apps'
- * `insert-component.ts` (survey finding A5, plus table rows 31/33).
+ * `insert-component.ts`.
  *
- * NODE-FREE by design (`tmp/W11-adapter-design.md`, section 1): re-exported
+ * NODE-FREE by design: re-exported
  * from `../browser.ts` as well as `../index.ts`, so VS Code's webview
  * bundle can read the origin-tag vocabulary and the pure completion math
  * directly if a future slice needs to. `CatalogCache.get`'s injected
  * `load` is the one thing that reaches disk, and it is always supplied by
  * the caller (a main-entry-only pack-discovery call), never imported here.
  *
- * What stays app-side (deliberately, per the survey's section D): VS
+ * What stays app-side (deliberately): VS
  * Code's sectioned quick-pick presentation (`Standard`/`Layout`/`<pack>
  * pack` separators) and Obsidian's flat fuzzy list are a genuine product
  * difference, not duplication — this module returns the catalog and the
@@ -25,12 +25,8 @@ import { closesOpenContainerFence, completionAt, componentDocumentation, fenceEx
 export const STANDARD_ORIGIN_TAG = 'standard';
 export const LAYOUT_ORIGIN_TAG = 'layout';
 /**
- * Survey finding A5: `apps/vscode/src/completion.ts:completionOriginTag`
- * and `apps/obsidian/src/complete-component.ts:completionOriginTag` had
- * IDENTICAL function bodies, differing only in which locally-defined
- * constant stood in for the standard/layout tag string. Both apps'
- * constants held the same lower-case values (`'standard'`/`'layout'`),
- * so there was never a wording difference to preserve.
+ * The origin tag a completion item carries: the lower-case
+ * `'standard'`/`'layout'` strings above, or the pack name.
  */
 export function completionOriginTag(item) {
     if (item.kind !== 'component')

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

@@ -2,7 +2,7 @@
  * The `exportNote` behavior: outcome shape, wording, and format gating,
  * merged from `apps/vscode/src/export-html.ts`, the host-neutral half of
  * `apps/obsidian/src/export-note.ts`, and `apps/cli/src/export-note.ts`'s
- * `exportHtml` (survey finding A10, table rows 22/26).
+ * `exportHtml`.
  *
  * `html` and `md-plain` are fully implemented here, over `../export/note-export.js`'s
  * `buildNoteExport` (already host-neutral, already shared) and
@@ -12,26 +12,25 @@
  * AGENTS.md's package boundaries), so it is rendered through the injected
  * `renderAnsi` option; a host that omits it gets `Unsupported`.
  *
- * PDF stays a seam, never an implementation here, exactly as
- * `tmp/W11-adapter-design.md` specifies: this module builds the same HTML
+ * PDF stays a seam, never an implementation here, this module builds the same HTML
  * document `html` would have written and hands it to
  * `adapter.exports.htmlToPdf`, but the DEGRADE-TO-HTML-ON-FAILURE product
  * behavior Obsidian's own `exportNoteAsPdf` layers on top (falling back to
  * writing the HTML file when printing is unavailable or fails, and
  * reporting which of the two happened) is Obsidian-specific policy about
  * what to do with a seam's failure, not the seam itself — it stays
- * app-side. See `tmp/W11-phase1b.md` for this call.
+ * app-side.
  *
  * Cascade orchestration (multi-note export, `walkNoteCascade` +
  * `assignCascadeFileNames` + `rewriteCascadeLinks` + `zipExportArchive`)
- * is NOT moved in this pass — see `tmp/W11-phase1b.md`'s deviations
- * section for why, and what Phase 2 (or a follow-up) still needs to do.
+ * is not part of this module: it stays with each host.
  */
 import type { StoredValue } from '@markii/runtime';
 import type { OnDiagnostic, UnavailableComponent } from '@markii/stdlib';
 import type { HtmlExportEngine, ExportBodyRenderer, ExportPackStylesheet, ExportRenderInfo, StaticExportReason } from '../export/note-export.js';
 import type { EmbeddedImageReport, ExportImageReader } from '../export/image-embed.js';
 import type { HostAdapter, HostExportFormat, HostLabels } from './adapter.js';
+import type { ExportOutcome } from './create-host.js';
 /** The file name an export lands under, by format: the note's own base name with the format's own extension, so the export lands beside the note unless the host's picker says otherwise. */
 export declare function exportDefaultFileName(notePath: string, format: HostExportFormat): string;
 /** What a `'html'` or `'pdf'` export attempt produced. Every shape except `failed` means the host got a file, and every shape but `failed` carries the same diagnostics-facing detail so the two hosts' wording can share it. */
@@ -60,7 +59,7 @@ export declare function fileNameOf(path: string): string;
  * host's own diagnostics surface (`labels.diagnosticsSurface`), never at
  * a stack trace — the verbatim reason goes there instead.
  */
-export declare function exportResultMessage(outcome: NoteFileExportOutcome, labels: HostLabels): string;
+export declare function exportResultMessage(outcome: ExportOutcome, labels: HostLabels): string;
 /** One diagnostic line describing HOW an export's body was rendered: the pack-vs-static distinction, kept off the result message and put here instead. */
 export declare function renderEngineDiagnosticLine(render: ExportRenderInfo): string;
 /** `bytes`, formatted as a human-readable size (`"1.2 KB"`, `"512 bytes"`). */

package/dist/host/export-behavior.js

@@ -23,7 +23,7 @@ export function fileNameOf(path) {
  * a stack trace — the verbatim reason goes there instead.
  */
 export function exportResultMessage(outcome, labels) {
-    if (outcome.kind === 'failed') {
+    if (outcome.kind !== 'exported') {
         return `Markii: could not export this note. Open ${labels.diagnosticsSurface} for details.`;
     }
     const name = fileNameOf(outcome.path);