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

package/dist/host/create-host.js

@@ -1,6 +1,12 @@
-import { runViaAdapter, } from './run-behavior.js';
+import { readPersistedValues } from '../run/run-flow.js';
+import { clearGrantForDocument } from '../run/grant-flow.js';
+import { readLastRunTrace } from '../run/run-trace.js';
+import { staleValuesForRehydration } from '../run/stale-values.js';
+import { runViaAdapter } from './run-behavior.js';
 import { installPackDiagnosticLines, installPackFromArchive, } from './pack-install.js';
 import { loadPacksViaAdapter, packDiscoveryIoFromAdapter, } from './pack-load.js';
+import { exportBaseName } from '../export/note-export.js';
+import { exportLinkedSetViaAdapter, } from './cascade-export-behavior.js';
 import { buildComponentCatalog } from '../insert/component-catalog.js';
 import { formatPackDiagnosticLines, skippedPackFolderLine, } from '../packs/pack-diagnostics.js';
 import { readTerminalPackScripts, } from './terminal-packs.js';
@@ -13,7 +19,22 @@ function unsupported(adapter, capability, detail) {
     adapter.diagnostics(`declined (${capability} unsupported on ${adapter.id}): ${detail}`);
     return { kind: 'unsupported', capability, detail };
 }
+/** Writes one diagnostics line for a rejected adapter primitive and returns the `failed` outcome. Never throws. */
+function failedOutcome(adapter, what, err) {
+    const reason = err instanceof Error ? err.message : String(err);
+    try {
+        adapter.diagnostics(`${what} failed: ${reason}`);
+    }
+    catch {
+        // the diagnostics surface itself is what failed
+    }
+    return { kind: 'failed', reason };
+}
 export function createMarkiiHost(adapter, options = {}) {
+    return createMarkiiHostWithSeams(adapter, options);
+}
+/** `createMarkiiHost` with the test seams. Exported from `@markii/host/internal` only. */
+export function createMarkiiHostWithSeams(adapter, options = {}) {
     const packIo = options.packDiscoveryIo ?? packDiscoveryIoFromAdapter(adapter);
     /**
      * The pack source every load reads: under `trust: 'device-list'` the
@@ -33,12 +54,22 @@ export function createMarkiiHost(adapter, options = {}) {
         };
     }
     /** The pack-aware insert/completion catalog, built fresh from this host's currently authorized folders. Not cached here: `./editor-behavior.js`'s `createCatalogCache` is the caching seam, and a caller wiring a live editor (repeated completion/hover calls per keystroke) is expected to wrap this call in one. */
-    async function currentCatalog() {
+    async function readCatalog() {
         if (!adapter.packs)
             return buildComponentCatalog([]);
         const { packs } = await loadPacksViaAdapter(packSource(adapter.packs), packIo);
         return buildComponentCatalog([...(adapter.packs.bundledPacks?.() ?? []), ...packs], adapter.packs.engine);
     }
+    /** The catalog for the cache. A rejected pack read writes one diagnostics line and leaves the standard set, so completion and hover still answer. */
+    async function currentCatalog() {
+        try {
+            return await readCatalog();
+        }
+        catch (err) {
+            failedOutcome(adapter, 'read the pack catalog', err);
+            return buildComponentCatalog([]);
+        }
+    }
     /** Completion and hover fire per keystroke, so they read a cached catalog. `insertComponent` stays uncached: it runs once per command. */
     const catalogCache = createCatalogCache(currentCatalog);
     function documentTextFor(editor, request) {
@@ -74,15 +105,47 @@ export function createMarkiiHost(adapter, options = {}) {
             if (!adapter.isolate) {
                 return unsupported(adapter, 'isolate', 'no isolate is configured, so scripts cannot run.');
             }
-            const result = await runViaAdapter(adapter, request, options.spawnRun);
-            return { kind: 'ran', ...result };
+            try {
+                return await runViaAdapter(adapter, request, options.spawnRun);
+            }
+            catch (err) {
+                // `runViaAdapter` reports a throwing run as `failed` itself. This
+                // catches only what threw outside it, so `run` never rejects.
+                const reason = err instanceof Error ? err.message : String(err);
+                try {
+                    adapter.diagnostics(`run failed: ${reason}`);
+                }
+                catch {
+                    // the diagnostics surface itself is what failed
+                }
+                return { kind: 'failed', reason };
+            }
+        },
+        lastRun(documentKey) {
+            const persistedValues = readPersistedValues(adapter.memento, documentKey);
+            const trace = readLastRunTrace(adapter.memento, documentKey);
+            return {
+                values: staleValuesForRehydration(persistedValues),
+                persistedValues,
+                ...(trace !== undefined ? { trace } : {}),
+            };
+        },
+        forgetGrants(documentKey) {
+            return clearGrantForDocument(adapter.memento, documentKey);
         },
         async exportNote(request) {
             const formats = adapter.exports?.formats;
             if (formats === undefined || !formats.has(request.format)) {
                 return unsupported(adapter, 'export-format', `export format "${request.format}" is not available on ${adapter.id}.`);
             }
+            if (request.targetPath === undefined &&
+                adapter.exports?.resolveTarget === undefined) {
+                return unsupported(adapter, 'export-format', `export format "${request.format}" has no destination on ${adapter.id}: the host declares no resolveTarget and the request has no targetPath.`);
+            }
             const outcome = await exportNoteFileViaAdapter(adapter, request.format, {
+                ...(request.targetPath !== undefined
+                    ? { targetPath: request.targetPath }
+                    : {}),
                 ...(options.htmlEngine !== undefined
                     ? { engine: options.htmlEngine }
                     : {}),
@@ -116,7 +179,7 @@ export function createMarkiiHost(adapter, options = {}) {
             }, 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).`);
-                return { kind: 'cancelled' };
+                return { kind: 'declined' };
             }
             for (const line of exportDiagnosticLines(outcome)) {
                 adapter.diagnostics(line);
@@ -136,6 +199,29 @@ export function createMarkiiHost(adapter, options = {}) {
                 images: outcome.images,
             };
         },
+        async exportLinkedSet(request) {
+            // A host offers the linked-set export when it declares `exports` and
+            // either names a `resolveLinkedSetTarget` or gets a `targetPath` with
+            // the request.
+            if (adapter.exports === undefined ||
+                (request.targetPath === undefined &&
+                    adapter.exports.resolveLinkedSetTarget === undefined)) {
+                return unsupported(adapter, 'linked-set-export', `the linked-set export is not available on ${adapter.id}.`);
+            }
+            if (options.htmlEngine === undefined) {
+                return unsupported(adapter, 'linked-set-export', 'no HTML export engine was supplied, so the linked-set export cannot render.');
+            }
+            const outcome = await exportLinkedSetViaAdapter(adapter, {
+                ...request,
+                engine: options.htmlEngine,
+                suggestedFileName: `${exportBaseName(request.rootPath)}.zip`,
+            });
+            if (outcome === undefined) {
+                adapter.diagnostics(`linked-set export declined: no archive target was chosen on ${adapter.id}.`);
+                return { kind: 'declined' };
+            }
+            return outcome;
+        },
         async installPack(request) {
             if (!adapter.packs?.installRoot) {
                 return unsupported(adapter, 'packs', 'this host has no pack-install destination configured.');
@@ -164,29 +250,34 @@ export function createMarkiiHost(adapter, options = {}) {
                 return unsupported(adapter, 'packs', 'this host has no pack folders configured.');
             }
             catalogCache.invalidate();
-            const result = await loadPacksViaAdapter(packSource(adapter.packs), packIo);
-            for (const line of formatPackDiagnosticLines({
-                packs: result.packs,
-                skipped: result.skipped,
-                engine: adapter.packs.engine,
-                cssWarnings: [],
-            })) {
-                adapter.diagnostics(line);
-            }
-            if (usesPackTrust(adapter)) {
-                for (const namespace of (await listInstalledPacks(adapter))
-                    .notEnabled) {
-                    adapter.diagnostics(notEnabledPackDiagnosticLine(namespace, adapter.labels.deviceNoun));
+            try {
+                const result = await loadPacksViaAdapter(packSource(adapter.packs), packIo);
+                for (const line of formatPackDiagnosticLines({
+                    packs: result.packs,
+                    skipped: result.skipped,
+                    engine: adapter.packs.engine,
+                    cssWarnings: [],
+                })) {
+                    adapter.diagnostics(line);
                 }
+                if (usesPackTrust(adapter)) {
+                    for (const namespace of (await listInstalledPacks(adapter))
+                        .notEnabled) {
+                        adapter.diagnostics(notEnabledPackDiagnosticLine(namespace, adapter.labels.deviceNoun));
+                    }
+                }
+                return {
+                    kind: 'loaded',
+                    namespaces: result.namespaces,
+                    packs: result.packs,
+                    skipped: result.skipped,
+                    components: result.components,
+                    unavailable: result.unavailable,
+                };
+            }
+            catch (err) {
+                return failedOutcome(adapter, 'load packs', err);
             }
-            return {
-                kind: 'loaded',
-                namespaces: result.namespaces,
-                packs: result.packs,
-                skipped: result.skipped,
-                components: result.components,
-                unavailable: result.unavailable,
-            };
         },
         async loadTerminalPacks() {
             if (!adapter.packs) {
@@ -196,34 +287,39 @@ export function createMarkiiHost(adapter, options = {}) {
                 return unsupported(adapter, 'packs', 'this host does not run the terminal engine, so it has no terminal packs.');
             }
             catalogCache.invalidate();
-            const result = await loadPacksViaAdapter(packSource(adapter.packs), packIo);
-            const read = await readTerminalPackScripts(adapter, result.packs);
-            for (const line of formatPackDiagnosticLines({
-                packs: result.packs,
-                skipped: result.skipped,
-                engine: 'ansi',
-                cssWarnings: [],
-            })) {
-                adapter.diagnostics(line);
+            try {
+                const result = await loadPacksViaAdapter(packSource(adapter.packs), packIo);
+                const read = await readTerminalPackScripts(adapter, result.packs);
+                for (const line of formatPackDiagnosticLines({
+                    packs: result.packs,
+                    skipped: result.skipped,
+                    engine: 'ansi',
+                    cssWarnings: [],
+                })) {
+                    adapter.diagnostics(line);
+                }
+                for (const line of read.problems)
+                    adapter.diagnostics(line);
+                const failureLines = [
+                    ...result.skipped
+                        .filter((entry) => entry.engineUnsupported === undefined)
+                        .map(skippedPackFolderLine),
+                    ...read.problems,
+                ];
+                return {
+                    kind: 'loaded',
+                    namespaces: result.namespaces,
+                    packs: result.packs,
+                    skipped: result.skipped,
+                    components: result.components,
+                    unavailable: result.unavailable,
+                    scripts: read.scripts,
+                    failureLines,
+                };
+            }
+            catch (err) {
+                return failedOutcome(adapter, 'load terminal packs', err);
             }
-            for (const line of read.problems)
-                adapter.diagnostics(line);
-            const failureLines = [
-                ...result.skipped
-                    .filter((entry) => entry.engineUnsupported === undefined)
-                    .map(skippedPackFolderLine),
-                ...read.problems,
-            ];
-            return {
-                kind: 'loaded',
-                namespaces: result.namespaces,
-                packs: result.packs,
-                skipped: result.skipped,
-                components: result.components,
-                unavailable: result.unavailable,
-                scripts: read.scripts,
-                failureLines,
-            };
         },
         async removePack(namespace) {
             const packs = adapter.packs;
@@ -245,7 +341,12 @@ export function createMarkiiHost(adapter, options = {}) {
             if (!usesPackTrust(adapter)) {
                 return unsupported(adapter, 'pack-trust', 'this host does not gate installed packs on a trust list.');
             }
-            return { kind: 'listed', ...(await listInstalledPacks(adapter)) };
+            try {
+                return { kind: 'listed', ...(await listInstalledPacks(adapter)) };
+            }
+            catch (err) {
+                return failedOutcome(adapter, 'list installed packs', err);
+            }
         },
         async enablePack(namespace) {
             if (!usesPackTrust(adapter)) {
@@ -270,17 +371,31 @@ export function createMarkiiHost(adapter, options = {}) {
             if (!editor) {
                 return unsupported(adapter, 'editor', 'completion is not available: this host has no live editor.');
             }
-            return completeWith(await catalogCache.get(), request, editor);
+            try {
+                return completeWith(await catalogCache.get(), request, editor);
+            }
+            catch (err) {
+                return failedOutcome(adapter, 'completion', err);
+            }
         },
         completeAtSync(request) {
             const editor = adapter.editor;
             if (!editor) {
                 return unsupported(adapter, 'editor', 'completion is not available: this host has no live editor.');
             }
-            const warm = catalogCache.peek();
-            if (warm === undefined)
-                void catalogCache.get();
-            return completeWith(warm ?? buildComponentCatalog([]), request, editor);
+            try {
+                const warm = catalogCache.peek();
+                if (warm === undefined) {
+                    catalogCache.get().catch((err) => {
+                        failedOutcome(adapter, 'completion catalog', err);
+                    });
+                }
+                return completeWith(warm ?? buildComponentCatalog([]), request, editor);
+            }
+            catch (err) {
+                failedOutcome(adapter, 'completion', err);
+                return { kind: 'none' };
+            }
         },
         invalidateCatalog() {
             catalogCache.invalidate();
@@ -290,48 +405,59 @@ export function createMarkiiHost(adapter, options = {}) {
             if (!editor) {
                 return unsupported(adapter, 'editor', 'hover is not available: this host has no live editor.');
             }
-            const catalog = await catalogCache.get();
-            const hover = hoverAtViaEditor({ documentText: () => documentTextFor(editor, request) }, request, catalog);
-            if (hover === undefined)
-                return { kind: 'none' };
-            // The formatted text (summary, attributes, and the usage example),
-            // not the bare summary sentence: a component's description alone
-            // often never repeats its own directive name (see
-            // `./editor-behavior.js`'s `hoverDocumentationText` doc comment),
-            // while the usage example always does.
-            return {
-                kind: 'hover',
-                text: formatComponentDocumentation(hover.documentation),
-                documentation: hover.documentation,
-                start: hover.start,
-                end: hover.end,
-            };
+            try {
+                const catalog = await catalogCache.get();
+                const hover = hoverAtViaEditor({ documentText: () => documentTextFor(editor, request) }, request, catalog);
+                if (hover === undefined)
+                    return { kind: 'none' };
+                // The formatted text (summary, attributes, and the usage example),
+                // not the bare summary sentence: a component's description alone
+                // often never repeats its own directive name (see
+                // `./editor-behavior.js`'s `hoverDocumentationText` doc comment),
+                // while the usage example always does.
+                return {
+                    kind: 'hover',
+                    text: formatComponentDocumentation(hover.documentation),
+                    documentation: hover.documentation,
+                    start: hover.start,
+                    end: hover.end,
+                };
+            }
+            catch (err) {
+                return failedOutcome(adapter, 'hover', err);
+            }
         },
         async insertComponent(request) {
             if (!adapter.editor) {
                 return unsupported(adapter, 'editor', 'insert component is not available: this host has no live editor.');
             }
-            const catalog = await currentCatalog();
-            const component = catalog.find((entry) => entry.directiveName === request.name);
-            if (component === undefined) {
-                adapter.diagnostics(`insert component: no catalog entry named "${request.name}".`);
-                return { kind: 'not-found', name: request.name };
-            }
-            const cursor = adapter.editor.cursor();
-            const documentText = adapter.editor.documentText();
-            const plan = insertComponentPlan(component, documentText, cursor.line, cursor.column);
-            const edits = plan.edits.map((edit) => ({
-                line: edit.line,
-                startColumn: edit.startColumn,
-                endColumn: edit.endColumn,
-                text: edit.text,
-            }));
-            const applied = await adapter.editor.applyEdits(edits);
-            if (!applied) {
-                adapter.diagnostics(`insert component: the host declined to apply the edit for "${request.name}".`);
-                return { kind: 'failed' };
-            }
-            return { kind: 'inserted', cursor: plan.cursor };
+            try {
+                const catalog = await readCatalog();
+                const component = catalog.find((entry) => entry.directiveName === request.name);
+                if (component === undefined) {
+                    adapter.diagnostics(`insert component: no catalog entry named "${request.name}".`);
+                    return { kind: 'not-found', name: request.name };
+                }
+                const cursor = adapter.editor.cursor();
+                const documentText = adapter.editor.documentText();
+                const plan = insertComponentPlan(component, documentText, cursor.line, cursor.column);
+                const edits = plan.edits.map((edit) => ({
+                    line: edit.line,
+                    startColumn: edit.startColumn,
+                    endColumn: edit.endColumn,
+                    text: edit.text,
+                }));
+                const applied = await adapter.editor.applyEdits(edits);
+                if (!applied) {
+                    const reason = 'the host declined to apply the edit';
+                    adapter.diagnostics(`insert component: the host declined to apply the edit for "${request.name}".`);
+                    return { kind: 'failed', reason };
+                }
+                return { kind: 'inserted', cursor: plan.cursor };
+            }
+            catch (err) {
+                return failedOutcome(adapter, 'insert component', err);
+            }
         },
         diagnostics(line) {
             adapter.diagnostics(line);

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

@@ -70,6 +70,8 @@ export declare function imageEmbedDiagnosticLines(images: EmbeddedImageReport):
 export declare function exportDiagnosticLines(outcome: NoteFileExportOutcome): string[];
 /** What `exportHtmlDocumentViaAdapter` needs beyond the note's own text and path. */
 export interface ExportHtmlDocumentRequest {
+    /** Where to write the file. When present the adapter's `resolveTarget` is not asked. */
+    readonly targetPath?: string;
     /** The static HTML engine. Required for the `html` and `pdf` formats; `exportNoteFileViaAdapter` declines those without it. */
     readonly engine?: HtmlExportEngine;
     readonly notePath: string;

package/dist/host/export-behavior.js

@@ -148,6 +148,12 @@ export async function buildExportDocument(request) {
         images: document.images,
     };
 }
+/** The path an export writes to: the request's own `targetPath`, else whatever the adapter's `resolveTarget` picks, which resolves `undefined` on a cancel. */
+async function exportTarget(adapter, request, format) {
+    if (request.targetPath !== undefined)
+        return request.targetPath;
+    return adapter.exports?.resolveTarget?.(exportDefaultFileName(request.notePath, format), format);
+}
 function reasonOf(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -176,7 +182,7 @@ export async function exportNoteFileViaAdapter(adapter, format, request, renderA
             const built = await buildExportDocument({ ...request, engine });
             if (format === 'html') {
                 const bytes = new TextEncoder().encode(built.html).byteLength;
-                const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'html'), 'html');
+                const path = await exportTarget(adapter, request, 'html');
                 if (path === undefined)
                     return undefined;
                 await adapter.writeFile(path, new TextEncoder().encode(built.html));
@@ -194,7 +200,7 @@ export async function exportNoteFileViaAdapter(adapter, format, request, renderA
             const htmlToPdf = adapter.exports?.htmlToPdf;
             if (htmlToPdf === undefined)
                 return undefined;
-            const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'pdf'), 'pdf');
+            const path = await exportTarget(adapter, request, 'pdf');
             if (path === undefined)
                 return undefined;
             const pdfBytes = await htmlToPdf(built.html);
@@ -216,7 +222,7 @@ export async function exportNoteFileViaAdapter(adapter, format, request, renderA
     if (format === 'md-plain') {
         try {
             const text = mdPlainFromSource(request.text);
-            const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'md-plain'), 'md-plain');
+            const path = await exportTarget(adapter, request, 'md-plain');
             if (path === undefined)
                 return undefined;
             await adapter.writeFile(path, new TextEncoder().encode(text));
@@ -238,7 +244,7 @@ export async function exportNoteFileViaAdapter(adapter, format, request, renderA
         return undefined;
     try {
         const text = await renderAnsi(request.text);
-        const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'ansi'), 'ansi');
+        const path = await exportTarget(adapter, request, 'ansi');
         if (path === undefined)
             return undefined;
         await adapter.writeFile(path, new TextEncoder().encode(text));

package/dist/host/pack-archive.d.ts

@@ -4,12 +4,13 @@ export declare function describeArchiveError(error: PackArchiveError): string;
 /** Writes one file and creates its missing parent folders: `HostAdapter.writeFile`. */
 export type ArchiveFileWriter = (absolutePath: string, bytes: Uint8Array) => Promise<void>;
 /**
- * Writes a validated archive's contents into `destinationDir`: `pack.json`
- * (the parsed manifest, re-serialized: `openPackArchive` keeps only the
- * validated manifest fields, not the original bytes, so the written file
- * is a normalized round-trip of the same fields, not a byte-for-byte
- * copy), `webview.js`, `webview.css` and `terminal.js` when the archive has them, and
- * `scripts/*` when it ships any. Does NOT clear `destinationDir` first;
+ * Writes a validated archive's contents into `destinationDir`: `webview.js`,
+ * `webview.css` and `terminal.js` when the archive has them, `scripts/*`
+ * when it ships any, and then `pack.json` (the parsed manifest,
+ * re-serialized: `openPackArchive` keeps only the validated manifest
+ * fields, not the original bytes, so the written file is a normalized
+ * round-trip of the same fields, not a byte-for-byte copy). The manifest is
+ * written last, so a failure midway leaves no loadable pack. Does NOT clear `destinationDir` first;
  * a caller that needs a clean re-extract (a reinstall replacing an
  * existing pack) removes the folder itself before this.
  *

package/dist/host/pack-archive.js

@@ -21,12 +21,13 @@ export function describeArchiveError(error) {
     return `invalid pack.json in archive (${error.errors.join('; ')})`;
 }
 /**
- * Writes a validated archive's contents into `destinationDir`: `pack.json`
- * (the parsed manifest, re-serialized: `openPackArchive` keeps only the
- * validated manifest fields, not the original bytes, so the written file
- * is a normalized round-trip of the same fields, not a byte-for-byte
- * copy), `webview.js`, `webview.css` and `terminal.js` when the archive has them, and
- * `scripts/*` when it ships any. Does NOT clear `destinationDir` first;
+ * Writes a validated archive's contents into `destinationDir`: `webview.js`,
+ * `webview.css` and `terminal.js` when the archive has them, `scripts/*`
+ * when it ships any, and then `pack.json` (the parsed manifest,
+ * re-serialized: `openPackArchive` keeps only the validated manifest
+ * fields, not the original bytes, so the written file is a normalized
+ * round-trip of the same fields, not a byte-for-byte copy). The manifest is
+ * written last, so a failure midway leaves no loadable pack. Does NOT clear `destinationDir` first;
  * a caller that needs a clean re-extract (a reinstall replacing an
  * existing pack) removes the folder itself before this.
  *
@@ -40,7 +41,6 @@ export function describeArchiveError(error) {
  */
 export async function writeArchiveContents(archive, destinationDir, writeFile) {
     const encoder = new TextEncoder();
-    await writeFile(joinPath(destinationDir, 'pack.json'), encoder.encode(JSON.stringify(archive.manifest, null, 2) + '\n'));
     await writeFile(joinPath(destinationDir, 'webview.js'), archive.scriptBytes);
     if (archive.stylesheetBytes !== undefined) {
         await writeFile(joinPath(destinationDir, 'webview.css'), archive.stylesheetBytes);
@@ -56,4 +56,8 @@ export async function writeArchiveContents(archive, destinationDir, writeFile) {
             await writeFile(target, archive.scriptModules[name]);
         }
     }
+    // The manifest goes last. Discovery treats a folder with no `pack.json`
+    // as no pack, so an install that fails partway never leaves a manifest
+    // beside a missing script.
+    await writeFile(joinPath(destinationDir, 'pack.json'), encoder.encode(JSON.stringify(archive.manifest, null, 2) + '\n'));
 }

package/dist/host/pack-install.js

@@ -43,7 +43,7 @@ export async function installPackFromArchive(adapter, options) {
     const opened = await openPackArchive(archiveBytes);
     if (!opened.ok) {
         return {
-            kind: 'rejected',
+            kind: 'invalid',
             reason: `"${archivePath}" is not a valid pack archive: ${describeArchiveError(opened.error)}`,
         };
     }
@@ -62,7 +62,7 @@ export async function installPackFromArchive(adapter, options) {
         });
     }
     catch (err) {
-        return { kind: 'rejected', reason: describeThrown(err) };
+        return { kind: 'failed', reason: describeThrown(err) };
     }
     if (!consented) {
         return { kind: 'declined', step: 'consent', namespace: packName };
@@ -73,7 +73,7 @@ export async function installPackFromArchive(adapter, options) {
         alreadyInstalled = await exists(targetDir);
     }
     catch (err) {
-        return { kind: 'rejected', reason: describeThrown(err) };
+        return { kind: 'failed', reason: describeThrown(err) };
     }
     let replaced = false;
     if (alreadyInstalled) {
@@ -88,7 +88,7 @@ export async function installPackFromArchive(adapter, options) {
             });
         }
         catch (err) {
-            return { kind: 'rejected', reason: describeThrown(err) };
+            return { kind: 'failed', reason: describeThrown(err) };
         }
         if (!proceed) {
             return { kind: 'declined', step: 'replace', namespace: packName };
@@ -102,7 +102,7 @@ export async function installPackFromArchive(adapter, options) {
     }
     catch (err) {
         return {
-            kind: 'rejected',
+            kind: 'failed',
             reason: `could not install pack "${packName}": ${describeThrown(err)}`,
         };
     }
@@ -153,7 +153,9 @@ export function installReplaceConfirmMessage(packName) {
  * `false`.
  */
 export function installPackMessage(outcome, archivePath, labels, reloadsAutomatically = false) {
-    if (outcome.kind === 'rejected' || outcome.kind === 'unsupported') {
+    if (outcome.kind === 'invalid' ||
+        outcome.kind === 'failed' ||
+        outcome.kind === 'unsupported') {
         return `Markii: could not install a pack from "${archivePath}". Open ${labels.diagnosticsSurface} for details.`;
     }
     if (outcome.kind === 'reserved') {
@@ -171,7 +173,7 @@ export function installPackMessage(outcome, archivePath, labels, reloadsAutomati
 }
 /** The full diagnostics-surface detail for one install attempt (AGENTS.md's "clean is not silent": the other of a failure's two homes). */
 export function installPackDiagnosticLines(outcome, archivePath) {
-    if (outcome.kind === 'rejected') {
+    if (outcome.kind === 'invalid' || outcome.kind === 'failed') {
         return [
             `Install pack from file rejected "${archivePath}": ${outcome.reason}`,
         ];

package/dist/host/pack-remove.d.ts

@@ -1,21 +1,10 @@
 import type { HostAdapter } from './adapter.js';
-export type RemovePackOutcome = {
-    readonly kind: 'removed';
-    readonly namespace: string;
-} | {
-    readonly kind: 'not-installed';
-    readonly namespace: string;
-} | {
-    readonly kind: 'reserved';
-    readonly namespace: string;
-} | {
-    readonly kind: 'invalid';
-    readonly reason: string;
-} | {
-    readonly kind: 'failed';
-    readonly reason: string;
-};
+import type { RemovePackOutcome } from './create-host.js';
+/** What one removal attempt produced, in the shape `createMarkiiHost(...).removePack` returns (minus `unsupported`, which only the host behavior can say). */
+export type RemovePackAttempt = Exclude<RemovePackOutcome, {
+    readonly kind: 'unsupported';
+}>;
 /** Never throws. The caller checks `adapter.packs.installRoot`/`removeFolder` exist first. */
-export declare function removePackViaAdapter(adapter: HostAdapter, namespace: string, installRoot: string, removeFolder: (folder: string) => Promise<void>, reservedNamespaces: ReadonlySet<string>): Promise<RemovePackOutcome>;
+export declare function removePackViaAdapter(adapter: HostAdapter, namespace: string, installRoot: string, removeFolder: (folder: string) => Promise<void>, reservedNamespaces: ReadonlySet<string>): Promise<RemovePackAttempt>;
 export declare function removePackMessage(outcome: RemovePackOutcome): string;
-export declare function removePackDiagnosticLine(outcome: RemovePackOutcome): string;
+export declare function removePackDiagnosticLine(outcome: RemovePackAttempt): string;

package/dist/host/pack-remove.js

@@ -37,6 +37,8 @@ export async function removePackViaAdapter(adapter, namespace, installRoot, remo
 }
 export function removePackMessage(outcome) {
     switch (outcome.kind) {
+        case 'unsupported':
+            return 'Markii: removing packs is not available on this host. Nothing was removed.';
         case 'removed':
             return `Markii: removed pack "${outcome.namespace}".`;
         case 'not-installed':