@markii/ansi 0.15.0 → 0.17.0-next.0

package/dist/interactive.js

@@ -0,0 +1,207 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
+import { Box, Text, measureElement, useInput } from 'ink';
+import { dim } from './ansi.js';
+import { style } from './style.js';
+import { cutToWidth } from './text-grid.js';
+const FocusContext = createContext({
+    interactive: false,
+    focusedId: undefined,
+    focusMarker: (text) => text,
+    reportActiveLabel: () => { },
+    registerAnchor: () => { },
+});
+/** Whether the component identified by `focusId` is the currently focused one. `undefined` (a non-interactive render, or a component that never got a `focusId`) is never focused. */
+export function useIsFocused(focusId) {
+    const api = useContext(FocusContext);
+    return focusId !== undefined && api.interactive && api.focusedId === focusId;
+}
+/** Wraps `text` in the accent-colored focus marker when interactive AND `focusId` is the focused one; otherwise returns `text` unchanged. */
+export function useFocusMarker(text, focusId) {
+    const api = useContext(FocusContext);
+    const focused = focusId !== undefined && api.interactive && api.focusedId === focusId;
+    return focused ? api.focusMarker(text) : text;
+}
+/**
+ * Lets a `tabs` instance report its currently active panel's label to
+ * `InteractiveRoot`, so the status line names the panel showing rather than
+ * the block's first one. Call it from an effect, never during render (see
+ * `FocusApi.reportActiveLabel`).
+ */
+export function useReportActiveLabel() {
+    const api = useContext(FocusContext);
+    return api.reportActiveLabel;
+}
+/**
+ * The ref callback a focusable component puts on its outermost `Box`, so
+ * the live viewer can scroll the focused block into view. A no-op without a
+ * `focusId` or outside an interactive render.
+ */
+export function useFocusAnchor(focusId) {
+    const { registerAnchor } = useContext(FocusContext);
+    return useCallback((node) => {
+        if (focusId === undefined)
+            return;
+        registerAnchor(focusId, node ?? undefined);
+    }, [focusId, registerAnchor]);
+}
+/**
+ * The root of an interactive render: owns which `focusId` is focused, moves
+ * it on up/down/j/k, calls `onExit` on `q`, and renders the one-line status
+ * bar (batch 10.1) naming the focused block and the key legend. Rendered
+ * only when the caller actually wants a live, keyboard-driven view:
+ * `buildMarkElement` mounts this when `interactive` is true, but the
+ * render-ONCE string path (`ink-string.ts`, `renderRootToString`) never
+ * reaches it at all — `tabs`/`details` still fall back to `FocusContext`'s
+ * default (uninteractive) value there, so a string render never sees a
+ * focus marker, a glyph, or a status line.
+ */
+export function InteractiveRoot({ focusables, onExit, color, theme, keyLegend, viewportRows, width, children, }) {
+    const focusableCount = focusables.length;
+    const [focusIndex, setFocusIndex] = useState(0);
+    // `focusId -> the label its last active-panel report carried`. Only a
+    // `tabs` descriptor is ever reported against; `details` never calls
+    // `reportActiveLabel`, so its entry here simply never appears. Absent
+    // keys are expected (mount, or a `tabs` the reader has not switched yet)
+    // and fall back to the descriptor's own stable `label` below.
+    const [activeLabels, setActiveLabels] = useState({});
+    const viewport = viewportRows !== undefined ? Math.max(1, viewportRows - 1) : undefined;
+    const [offset, setOffset] = useState(0);
+    const contentRef = useRef(null);
+    const anchors = useRef(new Map());
+    // What the last reveal pass saw, so a reveal runs when focus MOVES or the
+    // focused block changes height (a details opening), and not on every
+    // render: a reader who scrolled away on purpose is left where they are.
+    const lastRevealed = useRef({
+        id: undefined,
+        height: -1,
+    });
+    const contentHeight = () => contentRef.current ? measureElement(contentRef.current).height : 0;
+    const maxOffset = () => viewport === undefined ? 0 : Math.max(0, contentHeight() - viewport);
+    const scrollBy = (delta) => {
+        if (viewport === undefined)
+            return;
+        const limit = maxOffset();
+        setOffset((current) => Math.min(limit, Math.max(0, current + delta)));
+    };
+    const scrollTo = (target) => {
+        if (viewport === undefined)
+            return;
+        setOffset(target === 'top' ? 0 : maxOffset());
+    };
+    useInput((input, key) => {
+        if (input === 'q') {
+            onExit?.();
+            return;
+        }
+        if (viewport !== undefined) {
+            const page = Math.max(1, viewport - 1);
+            if (key.pageDown || input === ' ' || (key.ctrl && input === 'f')) {
+                scrollBy(page);
+                return;
+            }
+            if (key.pageUp || input === 'b' || (key.ctrl && input === 'b')) {
+                scrollBy(-page);
+                return;
+            }
+            if (key.home || input === 'g') {
+                scrollTo('top');
+                return;
+            }
+            if (key.end || input === 'G') {
+                scrollTo('end');
+                return;
+            }
+            if (key.ctrl && input === 'e') {
+                scrollBy(1);
+                return;
+            }
+            if (key.ctrl && input === 'y') {
+                scrollBy(-1);
+                return;
+            }
+        }
+        const down = key.downArrow || input === 'j';
+        const up = key.upArrow || input === 'k';
+        if (focusableCount === 0) {
+            // Nothing to focus: the same keys scroll a line at a time.
+            if (down)
+                scrollBy(1);
+            else if (up)
+                scrollBy(-1);
+            return;
+        }
+        if (down) {
+            setFocusIndex((current) => (current + 1) % focusableCount);
+        }
+        else if (up) {
+            setFocusIndex((current) => (current - 1 + focusableCount) % focusableCount);
+        }
+    }, { isActive: true });
+    const focusedId = focusableCount > 0 ? focusIndex % focusableCount : undefined;
+    // Invoked from `tabs.tsx`'s KEY HANDLER, never during render — see
+    // `FocusApi.reportActiveLabel`'s doc comment. The equality guard avoids an
+    // unnecessary re-render when a switch reports the label it already had
+    // (e.g. wrapping from the last panel back past the first is still a real
+    // change, but re-reporting the same active panel is not).
+    const reportActiveLabel = useCallback((focusId, label) => {
+        setActiveLabels((current) => current[focusId] === label ? current : { ...current, [focusId]: label });
+    }, []);
+    const registerAnchor = useCallback((focusId, node) => {
+        if (node)
+            anchors.current.set(focusId, node);
+        else
+            anchors.current.delete(focusId);
+    }, []);
+    const api = useMemo(() => ({
+        interactive: true,
+        focusedId,
+        focusMarker: (text) => style(text, '--mk-accent', theme, color),
+        reportActiveLabel,
+        registerAnchor,
+    }), [focusedId, color, theme, reportActiveLabel, registerAnchor]);
+    // After every commit Ink has laid the tree out, so this is where the
+    // viewport is kept honest: the offset never exceeds the document (a
+    // resize or a closing details can shrink it), and a focus move, or a
+    // focused block growing, scrolls that block into view.
+    useEffect(() => {
+        if (viewport === undefined || !contentRef.current)
+            return;
+        const content = measureElement(contentRef.current);
+        const limit = Math.max(0, content.height - viewport);
+        let next = Math.min(offset, limit);
+        const anchor = focusedId !== undefined ? anchors.current.get(focusedId) : undefined;
+        if (anchor) {
+            const box = measureElement(anchor);
+            const seen = lastRevealed.current;
+            if (seen.id !== focusedId || seen.height !== box.height) {
+                lastRevealed.current = { id: focusedId, height: box.height };
+                const top = box.y - content.y;
+                const bottom = top + box.height;
+                if (top < next)
+                    next = top;
+                else if (bottom > next + viewport)
+                    next = Math.min(top, bottom - viewport);
+                next = Math.min(limit, Math.max(0, next));
+            }
+        }
+        if (next !== offset)
+            setOffset(next);
+    });
+    const focused = focusedId !== undefined ? focusables[focusedId] : undefined;
+    const focusedLabel = focused && focusedId !== undefined
+        ? (activeLabels[focusedId] ?? focused.label)
+        : undefined;
+    const statusLabel = focused
+        ? `${focused.kind} "${focusedLabel}"`
+        : 'nothing focusable';
+    // Cut to the width on plain text: the status line must stay one row (the
+    // viewport math counts it as one), and a label or legend that wrapped
+    // would push the document up.
+    const statusLine = dim(cutToWidth(`${statusLabel}  ${keyLegend}`, width), color);
+    const status = _jsx(Text, { children: statusLine });
+    if (viewport === undefined) {
+        return (_jsx(FocusContext.Provider, { value: api, children: _jsxs(Box, { flexDirection: "column", children: [children, status] }) }));
+    }
+    return (_jsx(FocusContext.Provider, { value: api, children: _jsxs(Box, { flexDirection: "column", height: viewport + 1, children: [_jsx(Box, { flexDirection: "column", height: viewport, flexShrink: 0, overflow: "hidden", children: _jsx(Box, { ref: contentRef, flexDirection: "column", flexShrink: 0, marginTop: -offset, children: children }) }), status] }) }));
+}

