@north-light/crouter 0.3.170 → 0.3.172

package/dist/clients/attach/session/mouse.js

@@ -0,0 +1,64 @@
+// session/mouse.ts — terminal mouse reporting for the attach viewport.
+//
+// Mouse reporting starts from the user's configured default. Follow-tmux mode
+// leaves native terminal selection alone when tmux mouse is off; inside a
+// reporting viewer, every mouse sequence is consumed so clicks and drags can
+// never become editor input.
+import { spawnSync } from 'node:child_process';
+import { inTmux } from '../../../core/runtime/placement-tmux.js';
+const MOUSE_REPORTING_ON = '\x1b[?1002h\x1b[?1006h';
+const MOUSE_REPORTING_OFF = '\x1b[?1002l\x1b[?1006l';
+/** Lines moved for one terminal wheel notch. */
+export const WHEEL_LINES = 3;
+function detectMouseDefault() {
+    if (!inTmux())
+        return false;
+    const result = spawnSync('tmux', ['show-options', '-gv', 'mouse'], { encoding: 'utf8' });
+    return result.status === 0 && result.stdout?.trim() === 'on';
+}
+/** Create per-viewer mouse reporting from the user's saved starting mode. */
+export function createMouseReporting(write, defaultMode) {
+    let isEnabled = defaultMode === 'on' || (defaultMode === 'tmux' && detectMouseDefault());
+    const reassert = () => {
+        write(isEnabled ? MOUSE_REPORTING_ON : MOUSE_REPORTING_OFF);
+    };
+    const disable = () => {
+        isEnabled = false;
+        try {
+            write(MOUSE_REPORTING_OFF);
+        }
+        catch {
+            // Terminal restoration is best-effort, including during process exit.
+        }
+    };
+    process.once('exit', disable);
+    return {
+        enabled: () => isEnabled,
+        toggle: () => {
+            isEnabled = !isEnabled;
+            reassert();
+            return isEnabled;
+        },
+        reassert,
+        disable,
+        install: (tui, onWheel) => tui.addInputListener((data) => {
+            let consumed = false;
+            const withoutSgr = data.replace(/\x1b\[<(\d+);(\d+);\d+[Mm]/g, (_match, buttons, column) => {
+                consumed = true;
+                const button = Number(buttons) & ~(4 | 8 | 16);
+                if (button === 64)
+                    onWheel('up', WHEEL_LINES, Number(column));
+                if (button === 65)
+                    onWheel('down', WHEEL_LINES, Number(column));
+                return '';
+            });
+            const withoutMouse = withoutSgr.replace(/\x1b\[M[\s\S]{3}/g, () => {
+                consumed = true;
+                return '';
+            });
+            if (!consumed)
+                return undefined;
+            return withoutMouse.length > 0 ? { data: withoutMouse } : { consume: true };
+        }),
+    };
+}

package/dist/clients/attach/session/pane-tag.d.ts

@@ -8,8 +8,11 @@
  *  to call from a teardown that runs before it was ever claimed. */
 export declare function createPaneTag(remote: boolean, nodeId: string): {
     set: () => void;
+    stamp: () => void;
     clear: () => void;
     pane: () => string | undefined;
 };
 export declare function tagAttachPane(remote: boolean, pane: string | undefined, nodeId: string, setOpt?: (pane: string, name: string, value: string) => void): void;
 export declare function untagAttachPane(remote: boolean, pane: string | undefined, setOpt?: (pane: string, name: string, value: string) => void): void;
+export declare function tagAttachViewerPane(pane: string | undefined, setOpt?: (pane: string, name: string, value: string) => void): void;
+export declare function untagAttachViewerPane(pane: string | undefined, setOpt?: (pane: string, name: string, value: string) => void): void;

package/dist/clients/attach/session/pane-tag.js

@@ -1,11 +1,11 @@
-// session/pane-tag.ts — the `@crtr_node` tmux pane tag that lets the
-// host-agnostic `nodeInPane()` (the Alt+C cycle/recycle/close/demote family)
-// resolve which broker-hosted node a viewer pane is showing.
+// session/pane-tag.ts — pane tags owned by an attach viewer.
 //
-// LOCAL ONLY: a remote attach (`--canvas`) never sets the tag, so local pane
-// lifecycle can never resolve a remote node id — or a local id that happens to
-// collide with it — from this pane.
-import { currentTmux, setPaneOption } from '../../../core/runtime/placement-tmux.js';
+// `@crtr_node` is local identity used by nodeInPane(). A remote attach never
+// sets it, so local lifecycle cannot resolve a remote node id (or a colliding
+// local id) from that pane. `@crtr_attach` carries no identity: every local or
+// remote attach viewer sets it so tmux can conditionally forward opted-in root
+// gestures into whichever attach pane currently has focus.
+import { currentTmux, setPaneOption, stampViewerPaneAsync, VIEWER_STAMP_OPTION, } from '../../../core/runtime/placement-tmux.js';
 /** The tag's lifecycle for one viewer: `set()` once the startup checkpoint has
  *  cleared, `clear()` on teardown so a stray tag can't outlive the pane.
  *  `pane()` is the id teardown reports as this viewer's home.
@@ -20,11 +20,38 @@ export function createPaneTag(remote, nodeId) {
         set: () => {
             pane = process.env['TMUX_PANE'] ?? currentTmux()?.pane;
             tagAttachPane(remote, pane, nodeId);
+            tagAttachViewerPane(pane);
+            stampAttachPane(remote, pane);
+        },
+        stamp: () => {
+            if (remote || pane === undefined || pane === '')
+                return;
+            stampViewerPaneAsync(pane);
+        },
+        clear: () => {
+            untagAttachPane(remote, pane);
+            untagAttachViewerPane(pane);
+            unstampAttachPane(remote, pane);
         },
-        clear: () => untagAttachPane(remote, pane),
         pane: () => pane,
     };
 }
+function stampAttachPane(remote, pane) {
+    if (remote || pane === undefined || pane === '')
+        return;
+    try {
+        setPaneOption(pane, VIEWER_STAMP_OPTION, String(Date.now()));
+    }
+    catch { /* best-effort */ }
+}
+function unstampAttachPane(remote, pane) {
+    if (remote || pane === undefined || pane === '')
+        return;
+    try {
+        setPaneOption(pane, VIEWER_STAMP_OPTION, '');
+    }
+    catch { /* best-effort */ }
+}
 export function tagAttachPane(remote, pane, nodeId, setOpt = setPaneOption) {
     if (remote || pane === undefined || pane === '')
         return;
@@ -41,3 +68,19 @@ export function untagAttachPane(remote, pane, setOpt = setPaneOption) {
     }
     catch { /* best-effort */ }
 }
