@markii/host 0.0.1 → 0.17.0-next.2

package/dist/host/export-behavior.js

@@ -0,0 +1,257 @@
+import { buildNoteExport, exportedFileName, noteHasScripts, } from '../export/note-export.js';
+import { EMPTY_IMAGE_REPORT, MAX_EMBEDDED_IMAGE_BYTES, } from '../export/image-embed.js';
+import { mdPlainFromSource } from './export/md-plain.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 function exportDefaultFileName(notePath, format) {
+    const extension = {
+        html: '.html',
+        pdf: '.pdf',
+        ansi: '.txt',
+        'md-plain': '.md',
+    };
+    return exportedFileName(notePath, extension[format]);
+}
+/** The last path segment of a `/`-separated or `\`-separated path, for naming a file in a message. */
+export function fileNameOf(path) {
+    const segments = path.split(/[/\\]/);
+    return segments[segments.length - 1] ?? path;
+}
+/**
+ * The short result message for a written or failed html/pdf export. A
+ * success names the file. A failure says what failed and points at this
+ * host's own diagnostics surface (`labels.diagnosticsSurface`), never at
+ * a stack trace — the verbatim reason goes there instead.
+ */
+export function exportResultMessage(outcome, labels) {
+    if (outcome.kind === 'failed') {
+        return `Markii: could not export this note. Open ${labels.diagnosticsSurface} for details.`;
+    }
+    const name = fileNameOf(outcome.path);
+    return outcome.valueCount === 0 && outcome.hasScripts === true
+        ? `Markii: exported ${name}. The note has no stored script values, so data-bound components show their empty states.`
+        : `Markii: exported ${name}.`;
+}
+/** 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 function renderEngineDiagnosticLine(render) {
+    if (render.engine === 'react') {
+        const packs = render.packCount === 1 ? '1 pack' : `${String(render.packCount)} packs`;
+        const stylesheets = render.stylesheetCount === 1
+            ? '1 stylesheet'
+            : `${String(render.stylesheetCount)} stylesheets`;
+        return `Rendered through the preview's React engine, with ${packs} and ${stylesheets} embedded.`;
+    }
+    if (render.reason === 'no-packs') {
+        return 'Rendered with the static engine because no pack components are loaded, which matches what the preview shows.';
+    }
+    if (render.reason === 'no-renderer') {
+        return 'Rendered with the static engine because a preview panel could not be opened for this note. Pack components exported as labeled boxes; open the preview and export again to include them.';
+    }
+    if (render.reason === 'timeout') {
+        const detail = render.detail ? ` Detail: ${render.detail}` : '';
+        return `Rendered with the static engine because the preview did not answer in time. Pack components exported as labeled boxes.${detail}`;
+    }
+    const detail = render.detail ? ` Detail: ${render.detail}` : '';
+    return `Rendered with the static engine because the preview could not render the note. Pack components exported as labeled boxes.${detail}`;
+}
+/** One skipped image's diagnostics line: which file, and why it kept its original source instead of being embedded. */
+function skippedImageLine(skipped) {
+    if (skipped.reason === 'too-large') {
+        const size = skipped.byteLength !== undefined
+            ? formatByteSize(skipped.byteLength)
+            : 'an unknown size';
+        return `Skipped ${skipped.src}: ${size}, over the ${formatByteSize(MAX_EMBEDDED_IMAGE_BYTES)} embed limit.`;
+    }
+    if (skipped.reason === 'unsupported-type') {
+        return `Skipped ${skipped.src}: this file type is not supported for embedding.`;
+    }
+    return `Skipped ${skipped.src}: ${skipped.detail ?? 'the file could not be read'}.`;
+}
+/** `bytes`, formatted as a human-readable size (`"1.2 KB"`, `"512 bytes"`). */
+export function formatByteSize(bytes) {
+    if (bytes < 1024)
+        return bytes === 1 ? '1 byte' : `${String(bytes)} bytes`;
+    const kb = bytes / 1024;
+    if (kb < 1024)
+        return `${kb.toFixed(1)} KB`;
+    return `${(kb / 1024).toFixed(1)} MB`;
+}
+/** The image lines for `exportDiagnosticLines`: how many images were embedded and how many bytes they added, one line per skipped image, and a remote-source count when any sources still reach the network. Empty when a note has no images at all. */
+export function imageEmbedDiagnosticLines(images) {
+    const lines = [];
+    if (images.embedded.length > 0) {
+        const count = images.embedded.length === 1
+            ? '1 image'
+            : `${String(images.embedded.length)} images`;
+        lines.push(`Embedded ${count}, adding ${formatByteSize(images.embeddedBytes)} to the exported file.`);
+    }
+    for (const skipped of images.skipped) {
+        lines.push(skippedImageLine(skipped));
+    }
+    if (images.remote > 0) {
+        const line = images.remote === 1
+            ? '1 image source still points at a remote URL and needs network access to load.'
+            : `${String(images.remote)} image sources still point at remote URLs and need network access to load.`;
+        lines.push(line);
+    }
+    return lines;
+}
+/** The full diagnostics-surface detail for one html/pdf export attempt. */
+export function exportDiagnosticLines(outcome) {
+    if (outcome.kind === 'failed') {
+        const where = outcome.path ? ` to ${outcome.path}` : '';
+        return [`Export failed${where}: ${outcome.reason}`];
+    }
+    return [
+        `Export wrote ${outcome.path}: ${String(outcome.bytes)} bytes, ${String(outcome.valueCount)} stored values baked in.`,
+        renderEngineDiagnosticLine(outcome.render),
+        ...imageEmbedDiagnosticLines(outcome.images),
+    ];
+}
+/** Builds the standalone HTML document `html` and `pdf` both export, via the shared, already-host-neutral `buildNoteExport`. Never throws: a failing `renderBody` degrades to the static engine rather than propagating. */
+export async function buildExportDocument(request) {
+    const values = request.values ?? {};
+    const document = await buildNoteExport({
+        engine: request.engine,
+        text: request.text,
+        fileName: request.notePath,
+        values,
+        ...(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 }
+            : {}),
+        ...(request.unavailableComponents !== undefined
+            ? { unavailableComponents: request.unavailableComponents }
+            : {}),
+        ...(request.onDiagnostic !== undefined
+            ? { onDiagnostic: request.onDiagnostic }
+            : {}),
+    });
+    return {
+        html: document.html,
+        valueCount: document.valueCount,
+        hasScripts: noteHasScripts(request.text),
+        render: document.render,
+        images: document.images,
+    };
+}
+function reasonOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+/**
+ * Exports one note as `format`, gated on `adapter.exports?.formats`. A
+ * format the host has not declared returns `undefined` immediately
+ * (`createMarkiiHost`'s `exportNote` turns that into the shared
+ * `Unsupported` outcome and writes its own diagnostics line, matching
+ * every other capability-gated behavior).
+ *
+ * `renderAnsi` is required to actually produce an `'ansi'` outcome — a
+ * host that offers the `'ansi'` FORMAT capability but passes no renderer
+ * is a configuration bug on that host's part, not a Markii user's problem
+ * to see, so it also resolves to `undefined` here (never a thrown error)
+ * and the caller's `Unsupported` fallback covers it.
+ */
+export async function exportNoteFileViaAdapter(adapter, format, request, renderAnsi) {
+    const formats = adapter.exports?.formats;
+    if (formats === undefined || !formats.has(format))
+        return undefined;
+    if (format === 'html' || format === 'pdf') {
+        const engine = request.engine;
+        if (engine === undefined)
+            return undefined;
+        try {
+            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');
+                if (path === undefined)
+                    return undefined;
+                await adapter.writeFile(path, new TextEncoder().encode(built.html));
+                return {
+                    kind: 'written',
+                    path,
+                    bytes,
+                    valueCount: built.valueCount,
+                    hasScripts: built.hasScripts,
+                    render: built.render,
+                    images: built.images,
+                };
+            }
+            // 'pdf': the seam only. Degradation policy stays app-side.
+            const htmlToPdf = adapter.exports?.htmlToPdf;
+            if (htmlToPdf === undefined)
+                return undefined;
+            const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'pdf'), 'pdf');
+            if (path === undefined)
+                return undefined;
+            const pdfBytes = await htmlToPdf(built.html);
+            await adapter.writeFile(path, pdfBytes);
+            return {
+                kind: 'written',
+                path,
+                bytes: pdfBytes.byteLength,
+                valueCount: built.valueCount,
+                hasScripts: built.hasScripts,
+                render: built.render,
+                images: built.images,
+            };
+        }
+        catch (error) {
+            return { kind: 'failed', reason: reasonOf(error) };
+        }
+    }
+    if (format === 'md-plain') {
+        try {
+            const text = mdPlainFromSource(request.text);
+            const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'md-plain'), 'md-plain');
+            if (path === undefined)
+                return undefined;
+            await adapter.writeFile(path, new TextEncoder().encode(text));
+            return {
+                kind: 'written',
+                path,
+                bytes: new TextEncoder().encode(text).byteLength,
+                valueCount: 0,
+                render: { engine: 'static', reason: 'no-packs' },
+                images: EMPTY_IMAGE_REPORT,
+            };
+        }
+        catch (error) {
+            return { kind: 'failed', reason: reasonOf(error) };
+        }
+    }
+    // format === 'ansi'
+    if (renderAnsi === undefined)
+        return undefined;
+    try {
+        const text = await renderAnsi(request.text);
+        const path = await adapter.exports?.resolveTarget(exportDefaultFileName(request.notePath, 'ansi'), 'ansi');
+        if (path === undefined)
+            return undefined;
+        await adapter.writeFile(path, new TextEncoder().encode(text));
+        return {
+            kind: 'written',
+            path,
+            bytes: new TextEncoder().encode(text).byteLength,
+            valueCount: 0,
+            render: { engine: 'static', reason: 'no-packs' },
+            images: EMPTY_IMAGE_REPORT,
+        };
+    }
+    catch (error) {
+        return { kind: 'failed', reason: reasonOf(error) };
+    }
+}

