@askdkc/dsh-cli 0.11.3

package/lib/types/ink/update-overflow-guard.js

@@ -0,0 +1,164 @@
+/**
+ * Self-healing guard for React's nested-update overflow — Minified React
+ * error #185 ("Maximum update depth exceeded").
+ *
+ * WHY THIS EXISTS — the crash is a ratchet, not a single bad component.
+ * react-reconciler counts consecutive commits that each end with more
+ * pending Sync/InputContinuous/Default-lane updates on the same root
+ * (`nestedUpdateCount`); once 50 commits pass without one that drains the
+ * queue, the NEXT update enqueue throws #185 — from whichever timer or
+ * store notification happens to fire first, which is why the stack points
+ * at an innocent animation tick while the actual oscillating component is
+ * someone else entirely (the upstream fork lineage hit this repeatedly:
+ * Divider measure loops, MessageList streaming measure cascades, and the
+ * repeated layout measurements during streaming).
+ *
+ * The throw is SELF-HEALING BY CONTRACT: `getRootForUpdatedFiber` resets
+ * `nestedUpdateCount` to 0 and clears `rootWithNestedUpdates` *before*
+ * throwing, so swallowing exactly this error class skips at most one frame
+ * of animation while the next commit starts from a clean counter. That
+ * turns a process-killing crash into a dropped tick plus a rate-limited
+ * diagnostic breadcrumb naming the enqueue site that surfaced it.
+ *
+ * This guard deliberately does NOT swallow anything else: unknown errors
+ * rethrow unchanged.
+ */
+import { logError } from '../utils/log.js';
+/** Message fragments that identify the nested-update overflow error. */
+const OVERFLOW_MARKERS = ['Minified React error #185', 'Maximum update depth'];
+/** Window for log rate limiting (ms): first hit logs, the rest just count. */
+const LOG_WINDOW_MS = 10_000;
+/** Circuit breaker: same source tripping this many times inside one log
+ * window is a SUSTAINED oscillation, not a one-off — absorbing alone would
+ * leave the process alive but burning CPU on the oscillation's own commit
+ * storm. Trip the source's quench (pause its timer) so "alive" cannot
+ * degrade into "alive but very laggy". */
+const TRIP_THRESHOLD = 5;
+/** First quench duration (ms); doubles per consecutive trip, capped. */
+const TRIP_BACKOFF_BASE_MS = 5_000;
+const TRIP_BACKOFF_MAX_MS = 60_000;
+const quenches = new Map();
+const sources = new Map();
+/** Test seam: reset rate-limit bookkeeping. */
+export function resetUpdateOverflowGuardForTest() {
+    sources.clear();
+}
+/**
+ * Register a circuit-breaker action for a source. When the source trips
+ * (sustained oscillation), the quench pauses its notification channel for
+ * the backoff window — the strongest self-healing the guard can do without
+ * killing the process. Sources without a quench (data channels that must
+ * not stall) only get the escalated ERROR log.
+ */
+export function registerOverflowQuench(source, quench) {
+    quenches.set(source, quench);
+}
+/**
+ * Whether an error is the nested-update overflow (#185) — by message, the
+ * only signal the production build exposes.
+ */
+export function isNestedUpdateOverflow(error) {
+    if (!(error instanceof Error))
+        return false;
+    return OVERFLOW_MARKERS.some(marker => error.message.includes(marker));
+}
+/**
+ * Swallow the nested-update overflow error, logging (rate-limited, with a
+ * running count per window) which enqueue site surfaced it. Any other error
+ * returns false so callers rethrow it untouched.
+ *
+ * @param error - The caught error from a subscriber/enqueue notification.
+ * @param source - Stable label naming the enqueue site (for the log line).
+ * @returns true when the error was the overflow and has been absorbed.
+ */
+export function swallowNestedUpdateOverflow(error, source) {
+    if (!isNestedUpdateOverflow(error))
+        return false;
+    const now = Date.now();
+    let state = sources.get(source);
+    if (state === undefined || now - state.windowStart >= LOG_WINDOW_MS) {
+        state = { windowStart: now, logged: false, count: 0, trips: state?.trips ?? 0, quenchUntil: state?.quenchUntil ?? 0 };
+        sources.set(source, state);
+    }
+    state.count += 1;
+    if (!state.logged) {
+        state.logged = true;
+        logError(new Error(`Recovered from React nested-update overflow (#185) at ${source} — ` +
+            `dropped 1 update, counter reset by React. If this repeats, a ` +
+            `component is oscillating state updates in a tight commit chain.`));
+    }
+    // Circuit breaker: a SUSTAINED oscillation keeps re-filling React's
+    // counter between absorptions. Swallowing alone would keep the process
+    // alive while the oscillation's commit storm burns the CPU ("alive but
+    // laggy"). Trip the quench instead: pause the source's channel for an
+    // escalating window, freezing at most an animation, never data.
+    if (state.count >= TRIP_THRESHOLD && now >= state.quenchUntil) {
+        state.trips += 1;
+        const ms = Math.min(TRIP_BACKOFF_BASE_MS * 2 ** (state.trips - 1), TRIP_BACKOFF_MAX_MS);
+        state.quenchUntil = now + ms;
+        state.count = 0;
+        const quench = quenches.get(source);
+        if (quench !== undefined) {
+            quench(ms);
+            logError(new Error(`Sustained rendering oscillation at ${source} (#185 x${TRIP_THRESHOLD} in ${LOG_WINDOW_MS / 1000}s) — ` +
+                `its channel is PAUSED for ${ms / 1000}s to break the loop ` +
+                `(trip #${state.trips}, backoff doubles; animations freeze, no data loss). ` +
+                `This is a bug: please report the component involved.`));
+        }
+        else {
+            logError(new Error(`SUSTAINED rendering oscillation at ${source} (#185 x${TRIP_THRESHOLD} in ${LOG_WINDOW_MS / 1000}s, ` +
+                `trip #${state.trips}) — no quench registered for this source, absorbing only. ` +
+                `This is a bug: please report the component involved.`));
+        }
+    }
+    return true;
+}
+/**
+ * Invoke a notification callback with the overflow guard applied. The
+ * callback's own non-overflow errors propagate unchanged.
+ *
+ * @param source - Stable label naming the enqueue site (for the log line).
+ * @param onChange - The subscriber callback about to run.
+ */
+export function callWithUpdateOverflowGuard(source, onChange) {
+    try {
+        onChange();
+    }
+    catch (error) {
+        if (swallowNestedUpdateOverflow(error, source))
+            return;
+        throw error;
+    }
+}
+/**
+ * Process-level backstop for the overflow error. The hotspot guards above
+ * cover the known enqueue sites (clock tick, reveal tick, channel emit,
+ * scroll/selection notify), but the throw surfaces from whichever timer or
+ * microtask dispatches next — any not-yet-guarded path (a script's own
+ * feeder, a future timer, a plugin's store) would still kill the process.
+ * This installs uncaughtException/unhandledRejection handlers that absorb
+ * exactly the overflow error class (same self-healing contract: React
+ * already reset the counter before throwing) and rethrow everything else
+ * unchanged. Idempotent; opt out with DSH_TUI_NO_185_PROCESS_GUARD=1 when a
+ * host owns process error policy.
+ */
+let processGuardInstalled = false;
+export function installNestedUpdateOverflowProcessGuard() {
+    if (processGuardInstalled)
+        return;
+    if (process.env.DSH_TUI_NO_185_PROCESS_GUARD === '1')
+        return;
+    processGuardInstalled = true;
+    process.on('uncaughtException', error => {
+        if (swallowNestedUpdateOverflow(error, 'process.uncaught'))
+            return;
+        // Unknown errors keep Node's default semantics: rethrowing from a
+        // listener crashes the process with the original error.
+        throw error;
+    });
+    process.on('unhandledRejection', error => {
+        if (swallowNestedUpdateOverflow(error, 'process.rejection'))
+            return;
+        throw error;
+    });
+}