+export function tagAttachViewerPane(pane, setOpt = setPaneOption) {
+    if (pane === undefined || pane === '')
+        return;
+    try {
+        setOpt(pane, '@crtr_attach', '1');
+    }
+    catch { /* best-effort */ }
+}
+export function untagAttachViewerPane(pane, setOpt = setPaneOption) {
+    if (pane === undefined || pane === '')
+        return;
+    try {
+        setOpt(pane, '@crtr_attach', '');
+    }
+    catch { /* best-effort */ }
+}

package/dist/clients/attach/session/reconnect.d.ts

@@ -33,5 +33,8 @@ export interface ReconnectSupervisor {
     /** Install the permanent frame/error/close handlers. Call once, AFTER the
      *  connect race is settled and its temporary listeners are gone. */
     install: () => void;
+    /** Cancel the current delay/redial wait. Ordinary attach never calls this;
+     *  bounded companion surfaces call it before closing their socket. */
+    stop: () => void;
 }
 export declare function createReconnect(ctx: Pick<AttachSession, 'nodeId' | 'socket' | 'canvasSource'>, hooks: ReconnectHooks): ReconnectSupervisor;

package/dist/clients/attach/session/reconnect.js

@@ -12,7 +12,6 @@ import { reconnectShouldGiveUp } from '../../../core/broker-client/index.js';
 const RECONNECT_ACTIVE_DELAY_CAP_MS = 1_000;
 /** Dormant by choice — low-rate patience. */
 const RECONNECT_DORMANT_DELAY_MS = 3_000;