package/dist/layout.js

@@ -1,6 +1,5 @@
 import { ALIGN_PRESETS, LAYOUT_ATTRIBUTE_KEYS, WIDTH_PRESETS, } from '@markii/stdlib';
-import { pad, wrap } from './box.js';
-import { measure } from './measure.js';
+import { padText as pad, wrapText as wrap, measureWidth as measure, } from './text-grid.js';
 /**
  * The terminal counterpart of `@markii/html`'s `layout.ts`: the same closed
  * `width`/`align` vocabulary from `@markii/stdlib`, but resolved to COLUMN

package/dist/pack-loader.d.ts

@@ -0,0 +1,64 @@
+import type { PackManifest } from '@markii/pack';
+import type { AnsiRegistry, AnsiRegistryEntry } from './registry.js';
+/**
+ * This engine's id in a pack manifest's per-component `sources` map
+ * (docs/packs.md). A component with an `ansi` source has a terminal view.
+ */
+export declare const ANSI_ENGINE_ID = "ansi";
+/**
+ * The component modules a host hands to `loadAnsiPack`, keyed by the
+ * manifest's LOCAL component name. Each is the `{ component, inline? }`
+ * pair a pack's `terminal.js` registered (`./pack-script.ts`).
+ */
+export type AnsiPackComponentModules = Record<string, AnsiRegistryEntry>;
+/**
+ * Returns `value` with every string in it run through
+ * `stripControlCharacters`, so a pack that prints a stored value cannot
+ * print a control character a script smuggled in. Arrays and plain objects
+ * are copied (null-prototype for objects, hasOwn-guarded), never mutated.
+ * Anything past `MAX_SANITIZE_DEPTH`, and every non-JSON value, becomes
+ * `undefined`. Never throws: a throwing getter reads as `undefined`.
+ */
+export declare function sanitizeValueForPack(value: unknown, depth?: number): unknown;
+/** What `loadAnsiPack` reports about a pack it could not run. */
+export interface LoadAnsiPackResult {
+    registry: AnsiRegistry;
+    /** Present when the pack has components but none has an `ansi` source: the pack contributes nothing. `engine` names the engines it does declare. */
+    dropped?: {
+        name: string;
+        engine: string;
+    };
+}
+/**
+ * Loads one pack's terminal components into a namespaced `AnsiRegistry`,
+ * mirroring `@markii/react`'s `loadPack`: gating is per component (only
+ * components with an `ansi` source register; the rest fall back to the
+ * unknown-component box), a manifest component with no module is skipped,
+ * a stray module is ignored, and a declared `kind` decides the `inline`
+ * flag. Reads are `Object.hasOwn`-guarded. Never throws.
+ */
+export declare function loadAnsiPack(manifest: PackManifest, componentModules: AnsiPackComponentModules): LoadAnsiPackResult;
+/** One pack ready to install: its manifest plus its registered component modules. */
+export interface AnsiPackToInstall {
+    manifest: PackManifest;
+    componentModules: AnsiPackComponentModules;
+}
+export type InstallAnsiPacksResult = {
+    ok: true;
+    registry: AnsiRegistry;
+    dropped: {
+        name: string;
+        engine: string;
+    }[];
+} | {
+    ok: false;
+    collisions: readonly string[];
+};
+/**
+ * Installs several packs into one registry on top of `base`, rejecting the
+ * whole install when two share a namespace (the install-time rule in
+ * docs/packs.md), exactly like `@markii/react`'s `installPacks`. A host
+ * that wants keep-first behavior (a bundled pack wins over a user pack of
+ * the same namespace) filters the list before calling.
+ */
+export declare function installAnsiPacks(packs: readonly AnsiPackToInstall[], base?: AnsiRegistry): InstallAnsiPacksResult;