package/lib/types/ink/useTerminalNotification.d.ts

@@ -0,0 +1,45 @@
+import { type Progress } from './terminal.js';
+type WriteRaw = (data: string) => void;
+/**
+ * React context providing a raw terminal write function. Null until a
+ * TerminalWriteProvider is mounted.
+ */
+export declare const TerminalWriteContext: import("react").Context<WriteRaw | null>;
+/**
+ * React provider component for TerminalWriteContext.
+ */
+export declare const TerminalWriteProvider: import("react").Provider<WriteRaw | null>;
+/**
+ * Terminal notification API returned by useTerminalNotification.
+ */
+export type TerminalNotification = {
+    notifyITerm2: (opts: {
+        message: string;
+        title?: string;
+    }) => void;
+    notifyKitty: (opts: {
+        message: string;
+        title: string;
+        id: number;
+    }) => void;
+    notifyGhostty: (opts: {
+        message: string;
+        title: string;
+    }) => void;
+    notifyBell: () => void;
+    /**
+     * Report progress to the terminal via OSC 9;4 sequences.
+     * Supported terminals: ConEmu, Ghostty 1.2.0+, iTerm2 3.6.6+
+     * Pass state=null to clear progress.
+     */
+    progress: (state: Progress['state'] | null, percentage?: number) => void;
+};
+/**
+ * Hook returning terminal notification helpers (iTerm2/kitty/Ghostty
+ * notifications, BEL, and OSC 9;4 progress). Throws when used outside a
+ * TerminalWriteProvider.
+ * @returns the terminal notification API bound to the current provider.
+ */
+export declare function useTerminalNotification(): TerminalNotification;
+export {};
+//# sourceMappingURL=useTerminalNotification.d.ts.map