package/dist/host/labels.d.ts

@@ -0,0 +1,24 @@
+/**
+ * `HostLabels`: the wording nouns every shared behavior module
+ * (`./script-execution.ts`, `./refresh-interval.ts`) interpolates, and the
+ * one concrete record per app this repo ships. Each app's `HostAdapter`
+ * imports its record rather than inventing its own strings, which is what
+ * collapses the survey's near-identical wording pairs (`tmp/W11-survey.md`,
+ * section A4) into one template.
+ *
+ * Pure and dependency-free: re-exported from `../browser.ts` as well as
+ * `../index.ts` so VS Code's Node-free webview bundle can read it too.
+ */
+import type { HostLabels } from './adapter.js';
+/** The VS Code extension's labels, taken from its current wording (`apps/vscode/src/script-execution.ts`, `apps/vscode/src/extension.ts`'s output channel). */
+export declare const VSCODE_LABELS: HostLabels;
+/** The Obsidian plugin's labels, taken from its current wording (`apps/obsidian/src/script-execution.ts`, docs/integration.md's host checklist). */
+export declare const OBSIDIAN_LABELS: HostLabels;
+/** The `markii` command line tool's labels: it has no persistent preview panel, and its diagnostics surface is stderr, gated behind `--verbose` for anything short of a failure (`apps/cli/src/main.ts`). */
+export declare const CLI_LABELS: HostLabels;
+/**
+ * The quiet marker a rendered note shows when its `uses:` list names packs
+ * this host has not installed (docs/packs.md). One sentence for every host;
+ * the tooltip beside it, which says how to install, stays host-specific.
+ */
+export declare function packsNotInstalledLabel(missing: readonly string[]): string;

