aiden-runtime 4.0.2 → 4.1.1

package/dist/cli/v4/pasteCompression.js

@@ -0,0 +1,124 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/pasteCompression.ts — Tier-3.1 (v4.1-tier3.1)
+ *
+ * When a user pastes a large block (>5 lines OR >500 chars), the
+ * REPL replaces the visible echo with a compact label
+ *   `[paste #<id>: <N> lines, <KB>]`
+ * and stores the original at `<aidenRoot>/pastes/paste_<id>.txt`.
+ * The agent receives the original text as input — only the visible
+ * echo is compressed, so the LLM still sees full content.
+ *
+ * The id counter is persisted in `<aidenRoot>/pastes/manifest.json`
+ * so it increments across sessions. Concurrent writes from the same
+ * process are serialised through an in-process latch; cross-process
+ * concurrency is best-effort (the manifest is read+rewritten atomic-
+ * ally enough for a single-user CLI).
+ *
+ * `expandPaste(id)` reads the original back from disk, used by the
+ * `/show <id>` slash command.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PASTE_COMPRESS_CHARS = exports.PASTE_COMPRESS_LINES = void 0;
+exports.compressPaste = compressPaste;
+exports.expandPaste = expandPaste;
+exports._resetLatchForTests = _resetLatchForTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../../core/v4/paths");
+/** Heuristic threshold — copy-paste a code block of >5 lines or >500
+ *  chars and we compress; smaller pastes echo verbatim. */
+exports.PASTE_COMPRESS_LINES = 5;
+exports.PASTE_COMPRESS_CHARS = 500;
+/** Per-process write latch so concurrent compresses don't race the
+ *  manifest. Cross-process safety is non-goal for the single-user CLI. */
+let writeLatch = Promise.resolve();
+function pastesDir() {
+    const paths = (0, paths_1.resolveAidenPaths)();
+    return node_path_1.default.join(paths.root, 'pastes');
+}
+function manifestPath() {
+    return node_path_1.default.join(pastesDir(), 'manifest.json');
+}
+async function readNextId() {
+    try {
+        const raw = await node_fs_1.promises.readFile(manifestPath(), 'utf8');
+        const j = JSON.parse(raw);
+        if (typeof j.nextId === 'number' && j.nextId >= 1)
+            return j.nextId;
+    }
+    catch {
+        // missing or malformed — start at 1
+    }
+    return 1;
+}
+async function writeNextId(next) {
+    const dir = pastesDir();
+    await node_fs_1.promises.mkdir(dir, { recursive: true });
+    await node_fs_1.promises.writeFile(manifestPath(), JSON.stringify({ nextId: next }, null, 2), 'utf8');
+}
+function formatBytes(text) {
+    const bytes = Buffer.byteLength(text, 'utf8');
+    if (bytes < 1024)
+        return `${bytes}B`;
+    return `${(bytes / 1024).toFixed(1)}KB`;
+}
+/**
+ * Decide whether `text` should be compressed and (if so) persist the
+ * original. Always returns the original text for the agent path; only
+ * the echo path consults `compressed`/`label`.
+ */
+async function compressPaste(text) {
+    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+    const big = lineCount > exports.PASTE_COMPRESS_LINES || text.length > exports.PASTE_COMPRESS_CHARS;
+    if (!big) {
+        return { compressed: false, original: text };
+    }
+    // Atomic ID allocation under in-process latch.
+    let id = '';
+    let label = '';
+    await (writeLatch = writeLatch.then(async () => {
+        const next = await readNextId();
+        id = String(next);
+        const dir = pastesDir();
+        await node_fs_1.promises.mkdir(dir, { recursive: true });
+        await node_fs_1.promises.writeFile(node_path_1.default.join(dir, `paste_${id}.txt`), text, 'utf8');
+        await writeNextId(next + 1);
+        label = `[paste #${id}: ${lineCount} lines, ${formatBytes(text)}]`;
+    }));
+    return { compressed: true, id, label, original: text };
+}
+/**
+ * Read back a previously stored paste by id. Returns `null` if the
+ * id is unknown or the file vanished.
+ */
+async function expandPaste(id) {
+    // Defence-in-depth: only allow numeric ids — keeps the path-join
+    // from straying outside the pastes directory if someone ever
+    // wires an untrusted argument here.
+    if (!/^\d+$/.test(id))
+        return null;
+    try {
+        const file = node_path_1.default.join(pastesDir(), `paste_${id}.txt`);
+        return await node_fs_1.promises.readFile(file, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Test/reset hook: drop the in-process latch so a fresh test run
+ * starts with a clean serialiser. Disk state untouched.
+ */
+function _resetLatchForTests() {
+    writeLatch = Promise.resolve();
+}

package/dist/cli/v4/pasteIntercept.js

@@ -0,0 +1,203 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/pasteIntercept.ts — Tier-3.1a (v4.1-tier3.1a)
+ *
+ * Stdin pre-tap that handles bracketed paste sequences before
+ * @inquirer/prompts sees them. Modern inquirer treats any internal
+ * `\n` as Enter and resolves early, so a multi-line paste auto-
+ * submits before the user has a chance to review. This module
+ * intercepts paste boundaries (CSI 2004), captures the content,
+ * persists it via the existing pasteCompression manifest, and
+ * substitutes a `[paste #<id>: <N> lines, <KB>]` label on stdin.
+ *
+ * The user sees the label in inquirer's input buffer, presses Enter
+ * to submit, and chatSession.readUserInput swaps the label for the
+ * original via getPasteOriginal(id) before handing to the agent.
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPasteOriginal = getPasteOriginal;
+exports.expandPasteLabels = expandPasteLabels;
+exports.installPasteInterceptor = installPasteInterceptor;
+exports._resetForTests = _resetForTests;
+const node_fs_1 = require("node:fs");
+const node_path_1 = __importDefault(require("node:path"));
+const paths_1 = require("../../core/v4/paths");
+const PASTE_BEGIN = '\x1b[200~';
+const PASTE_END = '\x1b[201~';
+/** id → original text (in-memory swap table). */
+const originals = new Map();
+function pastesDir() {
+    return node_path_1.default.join((0, paths_1.resolveAidenPaths)().root, 'pastes');
+}
+function manifestPath() {
+    return node_path_1.default.join(pastesDir(), 'manifest.json');
+}
+function readNextIdSync() {
+    try {
+        const raw = (0, node_fs_1.readFileSync)(manifestPath(), 'utf8');
+        const j = JSON.parse(raw);
+        if (typeof j.nextId === 'number' && j.nextId >= 1)
+            return j.nextId;
+    }
+    catch { /* missing or malformed */ }
+    return 1;
+}
+function writeNextIdSync(next) {
+    const dir = pastesDir();
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    (0, node_fs_1.writeFileSync)(manifestPath(), JSON.stringify({ nextId: next }, null, 2), 'utf8');
+}
+function formatBytes(text) {
+    const bytes = Buffer.byteLength(text, 'utf8');
+    return bytes < 1024 ? `${bytes}B` : `${(bytes / 1024).toFixed(1)}KB`;
+}
+function compressSync(text) {
+    const dir = pastesDir();
+    if (!(0, node_fs_1.existsSync)(dir))
+        (0, node_fs_1.mkdirSync)(dir, { recursive: true });
+    const next = readNextIdSync();
+    const id = String(next);
+    (0, node_fs_1.writeFileSync)(node_path_1.default.join(dir, `paste_${id}.txt`), text, 'utf8');
+    writeNextIdSync(next + 1);
+    const lineCount = (text.match(/\n/g)?.length ?? 0) + 1;
+    return { id, label: `[paste #${id}: ${lineCount} lines, ${formatBytes(text)}]` };
+}
+/**
+ * Look up the original text for a paste id. Returns undefined if the
+ * id was never seen by this process (e.g. the user typed a label by
+ * hand). Disk is the source of truth for /show <id>; this map is the
+ * fast path for the in-flight prompt swap.
+ */
+function getPasteOriginal(id) {
+    return originals.get(id);
+}
+/**
+ * Replace `[paste #N: …]` patterns in `input` with the corresponding
+ * original text from the in-process map. Patterns whose id we don't
+ * know are left intact (might be user-typed). Returns the swapped
+ * string.
+ */
+function expandPasteLabels(input) {
+    return input.replace(/\[paste #(\d+):[^\]]*\]/g, (m, id) => {
+        const orig = originals.get(id);
+        return orig !== undefined ? orig : m;
+    });
+}
+let installed = null;
+/**
+ * Install the stdin pre-tap. Wraps `process.stdin.emit('data', …)`
+ * so paste payloads are captured + replaced with labels before any
+ * downstream listener (inquirer) sees them. Idempotent. Returns an
+ * uninstall function.
+ *
+ * MCP serve mode: never call this — `aiden mcp serve` doesn't run
+ * the REPL.
+ */
+function installPasteInterceptor(stdin) {
+    if (installed)
+        return installed.restore;
+    const origEmit = stdin.emit.bind(stdin);
+    const state = { inPaste: false, buf: '' };
+    function processChunk(text) {
+        let out = '';
+        let cursor = 0;
+        while (cursor < text.length) {
+            if (state.inPaste) {
+                const endIdx = text.indexOf(PASTE_END, cursor);
+                if (endIdx === -1) {
+                    state.buf += text.slice(cursor);
+                    cursor = text.length;
+                }
+                else {
+                    state.buf += text.slice(cursor, endIdx);
+                    cursor = endIdx + PASTE_END.length;
+                    // Tier-3.1c: terminals (and some clipboard payloads) emit a
+                    // trailing CR/LF immediately after PASTE_END. Without this
+                    // swallow the bytes pass through to readline, where they
+                    // become an Enter event and auto-submit the prompt before
+                    // the user has reviewed the paste. Eat at most one CR + one
+                    // LF (in either order) right after PASTE_END.
+                    if (text[cursor] === '\r')
+                        cursor += 1;
+                    if (text[cursor] === '\n')
+                        cursor += 1;
+                    state.inPaste = false;
+                    const original = state.buf.replace(/\r\n/g, '\n');
+                    state.buf = '';
+                    // Strip a single trailing newline (Enter at end of paste).
+                    const trimmed = original.replace(/\n+$/, '');
+                    if (!trimmed.includes('\n') && trimmed.length <= 500) {
+                        // Single-line, small — emit as-is so user can edit.
+                        out += trimmed;
+                    }
+                    else {
+                        // Multi-line or large — disk-back + emit label.
+                        try {
+                            const { id, label } = compressSync(trimmed);
+                            originals.set(id, trimmed);
+                            out += label;
+                        }
+                        catch {
+                            // Disk failure: fall back to a single-space substitute
+                            // so internal newlines don't trigger auto-submit.
+                            out += trimmed.replace(/\n/g, ' ');
+                        }
+                    }
+                }
+            }
+            else {
+                const beginIdx = text.indexOf(PASTE_BEGIN, cursor);
+                if (beginIdx === -1) {
+                    out += text.slice(cursor);
+                    cursor = text.length;
+                }
+                else {
+                    out += text.slice(cursor, beginIdx);
+                    cursor = beginIdx + PASTE_BEGIN.length;
+                    state.inPaste = true;
+                }
+            }
+        }
+        return out;
+    }
+    const wrappedEmit = function (event, ...args) {
+        if (event !== 'data')
+            return origEmit(event, ...args);
+        const chunk = args[0];
+        if (chunk == null)
+            return origEmit(event, ...args);
+        const text = Buffer.isBuffer(chunk)
+            ? chunk.toString('utf8')
+            : (typeof chunk === 'string' ? chunk : String(chunk));
+        const processed = processChunk(text);
+        if (processed.length === 0)
+            return true; // suppress entirely
+        const nextArgs = [Buffer.from(processed, 'utf8'), ...args.slice(1)];
+        return origEmit(event, ...nextArgs);
+    };
+    stdin.emit = wrappedEmit;
+    const restore = () => {
+        if (!installed)
+            return;
+        stdin.emit = origEmit;
+        installed = null;
+    };
+    installed = { restore };
+    return restore;
+}
+/** Test helper: clear the in-memory map (does not touch disk). */
+function _resetForTests() {
+    originals.clear();
+    if (installed)
+        installed.restore();
+}

package/dist/cli/v4/replyRenderer.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod). Licensed under AGPL-3.0.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/replyRenderer.ts — Phase v4.1-reply-formatting
+ *
+ * Configures marked-terminal with skin-aware renderers so Aiden's
+ * agent replies render as structured markdown instead of raw walls
+ * of text. Headers, lists, code blocks, blockquotes, inline emphasis,
+ * and links all get terminal-friendly painting.
+ *
+ * The renderer is an instance — `getReplyRenderer().render(text)`
+ * returns the painted string. Used by:
+ *   - `display.markdown(text)` (non-streaming agent reply)
+ *   - `display.streamComplete()` (post-stream re-render, optional)
+ *   - the citation footer composer
+ *
+ * Stable-prefix split for streaming lives in `streamingPrefix.ts`
+ * (pure function over the buffered text); this module is only the
+ * static renderer.
+ *
+ * NO_COLOR honour: the skin engine already returns plain text when
+ * `NO_COLOR` is set, so every paint call gracefully degrades.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getReplyRenderer = getReplyRenderer;
+exports._resetForTests = _resetForTests;
+const marked_1 = require("marked");
+const skinEngine_1 = require("./skinEngine");
+const syntaxHighlight_1 = require("./syntaxHighlight");
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const TerminalRenderer = require('marked-terminal').default ?? require('marked-terminal');
+function paint(kind) {
+    return (text) => (0, skinEngine_1.getSkinEngine)().applyColors(text, kind);
+}
+/**
+ * Render a fenced code block: top divider with language label, body
+ * with optional syntax highlighting, bottom divider.
+ *
+ *     ── typescript ─────────────
+ *       const x = 1;
+ *     ──────────────────────────
+ *
+ * Used by the prototype-override path below — marked-terminal's
+ * internal `Renderer.prototype.code` ignores user `opts.code` and
+ * runs its own highlighter, so we override the prototype method
+ * directly. The token-object signature is what marked v15 calls
+ * the renderer with; the older positional path is kept for
+ * compatibility.
+ */
+function renderCodeBlock(code, lang) {
+    const sk = (0, skinEngine_1.getSkinEngine)();
+    const width = Math.min(process.stdout.columns ?? 80, 100) - 4;
+    const langLabel = (lang ?? '').trim();
+    const top = langLabel
+        ? `── ${langLabel} ${'─'.repeat(Math.max(0, width - langLabel.length - 4))}`
+        : '─'.repeat(width);
+    const bot = '─'.repeat(width);
+    const body = (0, syntaxHighlight_1.isSupportedLang)(langLabel)
+        ? (0, syntaxHighlight_1.highlightCode)(code, langLabel)
+        : code;
+    const indented = body.split('\n').map((ln) => `  ${ln}`).join('\n');
+    return [
+        sk.applyColors(top, 'muted'),
+        indented,
+        sk.applyColors(bot, 'muted'),
+        '',
+    ].join('\n') + '\n';
+}
+/**
+ * Render a block quote with a `┃` left rail in muted colour.
+ * Multi-line quotes get the rail on every line.
+ */
+function renderBlockquote(quote) {
+    const rail = paint('muted')('┃ ');
+    return quote
+        .split('\n')
+        .map((ln) => (ln.length === 0 ? rail.trimEnd() : `${rail}${ln}`))
+        .join('\n') + '\n';
+}
+/**
+ * Marked-terminal heading callback gets the rendered heading text +
+ * level. We paint h1 in brand-bold, h2 in brand, h3+ in heading.
+ */
+function renderHeading(text, level, _raw) {
+    if (level <= 1)
+        return paint('brand')(text.toUpperCase()) + '\n\n';
+    if (level === 2)
+        return paint('brand')(text) + '\n\n';
+    return paint('heading')(text) + '\n\n';
+}
+/**
+ * List items get a `▸ ` glyph in muted; numbered lists keep their
+ * numeric prefix (marked-terminal already prepends `N.` for ordered
+ * lists, so we just paint the body).
+ */
+function renderListItem(text) {
+    // marked-terminal feeds us the rendered child text. Strip its
+    // default tab prefix so our two-space indent stays consistent.
+    const body = text.replace(/^\s+/, '');
+    return `  ${paint('muted')('▸')} ${body}\n`;
+}
+/**
+ * Singleton — caching is fine since options bind to the active skin
+ * via paint callbacks (which read getSkinEngine() each call).
+ */
+let cachedRenderer = null;
+function getReplyRenderer() {
+    if (cachedRenderer)
+        return cachedRenderer;
+    // marked-terminal's `opts.<X>` callbacks are invoked with ALREADY-
+    // assembled strings, not raw token data — they're meant for ANSI
+    // wrapping, not structural override. So `opts.code` for example is
+    // never actually called for fenced blocks: marked-terminal's
+    // prototype.code runs its own internal highlighter and skips opts.
+    // To emit our structured code blocks (top divider + lang label +
+    // syntax highlight + bottom divider) we override the prototype
+    // method directly below.
+    const opts = {
+        blockquote: renderBlockquote,
+        heading: renderHeading,
+        firstHeading: (text, _level, _raw) => paint('brand')(text.toUpperCase()) + '\n\n',
+        hr: () => paint('muted')('─'.repeat(Math.min(process.stdout.columns ?? 80, 100) - 4)) + '\n',
+        listitem: renderListItem,
+        paragraph: (text) => `${text}\n\n`,
+        strong: paint('brand'),
+        em: paint('muted'),
+        codespan: (text) => paint('accent')(`\`${text}\``),
+        del: paint('muted'),
+        // marked-terminal calls opts.link with the ASSEMBLED visual
+        // (already OSC8-wrapped when the host terminal supports it),
+        // so we just paint it.
+        link: (assembled) => paint('accent')(assembled),
+        href: paint('accent'),
+        text: (text) => text,
+        width: Math.min(process.stdout.columns ?? 80, 100),
+        showSectionPrefix: false,
+        reflowText: false,
+        tab: 2,
+    };
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const renderer = new TerminalRenderer(opts);
+    // Override the prototype `code` method on this instance so we get
+    // structured code blocks (divider + lang label + syntax highlight
+    // + divider) instead of marked-terminal's plain yellow-highlighted
+    // output. Token-object signature handles marked v15.
+    renderer.code = function (code, lang, _escaped) {
+        let text;
+        let langOut;
+        if (typeof code === 'object' && code !== null) {
+            // marked v15 passes a token object: { text, lang, escaped }.
+            const tok = code;
+            text = tok.text ?? '';
+            langOut = tok.lang;
+        }
+        else {
+            text = String(code ?? '');
+            langOut = lang;
+        }
+        return renderCodeBlock(text, langOut);
+    };
+    // Override `link` to ALWAYS emit OSC8 hyperlinks (marked-terminal's
+    // default uses `supports-hyperlinks` which returns false on piped
+    // stdout — but Aiden's REPL targets modern terminals that support
+    // OSC8 universally). Visible label gets accent paint; href is the
+    // OSC8 target. Token-object signature handles marked v15.
+    renderer.link = function (href, _title, text) {
+        let url;
+        let label;
+        if (typeof href === 'object' && href !== null) {
+            const tok = href;
+            url = tok.href ?? '';
+            label = this
+                .parser?.parseInline?.(tok.tokens ?? []) ?? '';
+        }
+        else {
+            url = String(href ?? '');
+            label = String(text ?? url);
+        }
+        if (!label)
+            label = url;
+        const painted = paint('accent')(label);
+        return `\x1b]8;;${url}\x1b\\${painted}\x1b]8;;\x1b\\`;
+    };
+    cachedRenderer = {
+        render(text) {
+            try {
+                // Bind the renderer globally before each parse — marked v15
+                // applies the renderer at parse time, so re-setting before
+                // each call is safe and ensures our custom options win even
+                // if other code transiently swaps the renderer.
+                marked_1.marked.setOptions({ renderer: renderer });
+                const out = marked_1.marked.parse(text);
+                return typeof out === 'string' ? out : String(out);
+            }
+            catch {
+                return text;
+            }
+        },
+    };
+    return cachedRenderer;
+}
+/** Test reset — drops the cached renderer so a skin change picks up. */
+function _resetForTests() {
+    cachedRenderer = null;
+}

package/dist/cli/v4/resizeGuard.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Copyright (c) 2026 Shiva Deore (Taracod).
+ * Licensed under AGPL-3.0. See LICENSE for details.
+ *
+ * Aiden — local-first agent.
+ */
+/**
+ * cli/v4/resizeGuard.ts — Phase v4.1-tier3-essentials
+ *
+ * Hard-clear the terminal on `process.stdout` resize so dropdown
+ * re-renders, prompt frames, and dirty escape state from before the
+ * resize don't ghost into the new viewport.
+ *
+ * The clear is a single `\x1b[2J\x1b[H` (erase display + cursor home);
+ * every mainstream emulator honours it. A virtualised transcript could
+ * do this more surgically via React state, but we don't have one yet,
+ * so the brute-force clear is the right minimum for v4.1.
+ *
+ * Skipped in non-TTY (`process.stdout.isTTY` falsy) and in MCP serve
+ * mode (`isMcpServeMode()` true). 100ms debounce so a continuous
+ * resize drag doesn't issue dozens of clears.
+ *
+ * `installResizeGuard()` returns a teardown function. Idempotent.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HARD_CLEAR_SEQUENCE = void 0;
+exports.installResizeGuard = installResizeGuard;
+exports._resetForTests = _resetForTests;
+const uiBuild_1 = require("./uiBuild");
+/** Single ANSI sequence: `ED 2` (erase display) + `CUP` (cursor home). */
+const HARD_CLEAR = '\x1b[2J\x1b[H';
+const DEFAULT_DEBOUNCE_MS = 100;
+let installed = null;
+/**
+ * Install a 'resize' listener on `process.stdout`. No-op when stdout
+ * is non-TTY or MCP serve mode is active. Idempotent — calling twice
+ * returns the same teardown.
+ */
+function installResizeGuard(opts = {}) {
+    if (installed)
+        return installed.uninstall;
+    const out = opts.out ?? process.stdout;
+    if (!out || !out.isTTY) {
+        const noop = () => { };
+        installed = { uninstall: noop };
+        return noop;
+    }
+    if ((0, uiBuild_1.isMcpServeMode)()) {
+        const noop = () => { };
+        installed = { uninstall: noop };
+        return noop;
+    }
+    const debounceMs = opts.debounceMs ?? DEFAULT_DEBOUNCE_MS;
+    let pending = null;
+    const onResize = () => {
+        if (pending)
+            clearTimeout(pending);
+        pending = setTimeout(() => {
+            pending = null;
+            try {
+                out.write(HARD_CLEAR);
+            }
+            catch { /* defensive */ }
+            try {
+                opts.onCleared?.();
+            }
+            catch { /* re-render must not crash the listener */ }
+        }, debounceMs);
+    };
+    out.on('resize', onResize);
+    const uninstall = () => {
+        if (!installed)
+            return;
+        out.removeListener('resize', onResize);
+        if (pending) {
+            clearTimeout(pending);
+            pending = null;
+        }
+        installed = null;
+    };
+    installed = { uninstall };
+    return uninstall;
+}
+/** Test helper: drop install state. */
+function _resetForTests() {
+    if (installed)
+        installed.uninstall();
+    installed = null;
+}
+/** Constant exposed for smokes — they assert we emit this exact bytes. */
+exports.HARD_CLEAR_SEQUENCE = HARD_CLEAR;