package/lib/types/ink/useTerminalNotification.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTerminalNotification.d.ts","sourceRoot":"","sources":["../../../src/ink/useTerminalNotification.ts"],"names":[],"mappings":"AACA,OAAO,EAAgC,KAAK,QAAQ,EAAE,MAAM,eAAe,CAAA;AAI3E,KAAK,QAAQ,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;AAEtC;;;GAGG;AACH,eAAO,MAAM,oBAAoB,0CAAuC,CAAA;AAExE;;GAEG;AACH,eAAO,MAAM,qBAAqB,2CAAgC,CAAA;AAElE;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAAG;IACjC,YAAY,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IACjE,WAAW,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IAC3E,aAAa,EAAE,CAAC,IAAI,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,KAAK,IAAI,CAAA;IACjE,UAAU,EAAE,MAAM,IAAI,CAAA;IACtB;;;;OAIG;IACH,QAAQ,EAAE,CAAC,KAAK,EAAE,QAAQ,CAAC,OAAO,CAAC,GAAG,IAAI,EAAE,UAAU,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;CACzE,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,IAAI,oBAAoB,CAqG9D"}

package/lib/types/ink/useTerminalNotification.js

@@ -0,0 +1,70 @@
+import { createContext, useCallback, useContext, useMemo } from 'react';
+import { isProgressReportingAvailable } from './terminal.js';
+import { BEL } from './termio/ansi.js';
+import { ITERM2, OSC, osc, PROGRESS, wrapForMultiplexer } from './termio/osc.js';
+/**
+ * React context providing a raw terminal write function. Null until a
+ * TerminalWriteProvider is mounted.
+ */
+export const TerminalWriteContext = createContext(null);
+/**
+ * React provider component for TerminalWriteContext.
+ */
+export const TerminalWriteProvider = TerminalWriteContext.Provider;
+/**
+ * Hook returning terminal notification helpers (iTerm2/kitty/Ghostty
+ * notifications, BEL, and OSC 9;4 progress). Throws when used outside a
+ * TerminalWriteProvider.
+ * @returns the terminal notification API bound to the current provider.
+ */
+export function useTerminalNotification() {
+    const writeRaw = useContext(TerminalWriteContext);
+    if (!writeRaw) {
+        throw new Error('useTerminalNotification must be used within TerminalWriteProvider');
+    }
+    const notifyITerm2 = useCallback(({ message, title }) => {
+        const displayString = title ? `${title}:\n${message}` : message;
+        writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, `\n\n${displayString}`)));
+    }, [writeRaw]);
+    const notifyKitty = useCallback(({ message, title, id, }) => {
+        writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=0:p=title`, title)));
+        writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:p=body`, message)));
+        writeRaw(wrapForMultiplexer(osc(OSC.KITTY, `i=${id}:d=1:a=focus`, '')));
+    }, [writeRaw]);
+    const notifyGhostty = useCallback(({ message, title }) => {
+        writeRaw(wrapForMultiplexer(osc(OSC.GHOSTTY, 'notify', title, message)));
+    }, [writeRaw]);
+    const notifyBell = useCallback(() => {
+        // Raw BEL — inside tmux this triggers tmux's bell-action (window flag).
+        // Wrapping would make it opaque DCS payload and lose that fallback.
+        writeRaw(BEL);
+    }, [writeRaw]);
+    const progress = useCallback((state, percentage) => {
+        if (!isProgressReportingAvailable()) {
+            return;
+        }
+        if (!state) {
+            writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, '')));
+            return;
+        }
+        const pct = Math.max(0, Math.min(100, Math.round(percentage ?? 0)));
+        switch (state) {
+            case 'completed':
+                writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.CLEAR, '')));
+                break;
+            case 'error':
+                writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.ERROR, pct)));
+                break;
+            case 'indeterminate':
+                writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.INDETERMINATE, '')));
+                break;
+            case 'running':
+                writeRaw(wrapForMultiplexer(osc(OSC.ITERM2, ITERM2.PROGRESS, PROGRESS.SET, pct)));
+                break;
+            case null:
+                // Handled by the if guard above
+                break;
+        }
+    }, [writeRaw]);
+    return useMemo(() => ({ notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress }), [notifyITerm2, notifyKitty, notifyGhostty, notifyBell, progress]);
+}