package/dist/host/labels.js

@@ -0,0 +1,32 @@
+/** The VS Code extension's labels, taken from its current wording (`apps/vscode/src/script-execution.ts`, `apps/vscode/src/extension.ts`'s output channel). */
+export const VSCODE_LABELS = {
+    appNoun: 'extension',
+    previewNoun: 'the Markii preview',
+    diagnosticsSurface: 'the Markii output channel',
+    deviceNoun: 'this device',
+    settingName: 'markii.scriptsDisabled',
+};
+/** The Obsidian plugin's labels, taken from its current wording (`apps/obsidian/src/script-execution.ts`, docs/integration.md's host checklist). */
+export const OBSIDIAN_LABELS = {
+    appNoun: 'plugin',
+    previewNoun: 'the Markii preview',
+    diagnosticsSurface: 'the Markii diagnostics',
+    deviceNoun: 'this device',
+};
+/** The `markii` command line tool's labels: it has no persistent preview panel, and its diagnostics surface is stderr, gated behind `--verbose` for anything short of a failure (`apps/cli/src/main.ts`). */
+export const CLI_LABELS = {
+    appNoun: 'command line tool',
+    previewNoun: 'the rendered note',
+    diagnosticsSurface: 'stderr',
+    deviceNoun: 'this device',
+};
+/**
+ * The quiet marker a rendered note shows when its `uses:` list names packs
+ * this host has not installed (docs/packs.md). One sentence for every host;
+ * the tooltip beside it, which says how to install, stays host-specific.
+ */
+export function packsNotInstalledLabel(missing) {
+    return missing.length === 1
+        ? `Pack not installed: ${missing[0]}`
+        : `Packs not installed: ${missing.join(', ')}`;
+}

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