-const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
 export function createReconnect(ctx, hooks) {
     const { nodeId, socket, canvasSource } = ctx;
     let lastSocketError;
@@ -22,6 +21,30 @@ export function createReconnect(ctx, hooks) {
     // closes its pane instead of freezing a scary "broker gone" corpse.
     // `dead`/`canceled` keep the corpse.
     let finalizedDone = false;
+    let stopped = false;
+    let resolveStopped = () => { };
+    let retryTimer;
+    let cancelRetry;
+    const stoppedSignal = new Promise((resolve) => {
+        resolveStopped = resolve;
+    });
+    const waitForRetry = (ms) => {
+        if (stopped)
+            return Promise.resolve(false);
+        return new Promise((resolve) => {
+            const settle = (elapsed) => {
+                retryTimer = undefined;
+                cancelRetry = undefined;
+                resolve(elapsed);
+            };
+            retryTimer = setTimeout(() => settle(true), ms);
+            cancelRetry = () => {
+                if (retryTimer !== undefined)
+                    clearTimeout(retryTimer);
+                settle(false);
+            };
+        });
+    };
     // The handshake the viewer sends on connect AND on every successful redial.
     // After a broker refresh / crash-revive the fresh process has no memory of
     // this client, so re-`hello` resumes the role chosen at the original attach
@@ -51,7 +74,7 @@ export function createReconnect(ctx, hooks) {
         hooks.setNotice('↻ node refreshing — reconnecting…', { sticky: true });
         let delay = 200;
         try {
-            while (!hooks.isTornDown()) {
+            while (!stopped && !hooks.isTornDown()) {
                 // The row read is advisory: a transient canvas-source error must never
                 // kill the supervisor loop — treat it as "keep trying" and read again
                 // on the next attempt. `canvasSource` is genuinely remote-backed under
@@ -81,7 +104,12 @@ export function createReconnect(ctx, hooks) {
                     hooks.onEnterDormancy();
                 hooks.setNotice(dormant ? '' : '↻ node refreshing — reconnecting…', { sticky: !dormant });
                 try {
-                    await socket.redial();
+                    const redialed = await Promise.race([
+                        socket.redial().then(() => true),
+                        stoppedSignal.then(() => false),
+                    ]);
+                    if (!redialed || stopped || hooks.isTornDown())
+                        return;
                     sendHello();
                     viewerDormant = false;
                     hooks.setNotice('');
@@ -89,7 +117,9 @@ export function createReconnect(ctx, hooks) {
                 }
                 catch {
                     // ENOENT (socket not recreated yet) / ECONNREFUSED (listen not ready) → retry.
-                    await sleep(dormant ? RECONNECT_DORMANT_DELAY_MS : Math.min(delay, RECONNECT_ACTIVE_DELAY_CAP_MS));
+                    const elapsed = await waitForRetry(dormant ? RECONNECT_DORMANT_DELAY_MS : Math.min(delay, RECONNECT_ACTIVE_DELAY_CAP_MS));
+                    if (!elapsed)
+                        return;
                     delay *= 2;
                 }
             }
@@ -100,7 +130,7 @@ export function createReconnect(ctx, hooks) {
             // latch eats every future close event and hangs the viewer forever).
             reconnecting = false;
         }
-        if (!hooks.isTornDown())
+        if (!stopped && !hooks.isTornDown())
             hooks.teardown(finalizedDone ? 'node-done' : 'broker-gone');
     };
     const install = () => {
@@ -123,5 +153,12 @@ export function createReconnect(ctx, hooks) {
         isDormant: () => viewerDormant,
         lastSocketError: () => lastSocketError,
         install,
+        stop: () => {
+            if (stopped)
+                return;
+            stopped = true;
+            cancelRetry?.();
+            resolveStopped();
+        },
     };
 }

package/dist/clients/attach/session/surface-frame.d.ts

@@ -0,0 +1,20 @@
+import { type Component } from '@earendil-works/pi-tui';
+import type { SurfaceComponent } from '../../surfaces/host.js';
+/**
+ * The opaque rectangle wrapper used for every viewer surface. Rows are read
+ * and pushed inside the render pass: a surface hidden beneath another surface
+ * is not rendered, and therefore never observes a stale height when restored.
+ */
+export declare class SurfaceFrame implements Component {
+    private readonly surface;
+    private readonly focusTarget;
+    private readonly getRows;
+    private _focused;
+    constructor(surface: SurfaceComponent, focusTarget: Component, getRows: () => number);
+    get focused(): boolean;
+    set focused(value: boolean);
+    get wantsKeyRelease(): boolean;
+    render(width: number): string[];
+    handleInput(data: string): void;
+    invalidate(): void;
+}

package/dist/clients/attach/session/surface-frame.js

@@ -0,0 +1,73 @@
+import { CURSOR_MARKER, isFocusable, sliceByColumn, truncateToWidth, visibleWidth, } from '@earendil-works/pi-tui';
+import { reportInvariant as report } from './invariant.js';
+/**
+ * The opaque rectangle wrapper used for every viewer surface. Rows are read
+ * and pushed inside the render pass: a surface hidden beneath another surface
+ * is not rendered, and therefore never observes a stale height when restored.
+ */
+export class SurfaceFrame {
+    surface;
+    focusTarget;
+    getRows;
+    _focused = false;
+    constructor(surface, focusTarget, getRows) {
+        this.surface = surface;
+        this.focusTarget = focusTarget;
+        this.getRows = getRows;
+    }
+    get focused() {
+        return this._focused;
+    }
+    set focused(value) {
+        this._focused = value;
+        if (isFocusable(this.focusTarget))
+            this.focusTarget.focused = value;
+    }
+    get wantsKeyRelease() {
+        return this.focusTarget.wantsKeyRelease ?? this.surface.wantsKeyRelease ?? false;
+    }
+    render(width) {
+        const rows = Math.max(0, Math.floor(this.getRows()));
+        const columns = Math.max(0, Math.floor(width));
+        this.surface.setRows(rows);
+        const rendered = this.surface.render(columns);
+        if (rendered.length !== rows) {
+            reportInvariant(`surface rendered ${rendered.length} rows; expected ${rows}`);
+        }
+        const frame = rendered.slice(0, rows).map((line) => {
+            if (visibleWidth(line) > columns) {
+                reportInvariant(`surface row is ${visibleWidth(line)} cells wide; expected at most ${columns}`);
+                return padToWidth(sliceByColumn(line, 0, columns, true), columns);
+            }
+            return padToWidth(line, columns);
+        });
+        while (frame.length < rows)
+            frame.push(' '.repeat(columns));
+        const markerCount = countMarkers(frame);
+        if (markerCount > 1) {
+            reportInvariant(`surface frame contains ${markerCount} CURSOR_MARKER sequences; expected at most one`);
+            return frame.map(stripCursorMarkers);
+        }
+        return frame;
+    }
+    handleInput(data) {
+        const handler = this.focusTarget.handleInput ?? this.surface.handleInput;
+        handler?.call(this.focusTarget.handleInput === undefined ? this.surface : this.focusTarget, data);
+    }
+    invalidate() {
+        this.surface.invalidate();
+    }
+}
+function padToWidth(line, width) {
+    return truncateToWidth(line, width, '', true);
+}
+function countMarkers(lines) {
+    return lines.reduce((count, line) => count + line.split(CURSOR_MARKER).length - 1, 0);
+}
+function stripCursorMarkers(line) {
+    return line.split(CURSOR_MARKER).join('');
+}
+/** Invariants are reported without taking down the attached viewer. */
+function reportInvariant(message) {
+    report('surface-frame', message);
+}

package/dist/clients/attach/session/surface-host.d.ts

@@ -0,0 +1,64 @@
+import { type Component, type TUI } from '@earendil-works/pi-tui';
+import type { SurfaceComponent, SurfaceHandle, SurfaceHost } from '../../surfaces/host.js';
+import type { MouseReporting } from './mouse.js';
+/** The status line's notice options, which the host preserves on both paths. */
+export interface NoticeOptions {
+    /** Keep the notice up until it is replaced or cleared, with no auto-clear. */
+    sticky?: boolean;
+}
+export interface ViewerSurfaceHostOptions {
+    tui: TUI;
+    mouse: MouseReporting;
+    /** The host's assigned row count; surfaces never read terminal geometry. */
+    rows: () => number;
+    /** Fallback notice sink used when no surface is mounted. */
+    statusNotice: (text: string, opts?: NoticeOptions) => void;
+    /** Styling supplied by the viewer's status-line palette. */
+    formatNotice: (text: string) => string;
+    noticeMs: number;
+    capabilities: SurfaceHost['capabilities'];
+    selfPane?: string;
+}
+/** The viewer's one host for full-pane surfaces. */
+export declare class ViewerSurfaceHost implements SurfaceHost {
+    readonly capabilities: SurfaceHost['capabilities'];
+    private readonly tui;
+    private readonly mouse;
+    private readonly getRows;
+    private readonly statusNotice;
+    private readonly formatNotice;
+    private readonly noticeMs;
+    private readonly selfPane;
+    private readonly stack;
+    private noticeOverlay;
+    private noticeTimer;
+    constructor(options: ViewerSurfaceHostOptions);
+    mount(component: SurfaceComponent, opts?: {
+        focus?: Component;
+    }): SurfaceHandle;
+    /**
+     * The one visible notice channel. Surfaces call this with a message only; the
+     * viewer routes its whole notice verb through here, so both status-line
+     * semantics survive a mounted surface: an empty string clears the current
+     * notice rather than painting a bare warning icon, and `sticky` suppresses the
+     * auto-clear for a condition that is not time-bounded (a reconnect loop, an
+     * armed confirmation).
+     */
+    notice(text: string, opts?: NoticeOptions): void;
+    suspendForChild(): () => void;
+    focusNode(nodeId: string): Promise<boolean>;
+    pickReviewFile(spec: {
+        candidates: readonly string[];
+        cwd: string;
+        title?: string;
+    }): Promise<string | null>;
+    /** Offer wheel input to the topmost surface only. */
+    handleWheel(direction: 'up' | 'down', lines: number, column: number): boolean;
+    /** Whether a full-pane surface currently owns input. */
+    hasFullPaneSurface(): boolean;
+    /** Close the whole stack before the viewer tears down its TUI. */
+    closeAll(): void;
+    private closeEntry;
+    private disposeNotice;
+    private disposeNoticeOverlay;
+}

package/dist/clients/attach/session/surface-host.js

@@ -0,0 +1,255 @@
+import { truncateToWidth, } from '@earendil-works/pi-tui';
+import { cliClient } from '../../../commands/api-client.js';
+import { focusViewer } from '../../../commands/node.js';
+import { daemonErrorMessage } from '../../inbox/resolve.js';
+import { buildFileReviewPicker } from '../overlays/file-review.js';
+import { reportInvariant as report } from './invariant.js';
+import { SurfaceFrame } from './surface-frame.js';
+const SURFACE_OVERLAY_OPTIONS = {
+    anchor: 'top-left',
+    width: '100%',
+    maxHeight: '100%',
+    margin: 0,
+};
+const NOTICE_OVERLAY_OPTIONS = {
+    anchor: 'top-left',
+    width: '100%',
+    margin: 0,
+    nonCapturing: true,
+};
+/** The viewer's one host for full-pane surfaces. */
+export class ViewerSurfaceHost {
+    capabilities;
+    tui;
+    mouse;
+    getRows;
+    statusNotice;
+    formatNotice;
+    noticeMs;
+    selfPane;
+    stack = [];
+    noticeOverlay;
+    noticeTimer;
+    constructor(options) {
+        this.tui = options.tui;
+        this.mouse = options.mouse;
+        this.getRows = options.rows;
+        this.statusNotice = options.statusNotice;
+        this.formatNotice = options.formatNotice;
+        this.noticeMs = options.noticeMs;
+        this.capabilities = options.capabilities;
+        this.selfPane = options.selfPane;
+    }
+    mount(component, opts) {
+        this.disposeNotice();
+        const frame = new SurfaceFrame(component, opts?.focus ?? component, this.getRows);
+        const overlay = this.tui.showOverlay(frame, SURFACE_OVERLAY_OPTIONS);
+        const entry = { component, frame, overlay, cleanup: [], closed: false, closing: false };
+        const previous = this.stack[this.stack.length - 1];
+        if (previous)
+            previous.overlay.setHidden(true);
+        this.stack.push(entry);
+        return {
+            close: () => this.closeEntry(entry, true),
+            invalidate: () => {
+                if (!entry.closed && this.stack[this.stack.length - 1] === entry)
+                    this.tui.requestRender();
+            },
+            onClose: (fn) => {
+                if (entry.closed || entry.closing) {
+                    reportInvariant('onClose registered after surface close');
+                    return;
+                }
+                entry.cleanup.push(fn);
+            },
+        };
+    }
+    /**
+     * The one visible notice channel. Surfaces call this with a message only; the
+     * viewer routes its whole notice verb through here, so both status-line
+     * semantics survive a mounted surface: an empty string clears the current
+     * notice rather than painting a bare warning icon, and `sticky` suppresses the
+     * auto-clear for a condition that is not time-bounded (a reconnect loop, an
+     * armed confirmation).
+     */
+    notice(text, opts) {
+        this.disposeNotice();
+        if (this.stack.length === 0) {
+            this.statusNotice(text, opts);
+            return;
+        }
+        if (text === '')
+            return;
+        const notice = new NoticeOverlay(() => this.formatNotice(text));
+        this.noticeOverlay = this.tui.showOverlay(notice, NOTICE_OVERLAY_OPTIONS);
+        if (opts?.sticky !== true && this.noticeMs > 0) {
+            this.noticeTimer = setTimeout(() => {
+                this.noticeTimer = undefined;
+                this.disposeNoticeOverlay();
+            }, this.noticeMs);
+        }
+    }
+    suspendForChild() {
+        this.tui.stop();
+        return () => {
+            this.tui.start();
+            this.mouse.reassert();
+            this.tui.invalidate();
+            this.tui.requestRender(true);
+        };
+    }
+    async focusNode(nodeId) {
+        if (!this.capabilities.canFocusNode || this.selfPane === undefined || this.selfPane === '') {
+            this.notice('Focusing a node needs a local viewer in tmux');
+            return false;
+        }
+        try {
+            const node = await cliClient().getNode(nodeId);
+            const result = await focusViewer(nodeId, {
+                pane: this.selfPane,
+                cwd: node.cwd,
+                name: node.name,
+            });
+            if (!result.focused)
+                this.notice('Could not open that node’s viewer');
+            return result.focused;
+        }
+        catch (error) {
+            this.notice(daemonErrorMessage(error));
+            return false;
+        }
+    }
+    pickReviewFile(spec) {
+        return new Promise((resolve) => {
+            let handle;
+            let settled = false;
+            const settle = (value) => {
+                if (settled)
+                    return;
+                settled = true;
+                resolve(value);
+                handle.close();
+            };
+            const picker = buildFileReviewPicker(spec.candidates, spec.cwd, (file) => settle(file), () => settle(null), (message) => this.notice(message));
+            handle = this.mount(titled(picker.component, spec.title), { focus: picker.focus });
+            handle.onClose(() => settle(null));
+        });
+    }
+    /** Offer wheel input to the topmost surface only. */
+    handleWheel(direction, lines, column) {
+        return this.stack[this.stack.length - 1]?.component.handleWheel?.(direction, lines, column) ?? false;
+    }
+    /** Whether a full-pane surface currently owns input. */
+    hasFullPaneSurface() {
+        return this.stack.length > 0;
+    }
+    /** Close the whole stack before the viewer tears down its TUI. */
+    closeAll() {
+        const bottom = this.stack[0];
+        if (bottom)
+            this.closeEntry(bottom, false);
+        this.disposeNotice();
+    }
+    closeEntry(entry, restore) {
+        if (entry.closed || entry.closing)
+            return;
+        const index = this.stack.indexOf(entry);
+        if (index === -1) {
+            entry.closed = true;
+            return;
+        }
+        entry.closing = true;
+        // Closing a parent owns every descendant. Close top-down, without
+        // restoring an intermediate surface that is about to be closed too.
+        while (this.stack.indexOf(entry) !== -1) {
+            const currentIndex = this.stack.indexOf(entry);
+            const child = this.stack[currentIndex + 1];
+            if (!child)
+                break;
+            this.closeEntry(child, false);
+        }
+        try {
+            entry.overlay.hide();
+        }
+        catch (error) {
+            reportInvariant(`surface overlay hide failed: ${errorMessage(error)}`);
+        }
+        for (const cleanup of entry.cleanup) {
+            try {
+                const result = cleanup();
+                if (result && typeof result.then === 'function') {
+                    void result.catch((error) => reportInvariant(`surface cleanup failed: ${errorMessage(error)}`));
+                }
+            }
+            catch (error) {
+                reportInvariant(`surface cleanup failed: ${errorMessage(error)}`);
+            }
+        }
+        entry.cleanup.length = 0;
+        entry.closed = true;
+        entry.closing = false;
+        const currentIndex = this.stack.indexOf(entry);
+        if (currentIndex !== -1)
+            this.stack.splice(currentIndex, 1);
+        if (restore) {
+            // A notice belongs to the surface it was raised over, so it goes when that
+            // surface does — including when the stack empties and no lower surface is
+            // left to restore, which would otherwise strand the overlay above the
+            // bare cockpit.
+            this.disposeNotice();
+            const top = this.stack[this.stack.length - 1];
+            if (top)
+                top.overlay.setHidden(false);
+        }
+    }
+    disposeNotice() {
+        this.disposeNoticeOverlay();
+        if (this.noticeTimer !== undefined) {
+            clearTimeout(this.noticeTimer);
+            this.noticeTimer = undefined;
+        }
+    }
+    disposeNoticeOverlay() {
+        this.noticeOverlay?.hide();
+        this.noticeOverlay = undefined;
+    }
+}
+class NoticeOverlay {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+    render(width) {
+        return [truncateToWidth(this.text(), Math.max(0, width), '', true)];
+    }
+    invalidate() { }
+}
+/**
+ * Apply an optional picker title without giving the host a second picker. A
+ * surface owes the host exactly its assigned rows, so this fills the rectangle
+ * the picker's natural height leaves short instead of handing the frame a
+ * three-row component and tripping its invariant on every render.
+ */
+function titled(component, title) {
+    let rows = 0;
+    return {
+        setRows: (value) => {
+            rows = Math.max(0, Math.floor(value));
+        },
+        render: (width) => {
+            const lines = component.render(width);
+            const body = title === undefined ? lines : [truncateToWidth(title, Math.max(0, width), '', true), ...lines.slice(1)];
+            const frame = body.slice(0, rows);
+            while (frame.length < rows)
+                frame.push('');
+            return frame;
+        },
+        invalidate: () => component.invalidate(),
+    };
+}
+function reportInvariant(message) {
+    report('surface-host', message);
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}