package/lib/types/ink/warn.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Log a warning when a value is present but not an integer.
+ * @param value - the value to check; undefined is skipped silently.
+ * @param name - the value's name, used in the warning message.
+ */
+export declare function ifNotInteger(value: number | undefined, name: string): void;
+//# sourceMappingURL=warn.d.ts.map

package/lib/types/ink/warn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"warn.d.ts","sourceRoot":"","sources":["../../../src/ink/warn.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,EAAE,IAAI,EAAE,MAAM,GAAG,IAAI,CAM1E"}

package/lib/types/ink/warn.js

@@ -0,0 +1,15 @@
+import { logForDebugging } from '../utils/debug.js';
+/**
+ * Log a warning when a value is present but not an integer.
+ * @param value - the value to check; undefined is skipped silently.
+ * @param name - the value's name, used in the warning message.
+ */
+export function ifNotInteger(value, name) {
+    if (value === undefined)
+        return;
+    if (Number.isInteger(value))
+        return;
+    logForDebugging(`${name} should be an integer, got ${value}`, {
+        level: 'warn',
+    });
+}

package/lib/types/ink/widest-line.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Get the display width of the widest line in a string.
+ * @param string - the text to measure, possibly containing newlines.
+ * @returns the maximum display width across all lines.
+ */
+export declare function widestLine(string: string): number;
+//# sourceMappingURL=widest-line.d.ts.map