package/dist/pack-loader.js

@@ -0,0 +1,172 @@
+import { composeDirectiveName, detectNamespaceCollisions, packComponentsForEngine, packDeclaredEngines, packSupportsEngine, } from '@markii/pack';
+import { createAnsiRegistry, mergeAnsiRegistries } from './registry.js';
+import { stripControlCharacters } from './sanitize.js';
+/**
+ * This engine's id in a pack manifest's per-component `sources` map
+ * (docs/packs.md). A component with an `ansi` source has a terminal view.
+ */
+export const ANSI_ENGINE_ID = 'ansi';
+/** The deepest a stored value is walked when sanitizing it for a pack. */
+const MAX_SANITIZE_DEPTH = 16;
+/**
+ * Returns `value` with every string in it run through
+ * `stripControlCharacters`, so a pack that prints a stored value cannot
+ * print a control character a script smuggled in. Arrays and plain objects
+ * are copied (null-prototype for objects, hasOwn-guarded), never mutated.
+ * Anything past `MAX_SANITIZE_DEPTH`, and every non-JSON value, becomes
+ * `undefined`. Never throws: a throwing getter reads as `undefined`.
+ */
+export function sanitizeValueForPack(value, depth = 0) {
+    if (depth > MAX_SANITIZE_DEPTH)
+        return undefined;
+    if (typeof value === 'string')
+        return stripControlCharacters(value);
+    if (value === null ||
+        typeof value === 'number' ||
+        typeof value === 'boolean') {
+        return value;
+    }
+    try {
+        if (Array.isArray(value)) {
+            return value.map((item) => sanitizeValueForPack(item, depth + 1));
+        }
+        if (typeof value === 'object') {
+            const out = Object.create(null);
+            for (const key of Object.keys(value)) {
+                if (!Object.hasOwn(value, key))
+                    continue;
+                out[stripControlCharacters(key)] = sanitizeValueForPack(value[key], depth + 1);
+            }
+            return out;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+/** A copy of `attributes` with every string value (and key) stripped of control characters. A bare attribute stays `null`. */
+function sanitizeAttributes(attributes) {
+    const out = Object.create(null);
+    try {
+        for (const key of Object.keys(attributes)) {
+            if (!Object.hasOwn(attributes, key))
+                continue;
+            const raw = attributes[key];
+            out[stripControlCharacters(key)] =
+                typeof raw === 'string' ? stripControlCharacters(raw) : raw;
+        }
+    }
+    catch {
+        // A hostile attribute object yields whatever copied so far.
+    }
+    return out;
+}
+/**
+ * The ctx a pack component receives: the engine's ctx with `resolve` and
+ * `data` replaced by sanitized-copy versions. `ctx.text` stays the engine's
+ * sanitizer, the way a pack prints any other string it composes.
+ */
+function packContext(ctx) {
+    const packCtx = {
+        ...ctx,
+        resolve: (name) => {
+            const resolution = ctx.resolve(name);
+            return {
+                ...resolution,
+                value: sanitizeValueForPack(resolution.value),
+                ...(resolution.error !== undefined
+                    ? { error: stripControlCharacters(resolution.error) }
+                    : {}),
+            };
+        },
+    };
+    if ('data' in ctx)
+        packCtx.data = sanitizeValueForPack(ctx.data);
+    if (ctx.dataError !== undefined) {
+        packCtx.dataError = stripControlCharacters(ctx.dataError);
+    }
+    return packCtx;
+}
+/**
+ * Wraps a pack's component so the engine, not the pack, decides what text
+ * reaches it. The wrapper sanitizes the attributes and the stored-value
+ * view of the ctx before calling the pack, and a throw inside the pack's
+ * render is contained by the walk's existing per-component boundary.
+ *
+ * This bounds what AUTHOR text can do through a pack. It cannot bound the
+ * pack's own code: a terminal pack runs in the host's process with the
+ * host's privileges and can write to stdout itself (docs/security.md).
+ */
+function wrapPackComponent(component) {
+    // Called as a plain function, like every registry component: it returns
+    // a string or an Ink element (the engine lays the element out at the
+    // directive's width). Components the pack's view renders INSIDE that
+    // element are ordinary React components and may use hooks.
+    return function PackComponent(props) {
+        return component({
+            attributes: sanitizeAttributes(props.attributes),
+            children: props.children,
+            ctx: packContext(props.ctx),
+        });
+    };
+}
+/**
+ * Loads one pack's terminal components into a namespaced `AnsiRegistry`,
+ * mirroring `@markii/react`'s `loadPack`: gating is per component (only
+ * components with an `ansi` source register; the rest fall back to the
+ * unknown-component box), a manifest component with no module is skipped,
+ * a stray module is ignored, and a declared `kind` decides the `inline`
+ * flag. Reads are `Object.hasOwn`-guarded. Never throws.
+ */
+export function loadAnsiPack(manifest, componentModules) {
+    if (!packSupportsEngine(manifest, ANSI_ENGINE_ID)) {
+        return {
+            registry: createAnsiRegistry(),
+            dropped: { name: manifest.name, engine: packDeclaredEngines(manifest) },
+        };
+    }
+    const entries = {};
+    for (const { localName, kind } of packComponentsForEngine(manifest, ANSI_ENGINE_ID)) {
+        if (!Object.hasOwn(componentModules, localName))
+            continue;
+        const module = componentModules[localName];
+        if (module == null || typeof module.component !== 'function')
+            continue;
+        const composed = composeDirectiveName(manifest.name, localName);
+        if (!composed.ok)
+            continue;
+        const entry = {
+            component: wrapPackComponent(module.component),
+        };
+        const inline = kind === undefined ? module.inline : kind === 'inline';
+        if (inline !== undefined)
+            entry.inline = inline;
+        entries[composed.name] = entry;
+    }
+    return { registry: createAnsiRegistry(entries) };
+}
+/**
+ * Installs several packs into one registry on top of `base`, rejecting the
+ * whole install when two share a namespace (the install-time rule in
+ * docs/packs.md), exactly like `@markii/react`'s `installPacks`. A host
+ * that wants keep-first behavior (a bundled pack wins over a user pack of
+ * the same namespace) filters the list before calling.
+ */
+export function installAnsiPacks(packs, base = createAnsiRegistry()) {
+    const collisions = detectNamespaceCollisions(packs.map((pack) => pack.manifest.name));
+    if (collisions.length > 0) {
+        return {
+            ok: false,
+            collisions: collisions.map((collision) => collision.namespace),
+        };
+    }
+    const dropped = [];
+    const loaded = packs.map((pack) => {
+        const result = loadAnsiPack(pack.manifest, pack.componentModules);
+        if (result.dropped)
+            dropped.push(result.dropped);
+        return result.registry;
+    });
+    return { ok: true, registry: mergeAnsiRegistries(base, ...loaded), dropped };
+}

package/dist/pack-script.d.ts

@@ -0,0 +1,44 @@
+import type { AnsiPackToInstall } from './pack-loader.js';
+/**
+ * The terminal pack registration contract (docs/packs.md). A pack's
+ * prebuilt `terminal.js` is an ESM module. On evaluation it calls
+ *
+ *   globalThis.__markiiRegisterTerminalPack(manifestJson, componentModules)
+ *
+ * with the raw `pack.json` text and an own-property map of
+ * `{ component, inline? }` keyed by local component name, the same shape
+ * `__markiiRegisterPack` takes for the webview. React and Ink are NOT
+ * bundled into the script. The host sets `globalThis.__markiiReactInk`
+ * (the React instance Ink uses) and `globalThis.__markiiInk` (Ink's
+ * exports) and a pack reads them only inside render-time functions, so
+ * evaluating the script with both undefined must not throw.
+ *
+ * SECURITY: evaluating this script runs the pack's code in the calling
+ * process with that process's full privileges. Only a host's own device-
+ * local install store and bundled packs may reach `loadTerminalPackScript`:
+ * never a note, a bundle, the working directory, or an environment
+ * variable (docs/security.md).
+ */
+export declare const TERMINAL_REGISTER_GLOBAL = "__markiiRegisterTerminalPack";
+export declare const TERMINAL_REACT_GLOBAL = "__markiiReactInk";
+export declare const TERMINAL_INK_GLOBAL = "__markiiInk";
+/**
+ * Publishes this package's own React and Ink instances for pack scripts to
+ * read at render time. Idempotent. Left in place for the life of the
+ * process, since a pack reads them each time its component renders.
+ */
+export declare function installTerminalPackGlobals(): void;
+export type LoadTerminalPackScriptResult = {
+    ok: true;
+    pack: AnsiPackToInstall;
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * Evaluates one pack's `terminal.js` text and returns the validated pack
+ * ready for `installAnsiPacks`, or the reason it could not be used. Never
+ * rejects. SECURITY: runs the script's code in this process; see the
+ * module comment for who may call it.
+ */
+export declare function loadTerminalPackScript(scriptText: string): Promise<LoadTerminalPackScriptResult>;

package/dist/pack-script.js

@@ -0,0 +1,135 @@
+import * as React from 'react';
+import * as Ink from 'ink';
+import { parsePackManifest } from '@markii/pack';
+/**
+ * The terminal pack registration contract (docs/packs.md). A pack's
+ * prebuilt `terminal.js` is an ESM module. On evaluation it calls
+ *
+ *   globalThis.__markiiRegisterTerminalPack(manifestJson, componentModules)
+ *
+ * with the raw `pack.json` text and an own-property map of
+ * `{ component, inline? }` keyed by local component name, the same shape
+ * `__markiiRegisterPack` takes for the webview. React and Ink are NOT
+ * bundled into the script. The host sets `globalThis.__markiiReactInk`
+ * (the React instance Ink uses) and `globalThis.__markiiInk` (Ink's
+ * exports) and a pack reads them only inside render-time functions, so
+ * evaluating the script with both undefined must not throw.
+ *
+ * SECURITY: evaluating this script runs the pack's code in the calling
+ * process with that process's full privileges. Only a host's own device-
+ * local install store and bundled packs may reach `loadTerminalPackScript`:
+ * never a note, a bundle, the working directory, or an environment
+ * variable (docs/security.md).
+ */
+export const TERMINAL_REGISTER_GLOBAL = '__markiiRegisterTerminalPack';
+export const TERMINAL_REACT_GLOBAL = '__markiiReactInk';
+export const TERMINAL_INK_GLOBAL = '__markiiInk';
+/**
+ * Publishes this package's own React and Ink instances for pack scripts to
+ * read at render time. Idempotent. Left in place for the life of the
+ * process, since a pack reads them each time its component renders.
+ */
+export function installTerminalPackGlobals() {
+    const g = globalThis;
+    g[TERMINAL_REACT_GLOBAL] = React;
+    g[TERMINAL_INK_GLOBAL] = Ink;
+}
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+/** Own-property validation of the registered map, same rule as the webview convention. */
+function toComponentModules(value) {
+    if (!isPlainObject(value))
+        return undefined;
+    const out = Object.create(null);
+    for (const key of Object.keys(value)) {
+        if (!Object.hasOwn(value, key))
+            continue;
+        const entry = value[key];
+        if (!isPlainObject(entry) || typeof entry.component !== 'function') {
+            return undefined;
+        }
+        if (Object.hasOwn(entry, 'inline') && typeof entry.inline !== 'boolean') {
+            return undefined;
+        }
+        out[key] = {
+            component: entry.component,
+            ...(typeof entry.inline === 'boolean' ? { inline: entry.inline } : {}),
+        };
+    }
+    return out;
+}
+// Evaluations are serialized: the register hook is one process global.
+let queue = Promise.resolve();
+let nonce = 0;
+async function evaluate(scriptText) {
+    installTerminalPackGlobals();
+    const g = globalThis;
+    const previous = g[TERMINAL_REGISTER_GLOBAL];
+    const registrations = [];
+    g[TERMINAL_REGISTER_GLOBAL] = (manifestJson, modules) => {
+        registrations.push({ manifestJson, modules });
+    };
+    try {
+        nonce += 1;
+        const source = `${scriptText}\n//# markiiTerminalPack=${String(nonce)}`;
+        const url = `data:text/javascript;base64,${Buffer.from(source, 'utf8').toString('base64')}`;
+        try {
+            await import(/* @vite-ignore */ url);
+        }
+        catch (error) {
+            const detail = error instanceof Error ? error.message : String(error);
+            return {
+                ok: false,
+                reason: `terminal.js threw while loading: ${detail}`,
+            };
+        }
+    }
+    finally {
+        if (previous === undefined)
+            delete g[TERMINAL_REGISTER_GLOBAL];
+        else
+            g[TERMINAL_REGISTER_GLOBAL] = previous;
+    }
+    if (registrations.length !== 1) {
+        return {
+            ok: false,
+            reason: registrations.length === 0
+                ? `terminal.js did not call ${TERMINAL_REGISTER_GLOBAL}`
+                : `terminal.js called ${TERMINAL_REGISTER_GLOBAL} ${String(registrations.length)} times; exactly one registration is allowed`,
+        };
+    }
+    const { manifestJson, modules } = registrations[0];
+    if (typeof manifestJson !== 'string') {
+        return {
+            ok: false,
+            reason: 'terminal.js did not provide a manifest JSON string',
+        };
+    }
+    const parsed = parsePackManifest(manifestJson);
+    if (!parsed.ok) {
+        return {
+            ok: false,
+            reason: `terminal.js manifest is invalid (${parsed.errors.join('; ')})`,
+        };
+    }
+    const componentModules = toComponentModules(modules);
+    if (componentModules === undefined) {
+        return { ok: false, reason: 'terminal.js registered malformed components' };
+    }
+    return { ok: true, pack: { manifest: parsed.manifest, componentModules } };
+}
+/**
+ * Evaluates one pack's `terminal.js` text and returns the validated pack
+ * ready for `installAnsiPacks`, or the reason it could not be used. Never
+ * rejects. SECURITY: runs the script's code in this process; see the
+ * module comment for who may call it.
+ */
+export function loadTerminalPackScript(scriptText) {
+    const run = queue.then(() => evaluate(scriptText));
+    queue = run.catch(() => undefined);
+    return run.catch((error) => ({
+        ok: false,
+        reason: `terminal.js could not be evaluated: ${error instanceof Error ? error.message : String(error)}`,
+    }));
+}