@@ -0,0 +1,30 @@
+import type { PackArchiveContents, PackArchiveError } from '@markii/pack';
+/** One line describing why `openPackArchive` rejected an archive, for a host's install-diagnostics wording. Passes `kind: 'zip'`'s and `kind: 'missing-entry'`'s message through verbatim (already specific); summarizes a manifest failure plainly. */
+export declare function describeArchiveError(error: PackArchiveError): string;
+/** The filesystem write seam `writeArchiveContents` needs (`./pack-install.ts`). Deliberately narrow: extracting an archive only ever creates files under a directory it first clears, it never reads back or deletes anything else. */
+export interface ArchiveExtractFs {
+    /** Removes `absolutePath` and everything under it, or resolves quietly if it does not exist. Never rejects: a directory that fails to clear is treated the same as a fresh one, and the write that follows fails loudly on its own if the path is genuinely unusable. */
+    readonly removeDirectory: (absolutePath: string) => Promise<void>;
+    /** Creates a directory and any missing parents. May reject on a genuine I/O failure. */
+    readonly makeDirectory: (absolutePath: string) => Promise<void>;
+    readonly writeFile: (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;
+ * a caller that needs a clean re-extract (a reinstall replacing an
+ * existing pack) calls `fs.removeDirectory` itself before this.
+ *
+ * PATH JAIL: `@markii/pack`'s `openPackArchive` has already rejected any
+ * entry whose name escapes the archive (`../`, an absolute path) or
+ * exceeds its size caps before this function ever sees `archive` — every
+ * path it writes here is built from `destinationDir` joined with a plain,
+ * already-validated relative name (`pack.json`, `webview.js`,
+ * `webview.css`, or a `scripts/`-relative Lua module name), never from
+ * anything read back out of the zip's raw entry names.
+ */
+export declare function writeArchiveContents(archive: PackArchiveContents, destinationDir: string, fs: ArchiveExtractFs): Promise<void>;

package/dist/host/pack-archive.js

@@ -0,0 +1,68 @@
+/**
+ * `.mkp` pack archive handling, merged from `apps/vscode/src/packs/archive-packs.ts`
+ * and `apps/obsidian/src/packs/archive-packs.ts` (survey finding A8). The
+ * orchestrator diffed the two files directly (not through the survey's
+ * earlier, unverified guess) and found them functionally byte-identical:
+ * the same three exports (`describeArchiveError`, `writeArchiveContents`,
+ * `ArchiveExtractFs`), the same implementation, the same path-jail
+ * reasoning. They differed only in doc-comment wording (which host's
+ * install command they described) and one em dash in a comment, which
+ * carries no behavior. See `tmp/W11-phase1b.md` for the exact diff output.
+ *
+ * This module bridges `@markii/pack`'s in-memory archive reader
+ * (`openPackArchive`, never modified here) into the write a pack install
+ * needs: extracting a validated archive's contents onto disk, under
+ * whichever install root the calling host names (`HostPackSource.installRoot`).
+ *
+ * Environment-free (`ArchiveExtractFs` is an injected seam). The real
+ * Node-backed one, `createNodeArchiveExtractFs`, lives in `../node-fs.ts`
+ * and is exported from `@markii/host/node`.
+ */
+import { dirnamePath, joinPath } from '../path-util.js';
+/** One line describing why `openPackArchive` rejected an archive, for a host's install-diagnostics wording. Passes `kind: 'zip'`'s and `kind: 'missing-entry'`'s message through verbatim (already specific); summarizes a manifest failure plainly. */
+export function describeArchiveError(error) {
+    if (error.kind === 'zip')
+        return error.message;
+    if (error.kind === 'missing-entry')
+        return error.message;
+    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;
+ * a caller that needs a clean re-extract (a reinstall replacing an
+ * existing pack) calls `fs.removeDirectory` itself before this.
+ *
+ * PATH JAIL: `@markii/pack`'s `openPackArchive` has already rejected any
+ * entry whose name escapes the archive (`../`, an absolute path) or
+ * exceeds its size caps before this function ever sees `archive` — every
+ * path it writes here is built from `destinationDir` joined with a plain,
+ * already-validated relative name (`pack.json`, `webview.js`,
+ * `webview.css`, or a `scripts/`-relative Lua module name), never from
+ * anything read back out of the zip's raw entry names.
+ */
+export async function writeArchiveContents(archive, destinationDir, fs) {
+    await fs.makeDirectory(destinationDir);
+    const encoder = new TextEncoder();
+    await fs.writeFile(joinPath(destinationDir, 'pack.json'), encoder.encode(JSON.stringify(archive.manifest, null, 2) + '\n'));
+    await fs.writeFile(joinPath(destinationDir, 'webview.js'), archive.scriptBytes);
+    if (archive.stylesheetBytes !== undefined) {
+        await fs.writeFile(joinPath(destinationDir, 'webview.css'), archive.stylesheetBytes);
+    }
+    if (archive.terminalScriptBytes !== undefined) {
+        await fs.writeFile(joinPath(destinationDir, 'terminal.js'), archive.terminalScriptBytes);
+    }
+    const moduleNames = Object.keys(archive.scriptModules);
+    if (moduleNames.length > 0) {
+        const scriptsDir = joinPath(destinationDir, 'scripts');
+        for (const name of moduleNames) {
+            const target = joinPath(scriptsDir, name);
+            await fs.makeDirectory(dirnamePath(target));
+            await fs.writeFile(target, archive.scriptModules[name]);
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+import type { ArchiveExtractFs } from './pack-archive.js';
+import type { HostAdapter, HostLabels } from './adapter.js';
+/** Whether a directory already exists under the install root, injected so this module needs no real disk to test. */
+export type PackDirectoryExists = (absolutePath: string) => Promise<boolean>;
+export interface InstallPackFromArchiveOptions {
+    readonly archiveBytes: Uint8Array;
+    /** The `.mkp` file's own path, used only in a rejection's diagnostic wording. Never read again once `archiveBytes` is in hand. */
+    readonly archivePath: string;
+    /** This host's own pack-install directory (`HostPackSource.installRoot()`). Each installed pack gets a subdirectory named by its namespace, since two packs can never share one (docs/packs.md's collision rule), which makes "is this namespace already installed" a plain directory check. */
+    readonly installRoot: string;
+    readonly exists: PackDirectoryExists;
+    readonly extractFs: ArchiveExtractFs;
+    /**
+     * Namespaces this install may never claim (`HostPackSource.reservedNamespaces()`).
+     * Empty for a host with no reserved set (VS Code). Checked before the
+     * consent prompt — a reserved namespace cannot be shadowed by an install.
+     */
+    readonly reservedNamespaces: ReadonlySet<string>;
+}
+export type InstallPackOutcome = {
+    readonly kind: 'installed';
+    readonly packName: string;
+    readonly installedDir: string;
+    readonly replaced: boolean;
+} | {
+    readonly kind: 'declined';
+    readonly step: 'consent' | 'replace';
+    readonly packName: string;
+} | {
+    readonly kind: 'reserved';
+    readonly packName: string;
+} | {
+    readonly kind: 'rejected';
+    readonly reason: string;
+};
+/**
+ * Never throws: a validation failure, a declined prompt, or a write
+ * failure all come back as a structured outcome. Order: validate the
+ * archive first (a rejected archive is never even offered the consent
+ * prompt), then refuse a reserved namespace, then ask consent to run its
+ * code, then, only if a pack of the same namespace is already installed,
+ * ask to replace it. Nothing is written until every applicable step has
+ * said yes.
+ *
+ * Every prompt routes through `adapter.prompt` with `kind:
+ * 'pack-install-consent'`/`'pack-replace'`, per `HostAdapter`'s contract —
+ * a host that can only show a non-blocking surface must deny rather than
+ * assume yes.
+ */
+export declare function installPackFromArchive(adapter: HostAdapter, options: InstallPackFromArchiveOptions): Promise<InstallPackOutcome>;
+/**
+ * The consent prompt's wording (AGENTS.md's product principles: "clean is
+ * not silent," and a consent step must say plainly what it authorizes).
+ * States outright that the pack's code will run inside the preview, since
+ * this is the one place that consent is asked, so it has to say it, not
+ * hint at it.
+ *
+ * CANONICAL WORDING CHOSEN over the two apps' prior copy (report this as a
+ * before/after pair): "from someone you trust" (Obsidian's phrasing) over
+ * "from a source you trust" (VS Code's), and `labels.previewNoun` ("the
+ * Markii preview" for both hosts) in place of VS Code's prior "every
+ * Markii preview" — `HostLabels.previewNoun` already gives both hosts the
+ * same noun, so the interpolation settles the wording rather than
+ * widening `HostLabels` for a distinction the record does not carry.
+ */
+export declare function installConsentMessage(packName: string, labels: HostLabels): string;
+/**
+ * The collision confirmation's wording: a namespace already installed,
+ * asked before replacing it. CANONICAL WORDING: "removes" (VS Code's prior
+ * wording) over Obsidian's prior "deletes" — see `tmp/W11-phase1b.md`'s
+ * before/after table for the exact strings this replaces.
+ */
+export declare function installReplaceConfirmMessage(packName: string): string;
+/**
+ * The one result message for the install command, matching this host's
+ * wording rules (two short sentences, no em dashes or parentheses in the
+ * popup; the full detail goes to the diagnostics surface).
+ *
+ * `reloadsAutomatically` is a per-host BEHAVIOR fact, not a wording noun:
+ * Obsidian's install command reloads every open view's packs immediately
+ * after a successful install, so its message says so; VS Code's install
+ * command does not (an installed pack still needs to be added to
+ * `markii.packs` before anything loads it), so it doesn't. Defaults to
+ * `false`.
+ */
+export declare function installPackMessage(outcome: InstallPackOutcome, archivePath: string, labels: HostLabels, reloadsAutomatically?: boolean): string;
+/** 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 declare function installPackDiagnosticLines(outcome: InstallPackOutcome, archivePath: string): string[];