package/lib/types/ink/widest-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"widest-line.d.ts","sourceRoot":"","sources":["../../../src/ink/widest-line.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,wBAAgB,UAAU,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAgBjD"}

package/lib/types/ink/widest-line.js

@@ -0,0 +1,19 @@
+import { lineWidth } from './line-width-cache.js';
+/**
+ * Get the display width of the widest line in a string.
+ * @param string - the text to measure, possibly containing newlines.
+ * @returns the maximum display width across all lines.
+ */
+export function widestLine(string) {
+    let maxWidth = 0;
+    let start = 0;
+    while (start <= string.length) {
+        const end = string.indexOf('\n', start);
+        const line = end === -1 ? string.substring(start) : string.substring(start, end);
+        maxWidth = Math.max(maxWidth, lineWidth(line));
+        if (end === -1)
+            break;
+        start = end + 1;
+    }
+    return maxWidth;
+}

package/lib/types/ink/wrap-text.d.ts

@@ -0,0 +1,10 @@
+import type { Styles } from './styles.js';
+/**
+ * Wrap or truncate text to a maximum width according to a textWrap style.
+ * @param text - the text to fit.
+ * @param maxWidth - the maximum display width in columns.
+ * @param wrapType - the textWrap style: wrap, wrap-trim, truncate, truncate-start, or truncate-middle.
+ * @returns the wrapped or truncated text, or `text` unchanged when no wrapping applies.
+ */
+export default function wrapText(text: string, maxWidth: number, wrapType: Styles['textWrap']): string;
+//# sourceMappingURL=wrap-text.d.ts.map

package/lib/types/ink/wrap-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrap-text.d.ts","sourceRoot":"","sources":["../../../src/ink/wrap-text.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAoFzC;;;;;;GAMG;AACH,MAAM,CAAC,OAAO,UAAU,QAAQ,CAC9B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,UAAU,CAAC,GAC3B,MAAM,CAoCR"}

package/lib/types/ink/wrap-text.js

@@ -0,0 +1,103 @@
+import sliceAnsi from '../utils/sliceAnsi.js';
+import { stringWidth } from './stringWidth.js';
+import { wrapAnsi } from './wrapAnsi.js';
+const ELLIPSIS = '…';
+// --- cross-mount wrap cache ------------------------------------------------
+// wrapText is pure: (text, maxWidth, wrapType) deterministically maps to one
+// output string. Yet before this cache every consumer re-wrapped from
+// scratch:
+//
+//  - dom.ts measureTextNode caches dimensions per node; virtualization
+//    unmounts scrolled-away rows, so scrolling back
+//    re-mounts the row's Text nodes and re-runs the FULL wrap (wrap-ansi
+//    tokenizes + string-width-measures every word — 100-300ms single-frame
+//    yoga spikes when a row of large settled text scrolls in, the dominant
+//    long-session scroll stall);
+//  - render-node-to-output.ts wraps every VISIBLE text node on every full
+//    paint pass (no per-node cache at all there).
+//
+// A content-addressed LRU here makes both paths O(1) for immutable settled
+// text (Markdown memo keeps content identity stable for the whole session).
+// The key embeds the raw text, so V8's content-hash Map lookup matches even
+// a rebuilt string. Budget mirrors line-width-cache: whole-cache clear on
+// overflow (repopulates within a frame or two).
+const WRAP_CACHE_MAX_ENTRIES = 2048;
+const WRAP_CACHE_MAX_CHARS = 2_000_000;
+const wrapCache = new Map();
+let wrapCacheChars = 0;
+/** Values below this are not worth a cache entry (key building costs about
+ *  as much as the wrap itself for trivial single-word strings). */
+const WRAP_CACHE_MIN_LENGTH = 24;
+function cachedWrap(text, maxWidth, wrapType, compute) {
+    if (text.length < WRAP_CACHE_MIN_LENGTH)
+        return compute();
+    const key = `${maxWidth}\u0000${wrapType}\u0000${text}`;
+    const hit = wrapCache.get(key);
+    if (hit !== undefined)
+        return hit;
+    const result = compute();
+    if (wrapCache.size >= WRAP_CACHE_MAX_ENTRIES || wrapCacheChars + text.length > WRAP_CACHE_MAX_CHARS) {
+        wrapCache.clear();
+        wrapCacheChars = 0;
+    }
+    wrapCache.set(key, result);
+    wrapCacheChars += text.length;
+    return result;
+}
+// sliceAnsi may include a boundary-spanning wide char (e.g. CJK at position
+// end-1 with width 2 overshoots by 1). Retry with a tighter bound once.
+function sliceFit(text, start, end) {
+    const s = sliceAnsi(text, start, end);
+    return stringWidth(s) > end - start ? sliceAnsi(text, start, end - 1) : s;
+}
+function truncate(text, columns, position) {
+    if (columns < 1)
+        return '';
+    if (columns === 1)
+        return ELLIPSIS;
+    const length = stringWidth(text);
+    if (length <= columns)
+        return text;
+    if (position === 'start') {
+        return ELLIPSIS + sliceFit(text, length - columns + 1, length);
+    }
+    if (position === 'middle') {
+        const half = Math.floor(columns / 2);
+        return (sliceFit(text, 0, half) +
+            ELLIPSIS +
+            sliceFit(text, length - (columns - half) + 1, length));
+    }
+    return sliceFit(text, 0, columns - 1) + ELLIPSIS;
+}
+/**
+ * Wrap or truncate text to a maximum width according to a textWrap style.
+ * @param text - the text to fit.
+ * @param maxWidth - the maximum display width in columns.
+ * @param wrapType - the textWrap style: wrap, wrap-trim, truncate, truncate-start, or truncate-middle.
+ * @returns the wrapped or truncated text, or `text` unchanged when no wrapping applies.
+ */
+export default function wrapText(text, maxWidth, wrapType) {
+    if (wrapType === 'wrap') {
+        return cachedWrap(text, maxWidth, wrapType, () => wrapAnsi(text, maxWidth, {
+            trim: false,
+            hard: true,
+        }));
+    }
+    if (wrapType === 'wrap-trim') {
+        return cachedWrap(text, maxWidth, wrapType, () => wrapAnsi(text, maxWidth, {
+            trim: true,
+            hard: true,
+        }));
+    }
+    if (wrapType.startsWith('truncate')) {
+        let position = 'end';
+        if (wrapType === 'truncate-middle') {
+            position = 'middle';
+        }
+        if (wrapType === 'truncate-start') {
+            position = 'start';
+        }
+        return cachedWrap(text, maxWidth, wrapType, () => truncate(text, maxWidth, position));
+    }
+    return text;
+}

package/lib/types/ink/wrapAnsi.d.ts

@@ -0,0 +1,17 @@
+type WrapAnsiOptions = {
+    hard?: boolean;
+    wordWrap?: boolean;
+    trim?: boolean;
+};
+/**
+ * Wrap a string to a maximum column width, preserving ANSI escape sequences.
+ *
+ * Uses wrap-ansi (with the incremental fast path for growing streaming inputs).
+ * @param input - the string to wrap.
+ * @param columns - the maximum width in columns.
+ * @param options - wrap options: hard breaks long words, wordWrap splits on word boundaries, trim strips trailing whitespace.
+ * @returns the wrapped string.
+ */
+declare const wrapAnsi: (input: string, columns: number, options?: WrapAnsiOptions) => string;
+export { wrapAnsi };
+//# sourceMappingURL=wrapAnsi.d.ts.map

package/lib/types/ink/wrapAnsi.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wrapAnsi.d.ts","sourceRoot":"","sources":["../../../src/ink/wrapAnsi.ts"],"names":[],"mappings":"AAEA,KAAK,eAAe,GAAG;IACrB,IAAI,CAAC,EAAE,OAAO,CAAA;IACd,QAAQ,CAAC,EAAE,OAAO,CAAA;IAClB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAqDD;;;;;;;;GAQG;AACH,QAAA,MAAM,QAAQ,EAAE,CACd,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,eAAe,KACtB,MACmB,CAAA;AAExB,OAAO,EAAE,QAAQ,EAAE,CAAA"}

package/lib/types/ink/wrapAnsi.js

@@ -0,0 +1,38 @@
+import wrapAnsiNpm from 'wrap-ansi';
+const SLOT_MIN_LENGTH = 2048;
+let slot = null;
+function slotOptionsApply(options) {
+    return options?.hard === true && (options?.trim ?? false) === false;
+}
+function wrapAnsiNpmIncremental(input, columns, options) {
+    const slottable = input.length > SLOT_MIN_LENGTH && slotOptionsApply(options);
+    if (slottable && slot !== null && slot.columns === columns && input.startsWith(slot.input)) {
+        const suffix = input.slice(slot.input.length);
+        if (!suffix.includes('\x1b') && !slot.remainder.includes('\x1b')) {
+            const tail = wrapAnsiNpm(slot.remainder + suffix, columns, options).split('\n');
+            const rows = [...slot.headRows, ...tail];
+            slot = { columns, input, headRows: rows.slice(0, -1), remainder: rows[rows.length - 1] ?? '' };
+            return rows.join('\n');
+        }
+    }
+    const result = wrapAnsiNpm(input, columns, options);
+    if (slottable && !input.includes('\x1b')) {
+        const rows = result.split('\n');
+        slot = { columns, input, headRows: rows.slice(0, -1), remainder: rows[rows.length - 1] ?? '' };
+    }
+    else {
+        slot = null;
+    }
+    return result;
+}
+/**
+ * Wrap a string to a maximum column width, preserving ANSI escape sequences.
+ *
+ * Uses wrap-ansi (with the incremental fast path for growing streaming inputs).
+ * @param input - the string to wrap.
+ * @param columns - the maximum width in columns.
+ * @param options - wrap options: hard breaks long words, wordWrap splits on word boundaries, trim strips trailing whitespace.
+ * @returns the wrapped string.
+ */
+const wrapAnsi = wrapAnsiNpmIncremental;
+export { wrapAnsi };

package/lib/types/jsx-runtime.d.ts

@@ -0,0 +1,2 @@
+export * from 'react/jsx-runtime';
+//# sourceMappingURL=jsx-runtime.d.ts.map

package/lib/types/jsx-runtime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsx-runtime.d.ts","sourceRoot":"","sources":["../../src/jsx-runtime.ts"],"names":[],"mappings":"AAYA,cAAc,mBAAmB,CAAA"}

package/lib/types/jsx-runtime.js

@@ -0,0 +1,13 @@
+// Host JSX factory for plugin scenes: re-exports the TUI's OWN
+// react/jsx-runtime, so JSX a plugin compiles against this subpath produces
+// React 19 elements (`Symbol.for('react.transitional.element')`) — the only
+// element flavor this app's reconciler accepts. A plugin bundling its own
+// older React emits `Symbol.for('react.element')` and dies on first render.
+//
+// Plugin tsconfig:
+//   "jsx": "react-jsx",
+//   "jsxImportSource": "dsh-cli"
+//
+// Hooks still come from the scene props' injected `React` — this module
+// covers element creation only.
+export * from 'react/jsx-runtime';

package/lib/types/migrationPrefs.d.ts

@@ -0,0 +1,60 @@
+/**
+ * One-time local migrations (`~/.dsh-tui/migrations.json`), keyed by stable
+ * migration id → ISO timestamp. Named keys (not a bare flag) so later
+ * migrations can append entries without a format change. Best-effort like
+ * every prefs file: a missing/corrupt file reads as "nothing applied yet",
+ * and a failed write simply leaves the migration to retry on a later boot.
+ */
+/**
+ * The fullscreen factory-default flip (schema + `cordis.patch.yml`, 0.9.x):
+ * a `fullscreen: false` pinned in the settings user layer BEFORE the flip
+ * keeps overriding the new default on every boot. The first boot past this
+ * migration clears that stale explicit choice once — see
+ * {@link planFullscreenFactoryMigration} for the decision table.
+ */
+export declare const FULLSCREEN_FACTORY_MIGRATION = "fullscreen-factory-default";
+/**
+ * Read the applied-migration map.
+ * @param dir - Prefs directory (injectable for tests).
+ * @returns Parsed migration map; empty on any read/parse failure.
+ */
+export declare function readAppliedMigrations(dir?: string): Readonly<Record<string, unknown>>;
+/**
+ * Record a migration as applied (merge write — other keys are never dropped).
+ * @param id - Migration id.
+ * @param dir - Prefs directory (injectable for tests).
+ * @returns True when the file was written, false on failure.
+ */
+export declare function markMigrationApplied(id: string, dir?: string): boolean;
+/** What this boot should do about the fullscreen factory-default flip. */
+export type FullscreenFactoryPlan = 'unset' | 'mark' | 'done';
+/**
+ * Decide the migration step from the settings scope's RESOLVED fullscreen
+ * value. The dsh-tui namespace declares no schema default and no `base`
+ * layer for `fullscreen`, so a resolved `false` can only come from the user
+ * layer — the pre-flip explicit choice this migration exists to clear:
+ *  - `done`  — marker present: never touch the user layer again, so a
+ *     `false` written AFTER the migration (a deliberate /settings choice)
+ *     always stands;
+ *  - `unset` — stale pre-flip explicit `false`: the caller clears it via a
+ *     settings `unset` op and boots fullscreen regardless — the doc write
+ *     is async and must not race the synchronous boot decision, so the
+ *     caller shadows the stale value out of its first settings apply;
+ *  - `mark`  — nothing to clear (unset or already `true`): record the
+ *     marker now so a `false` set later is never mistaken for a stale one.
+ */
+export declare function planFullscreenFactoryMigration(resolvedFullscreen: unknown, migrations: Readonly<Record<string, unknown>>): FullscreenFactoryPlan;
+/**
+ * Persist the plan's side effects. For `unset` the marker lands only after
+ * the doc write succeeds — a failed write stays unmarked and the next boot
+ * retries (that boot already ran fullscreen off the shadowed value).
+ * Never rejects.
+ * @param plan - Decision from {@link planFullscreenFactoryMigration}.
+ * @param options - `unset` thunk issuing the settings write; `dir` injects
+ *   the prefs directory for tests.
+ */
+export declare function commitFullscreenFactoryMigration(plan: FullscreenFactoryPlan, options: {
+    unset: () => Promise<void>;
+    dir?: string;
+}): Promise<void>;
+//# sourceMappingURL=migrationPrefs.d.ts.map

package/lib/types/migrationPrefs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrationPrefs.d.ts","sourceRoot":"","sources":["../../src/migrationPrefs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AASH;;;;;;GAMG;AACH,eAAO,MAAM,4BAA4B,+BAA+B,CAAA;AAExE;;;;GAIG;AACH,wBAAgB,qBAAqB,CAAC,GAAG,GAAE,MAAkB,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAQhG;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,EAAE,GAAG,GAAE,MAAkB,GAAG,OAAO,CASjF;AAED,0EAA0E;AAC1E,MAAM,MAAM,qBAAqB,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAA;AAE7D;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,8BAA8B,CAC5C,kBAAkB,EAAE,OAAO,EAC3B,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC5C,qBAAqB,CAGvB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gCAAgC,CACpD,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE;IAAE,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAE,GACpD,OAAO,CAAC,IAAI,CAAC,CAYf"}