tmux-ide 2.8.0 → 2.9.0-beta.5

package/packages/daemon/dist/tui/mirror/features/changes/controller.js

@@ -0,0 +1,454 @@
+import { basename, join } from "node:path";
+import { createRoot, createSignal } from "solid-js";
+import { changesBodyRows, changesHitTest, projectChangesSurface, } from "../../changes-surface.js";
+import { buildDiffRows, classifyDiff, clampSel, filterEntries, hunkEditTarget, nextHunkTop, rowIndexOfFile, totalCounts, untrackedDiffText, } from "../../diff-model.js";
+import { isBinary } from "../../runtime/file-content-primitives.js";
+import { clampTop, scrollToCursor } from "../../runtime/editor-primitives.js";
+const DEFAULT_SCROLL_STEP = 3;
+const statusLetter = (status) => ({
+    modified: "M",
+    added: "A",
+    deleted: "D",
+    renamed: "R",
+    copied: "C",
+    "type-changed": "T",
+    conflicted: "U",
+    untracked: "?",
+})[status] ?? "M";
+const projectionHover = (hover) => {
+    if (!hover)
+        return null;
+    if (hover.kind === "header-action")
+        return { region: "button", index: hover.index };
+    if (hover.kind === "footer-action")
+        return { region: "diffverb", index: hover.index };
+    return { region: "diff", index: hover.index };
+};
+/**
+ * Owns the complete demand-loaded Changes interaction model.
+ *
+ * The controller has its own explicitly disposed Solid owner because its module
+ * is imported after the application root has mounted. All asynchronous Git
+ * callbacks are fenced by both workspace generation and selected-read token, so
+ * a retired controller or an earlier workspace can never publish late state.
+ */
+export function createChangesFeatureController(host, initialIdentity) {
+    return createRoot((disposeOwner) => {
+        const [workspaceName, setWorkspaceName] = createSignal(initialIdentity.workspaceName);
+        const [directory, setDirectory] = createSignal(initialIdentity.directory);
+        const [entries, setEntries] = createSignal([]);
+        const [selected, setSelected] = createSignal(0);
+        const [diffText, setDiffText] = createSignal("");
+        const [diffTop, setDiffTop] = createSignal(0);
+        const [fileTop, setFileTop] = createSignal(0);
+        const [message, setMessage] = createSignal("");
+        const [filter, setFilter] = createSignal(null);
+        let pendingPath = null;
+        let pendingGroup = null;
+        let readToken = 0;
+        let generation = 1;
+        let disposed = false;
+        const bodyRows = () => Math.max(1, changesBodyRows(host.height()));
+        let cachedDiffText = null;
+        let cachedLines = [];
+        const lines = () => {
+            const text = diffText();
+            if (text !== cachedDiffText) {
+                cachedDiffText = text;
+                cachedLines = classifyDiff(text);
+            }
+            return cachedLines;
+        };
+        let cachedEntries = null;
+        let cachedFilter = null;
+        let cachedRowsData = { rows: [], files: [] };
+        const rowsData = () => {
+            const source = entries();
+            const query = filter();
+            if (source !== cachedEntries || query !== cachedFilter) {
+                cachedEntries = source;
+                cachedFilter = query;
+                cachedRowsData = buildDiffRows(filterEntries(source, query ?? ""));
+            }
+            return cachedRowsData;
+        };
+        const rows = () => rowsData().rows;
+        const visibleFiles = () => rowsData().files;
+        const visibleLines = () => {
+            const all = lines();
+            const top = clampTop(diffTop(), all.length, bodyRows());
+            return all.slice(top, top + bodyRows());
+        };
+        const visibleRows = () => {
+            const all = rows();
+            const top = clampTop(fileTop(), all.length, bodyRows());
+            return all.slice(top, top + bodyRows()).map((row, offset) => ({
+                row,
+                rowIndex: top + offset,
+            }));
+        };
+        const projection = () => projectChangesSurface({
+            width: host.width(),
+            height: host.height(),
+            dir: directory(),
+            fileCount: visibleFiles().length,
+            totals: totalCounts(visibleFiles()),
+            filterQuery: filter(),
+            message: message(),
+            listRows: visibleRows(),
+            selectedFileIndex: selected(),
+            diffLines: visibleLines(),
+            hovered: projectionHover(host.hover()),
+            footerHint: "]/[ hunk · ^e edit · / filter · r refresh · ^g home · ^q quit",
+        });
+        const current = () => visibleFiles()[selected()];
+        const alive = (expectedGeneration) => !disposed && expectedGeneration === generation;
+        const loadDiff = (entry) => {
+            const token = ++readToken;
+            const expectedGeneration = generation;
+            setMessage("");
+            if (entry.group === "untracked") {
+                try {
+                    const bytes = host.readFile(join(directory(), entry.path));
+                    if (!alive(expectedGeneration) || token !== readToken)
+                        return;
+                    if (isBinary(bytes)) {
+                        setDiffText("");
+                        setMessage("binary file");
+                    }
+                    else {
+                        setDiffText(untrackedDiffText(Buffer.from(bytes).toString("utf8")));
+                    }
+                }
+                catch (error) {
+                    if (!alive(expectedGeneration) || token !== readToken)
+                        return;
+                    setDiffText("");
+                    setMessage(`cannot read: ${error.message}`);
+                }
+                return;
+            }
+            const args = entry.group === "staged"
+                ? ["diff", "--no-color", "--cached", "--", entry.path]
+                : ["diff", "--no-color", "--", entry.path];
+            host.runGit(directory(), args, (stdout) => {
+                if (!alive(expectedGeneration) || token !== readToken)
+                    return;
+                setDiffText((previous) => (previous === stdout ? previous : stdout));
+            });
+        };
+        const selectFile = (index) => {
+            const files = visibleFiles();
+            if (files.length === 0)
+                return;
+            const next = clampSel(index, files.length);
+            setSelected(next);
+            setDiffTop(0);
+            const rowIndex = rowIndexOfFile(rows(), next);
+            if (rowIndex !== -1) {
+                setFileTop((top) => scrollToCursor(rowIndex, top, bodyRows(), rows().length));
+            }
+            loadDiff(files[next]);
+        };
+        const reselectFilter = () => {
+            if (visibleFiles().length === 0) {
+                setSelected(0);
+                setDiffText("");
+            }
+            else {
+                selectFile(0);
+            }
+        };
+        const mutate = (args, done) => {
+            const expectedGeneration = generation;
+            host.runGit(directory(), args, () => {
+                if (!alive(expectedGeneration))
+                    return;
+                done();
+            });
+        };
+        const stage = (entry) => {
+            if (entry.group === "staged") {
+                host.setStatusNote("already staged");
+                return;
+            }
+            mutate(["add", "--", entry.path], () => {
+                pendingPath = entry.path;
+                pendingGroup = "staged";
+                host.setStatusNote(`staged ${entry.path}`);
+                host.refreshResource();
+            });
+        };
+        const unstage = (entry) => {
+            if (entry.group !== "staged") {
+                host.setStatusNote("not staged");
+                return;
+            }
+            mutate(["reset", "HEAD", "--", entry.path], () => {
+                pendingPath = entry.path;
+                pendingGroup = "unstaged";
+                host.setStatusNote(`unstaged ${entry.path}`);
+                host.refreshResource();
+            });
+        };
+        const stageAll = () => {
+            const entry = current();
+            mutate(["add", "-A"], () => {
+                if (entry) {
+                    pendingPath = entry.path;
+                    pendingGroup = "staged";
+                }
+                host.setStatusNote("staged all changes");
+                host.refreshResource();
+            });
+        };
+        const unstageAll = () => {
+            const entry = current();
+            mutate(["reset", "HEAD"], () => {
+                if (entry) {
+                    pendingPath = entry.path;
+                    pendingGroup = entry.group === "staged" ? "unstaged" : entry.group;
+                }
+                host.setStatusNote("unstaged all");
+                host.refreshResource();
+            });
+        };
+        const runAction = (action, fileIndex = selected()) => {
+            if (action === "refresh")
+                host.refreshResource();
+            else if (action === "stage-all")
+                stageAll();
+            else if (action === "unstage-all")
+                unstageAll();
+            else {
+                const entry = visibleFiles()[fileIndex];
+                if (!entry)
+                    return;
+                if (action === "stage" || action === "row-stage")
+                    stage(entry);
+                else if (action === "unstage" || action === "row-unstage")
+                    unstage(entry);
+            }
+        };
+        const jumpHunk = (direction) => {
+            const all = lines();
+            const currentTop = clampTop(diffTop(), all.length, bodyRows());
+            const next = nextHunkTop(all, currentTop, direction);
+            if (next !== null)
+                setDiffTop(clampTop(next, all.length, bodyRows()));
+        };
+        const openSelected = () => {
+            const entry = current();
+            if (!entry)
+                return;
+            const all = lines();
+            const line = hunkEditTarget(all, clampTop(diffTop(), all.length, bodyRows()));
+            host.openEditor(join(directory(), entry.path), line ?? undefined);
+        };
+        const reset = (nextMessage = "") => {
+            generation += 1;
+            readToken += 1;
+            pendingPath = null;
+            pendingGroup = null;
+            setEntries([]);
+            setSelected(0);
+            setDiffText("");
+            setDiffTop(0);
+            setFileTop(0);
+            setMessage(nextMessage);
+            setFilter(null);
+        };
+        const setWorkspaceIdentity = (identity) => {
+            reset();
+            setWorkspaceName(identity.workspaceName);
+            setDirectory(identity.directory);
+        };
+        const prepare = (identity) => {
+            setWorkspaceIdentity(identity);
+            host.refreshResource();
+        };
+        const restoreSelectedPath = (path) => {
+            pendingPath = path;
+            pendingGroup = null;
+            if (!path || visibleFiles().length === 0)
+                return;
+            const index = visibleFiles().findIndex((entry) => entry.path === path);
+            if (index < 0)
+                return;
+            pendingPath = null;
+            selectFile(index);
+        };
+        const applyCatalog = (envelope) => {
+            if (disposed)
+                return;
+            const resource = envelope.resource;
+            if (resource.workspaceName !== workspaceName())
+                return;
+            if (resource.status !== "ready") {
+                readToken += 1;
+                setEntries([]);
+                setDiffText("");
+                setMessage(resource.message);
+                return;
+            }
+            const nextEntries = resource.entries.map((entry) => ({
+                group: entry.group,
+                status: statusLetter(entry.status),
+                path: entry.relativePath,
+                additions: entry.additions,
+                deletions: entry.deletions,
+            }));
+            setEntries(nextEntries);
+            const files = visibleFiles();
+            if (files.length === 0) {
+                readToken += 1;
+                setDiffText("");
+                setMessage(nextEntries.length === 0 ? "working tree clean" : "");
+                return;
+            }
+            setMessage("");
+            let next = clampSel(selected(), files.length);
+            if (pendingPath) {
+                const exact = pendingGroup
+                    ? files.findIndex((entry) => entry.path === pendingPath && entry.group === pendingGroup)
+                    : -1;
+                const fallback = files.findIndex((entry) => entry.path === pendingPath);
+                if (exact >= 0 || fallback >= 0)
+                    next = exact >= 0 ? exact : fallback;
+                pendingPath = null;
+                pendingGroup = null;
+            }
+            setSelected(next);
+            loadDiff(files[next]);
+        };
+        const handleKey = (event, mode) => {
+            if (disposed)
+                return false;
+            if (mode === "filter") {
+                if (event.name === "escape" || event.name === "return") {
+                    setFilter(null);
+                    reselectFilter();
+                }
+                else if (event.name === "backspace") {
+                    setFilter((query) => (query ?? "").slice(0, -1));
+                    reselectFilter();
+                }
+                else if (event.name === "up")
+                    selectFile(selected() - 1);
+                else if (event.name === "down")
+                    selectFile(selected() + 1);
+                else if (event.name.length === 1 && !event.ctrl && !event.meta) {
+                    setFilter((query) => (query ?? "") + (event.shift ? event.name.toUpperCase() : event.name));
+                    reselectFilter();
+                }
+                return true;
+            }
+            if (event.ctrl && event.name === "e")
+                openSelected();
+            else if (event.name === "j" || event.name === "down")
+                selectFile(selected() + 1);
+            else if (event.name === "k" || event.name === "up")
+                selectFile(selected() - 1);
+            else if (event.name === "s" && event.shift)
+                stageAll();
+            else if (event.name === "u" && event.shift)
+                unstageAll();
+            else if (event.name === "s") {
+                const entry = current();
+                if (entry)
+                    stage(entry);
+            }
+            else if (event.name === "u") {
+                const entry = current();
+                if (entry)
+                    unstage(entry);
+            }
+            else if (event.name === "]")
+                jumpHunk(1);
+            else if (event.name === "[")
+                jumpHunk(-1);
+            else if (event.name === "/" && !event.ctrl && !event.meta)
+                setFilter("");
+            else if (event.name === "r")
+                host.refreshResource();
+            else
+                return false;
+            return true;
+        };
+        const hoverTargetAt = (x, y) => {
+            const hit = changesHitTest(projection(), x, y);
+            if (hit?.area === "header" && hit.actionIndex !== undefined)
+                return { kind: "header-action", index: hit.actionIndex };
+            if (hit?.area === "footer" && hit.actionIndex !== undefined)
+                return { kind: "footer-action", index: hit.actionIndex };
+            if (hit?.area === "list" && hit.rowIndex !== undefined)
+                return { kind: "list-row", index: hit.rowIndex };
+            return null;
+        };
+        const handlePointer = (event) => {
+            if (disposed)
+                return false;
+            const hit = changesHitTest(projection(), event.x, event.y);
+            if (event.type === "scroll") {
+                const step = (event.direction === "up" ? -1 : 1) * (event.scrollStep ?? DEFAULT_SCROLL_STEP);
+                if (hit?.area === "list")
+                    setFileTop((top) => clampTop(top + step, rows().length, bodyRows()));
+                else if (hit?.area === "diff" || event.outsideBody === "diff")
+                    setDiffTop((top) => clampTop(top + step, lines().length, bodyRows()));
+                return true;
+            }
+            if (event.button === 2)
+                return true;
+            if ((hit?.area === "header" || hit?.area === "footer") && hit.actionId) {
+                runAction(hit.actionId);
+            }
+            else if (hit?.area === "list" && hit.fileIndex !== undefined) {
+                if (hit.actionId)
+                    runAction(hit.actionId, hit.fileIndex);
+                else
+                    selectFile(hit.fileIndex);
+            }
+            return true;
+        };
+        const contextTargetAt = (x, y) => {
+            const hit = changesHitTest(projection(), x, y);
+            if (hit?.area !== "list" || hit.fileIndex === undefined)
+                return null;
+            const entry = visibleFiles()[hit.fileIndex];
+            if (!entry)
+                return null;
+            return { title: basename(entry.path), path: join(directory(), entry.path) };
+        };
+        return {
+            projection,
+            directory,
+            hasEntries: () => entries().length > 0,
+            hasSelection: () => current() !== undefined,
+            selectedPath: () => current()?.path ?? null,
+            filterOpen: () => filter() !== null,
+            setWorkspaceIdentity,
+            prepare,
+            reset,
+            applyCatalog,
+            restoreSelectedPath,
+            handleKey,
+            hoverTargetAt,
+            handlePointer,
+            contextTargetAt,
+            scrollState: () => ({
+                contentLength: lines().length,
+                viewportRows: bodyRows(),
+                top: clampTop(diffTop(), lines().length, bodyRows()),
+            }),
+            setScrollTop: (top) => setDiffTop(clampTop(top, lines().length, bodyRows())),
+            dispose: () => {
+                if (disposed)
+                    return;
+                disposed = true;
+                generation += 1;
+                readToken += 1;
+                disposeOwner();
+            },
+        };
+    });
+}

package/packages/daemon/dist/tui/mirror/features/changes/feature.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Complete deferred Changes capability.
+ *
+ * Keep this as the literal optional-feature import root so the controller,
+ * projection/model helpers, and OpenTUI renderer enter both source and compiled
+ * Bun processes only after terminal readiness and explicit Changes demand.
+ */
+export { ChangesSurface, type ChangesSurfaceProps } from "../../changes-surface-view.tsx";
+export { createChangesFeatureController } from "./controller.ts";
+export type { ChangesContextTarget, ChangesFeatureHost, ChangesFeatureSession, ChangesHoverTarget, ChangesKeyEvent, ChangesPointerEvent, ChangesScrollState, ChangesWorkspaceIdentity, } from "./contract.ts";

package/packages/daemon/dist/tui/mirror/features/changes/feature.jsx

@@ -0,0 +1,9 @@
+/**
+ * Complete deferred Changes capability.
+ *
+ * Keep this as the literal optional-feature import root so the controller,
+ * projection/model helpers, and OpenTUI renderer enter both source and compiled
+ * Bun processes only after terminal readiness and explicit Changes demand.
+ */
+export { ChangesSurface } from "../../changes-surface-view.jsx";
+export { createChangesFeatureController } from "./controller.js";

package/packages/daemon/dist/tui/mirror/features/dialogs/contract.d.ts

@@ -0,0 +1,47 @@
+import type { DialogConfirmSpec, DialogGeom, DialogPromptSpec, DialogSelectItem, DialogSelectResult, DialogSelectSpec, DialogSpec } from "../../dialog-model.ts";
+import type { DialogEntryState, DialogKeyEvent } from "../../dialog-stack-core.ts";
+export type DialogSelectRequest = Omit<DialogSelectSpec, "kind">;
+export type DialogPromptRequest = Omit<DialogPromptSpec, "kind">;
+export type DialogConfirmRequest = Omit<DialogConfirmSpec, "kind">;
+export interface DialogFeatureViewport {
+    readonly width: number;
+    readonly height: number;
+    readonly dialogWidth: number;
+}
+export interface DialogFeatureHost {
+    /** Reactive when called inside a Solid owner. */
+    readonly viewport: () => DialogFeatureViewport;
+    readonly onOpenChange?: (open: boolean) => void;
+}
+export type DialogPointerKind = "move" | "down" | "scroll" | "up" | "out";
+export interface DialogPointerEvent {
+    readonly kind: DialogPointerKind;
+    readonly x: number;
+    readonly y: number;
+    readonly scrollDirection?: "up" | "down";
+}
+export interface ClosedDialogFeatureSnapshot {
+    readonly phase: "closed";
+}
+export interface OpenDialogFeatureSnapshot {
+    readonly phase: "open";
+    readonly spec: DialogSpec;
+    readonly state: Readonly<DialogEntryState>;
+    readonly geometry: DialogGeom;
+    readonly visibleItems: readonly DialogSelectItem[];
+}
+export type DialogFeatureSnapshot = ClosedDialogFeatureSnapshot | OpenDialogFeatureSnapshot;
+export interface DialogFeatureSession {
+    readonly open: () => boolean;
+    readonly disposed: () => boolean;
+    readonly snapshot: () => DialogFeatureSnapshot;
+    readonly select: (request: DialogSelectRequest) => Promise<DialogSelectResult | null>;
+    readonly prompt: (request: DialogPromptRequest) => Promise<string | null>;
+    readonly confirm: (request: DialogConfirmRequest) => Promise<boolean>;
+    readonly handleKey: (event: DialogKeyEvent) => boolean;
+    readonly handlePointer: (event: DialogPointerEvent) => boolean;
+    readonly dismiss: () => boolean;
+    readonly clear: () => void;
+    readonly setBusy: (busy: boolean) => boolean;
+    readonly dispose: () => void;
+}

package/packages/daemon/dist/tui/mirror/features/dialogs/contract.js

@@ -0,0 +1 @@
+export {};

package/packages/daemon/dist/tui/mirror/features/dialogs/feature.d.ts

@@ -0,0 +1,12 @@
+import { RGBA } from "@opentui/core";
+import type { SemanticThemeSnapshot } from "../../theme.ts";
+import type { DialogFeatureSession } from "./contract.ts";
+export { createDialogFeatureSession } from "./session.ts";
+export type * from "./contract.ts";
+export interface DialogFeatureSurfaceProps {
+    readonly session: DialogFeatureSession;
+    readonly theme: SemanticThemeSnapshot;
+    readonly accent?: RGBA | null;
+}
+/** Passive overlay; the application root remains the single input owner. */
+export declare function DialogFeatureSurface(props: DialogFeatureSurfaceProps): import("solid-js").JSX.Element;

package/packages/daemon/dist/tui/mirror/features/dialogs/feature.jsx

@@ -0,0 +1,123 @@
+/* @jsxImportSource @opentui/solid */
+import { RGBA } from "@opentui/core";
+import { For, Show, createMemo } from "solid-js";
+import { confirmFooter, confirmOptions, dialogInnerW, dialogMarker, dialogRowText, promptFooter, selectFooter, wrapText, } from "../../dialog-model.js";
+export { createDialogFeatureSession } from "./session.js";
+/** Passive overlay; the application root remains the single input owner. */
+export function DialogFeatureSurface(props) {
+    const snapshot = createMemo(() => props.session.snapshot());
+    const open = () => snapshot();
+    const innerWidth = () => dialogInnerW(open().geometry.width);
+    const accent = () => props.accent ?? props.theme.roles.text.link;
+    return (<Show when={snapshot().phase === "open"}>
+      <Show when={open().spec.kind === "select"}>
+        <box id="dialog-feature-surface" position="absolute" left={open().geometry.left} top={open().geometry.top} width={open().geometry.width} flexDirection="column" backgroundColor={props.theme.roles.surfaces.command} border borderColor={accent()} paddingLeft={1} paddingRight={1}>
+          <text fg={accent()} attributes={1}>
+            {open().spec.title.slice(0, innerWidth()).padEnd(innerWidth())}
+          </text>
+          <Show when={open().spec.filterable !== false}>
+            <box flexDirection="row">
+              <text fg={accent()} attributes={1}>
+                {"▸ "}
+              </text>
+              <text fg={props.theme.roles.text.primary}>{`${open().state.query}▏`}</text>
+            </box>
+          </Show>
+          <text fg={props.theme.roles.borders.subtle}>{"─".repeat(innerWidth())}</text>
+          <For each={open().visibleItems}>
+            {(item, index) => {
+            const absolute = () => open().state.top + index();
+            const selected = () => absolute() === open().state.sel;
+            const armed = () => absolute() === open().state.armed;
+            const body = () => dialogRowText(item, {
+                selected: selected(),
+                armed: armed(),
+                innerW: item.swatch ? innerWidth() - 2 : innerWidth(),
+            }).slice(2);
+            const markerColor = () => item.current
+                ? accent()
+                : selected()
+                    ? props.theme.roles.selection.selectionText
+                    : props.theme.roles.text.secondary;
+            const bodyColor = () => armed()
+                ? props.theme.roles.statusTone.danger
+                : selected()
+                    ? props.theme.roles.selection.selectionText
+                    : props.theme.roles.text.secondary;
+            return (<box height={1} flexDirection="row" backgroundColor={selected() || armed()
+                    ? props.theme.roles.selection.selection
+                    : props.theme.roles.surfaces.command}>
+                  <text fg={markerColor()}>{dialogMarker(item, selected())}</text>
+                  <Show when={item.swatch}>
+                    <text fg={RGBA.fromInts(item.swatch[0], item.swatch[1], item.swatch[2], 255)}>
+                      {"● "}
+                    </text>
+                  </Show>
+                  <text fg={bodyColor()}>{body()}</text>
+                </box>);
+        }}
+          </For>
+          <Show when={open().visibleItems.length === 0}>
+            <text fg={props.theme.roles.text.muted}>{"  no matches"}</text>
+          </Show>
+          <text fg={props.theme.roles.text.muted}>
+            {selectFooter(open().spec).slice(0, innerWidth())}
+          </text>
+        </box>
+      </Show>
+
+      <Show when={open().spec.kind === "prompt"}>
+        <box id="dialog-feature-surface" position="absolute" left={open().geometry.left} top={open().geometry.top} width={open().geometry.width} flexDirection="column" backgroundColor={props.theme.roles.surfaces.command} border borderColor={accent()} paddingLeft={1} paddingRight={1}>
+          <text fg={accent()} attributes={1}>
+            {open().spec.title.slice(0, innerWidth()).padEnd(innerWidth())}
+          </text>
+          <text fg={props.theme.roles.borders.subtle}>{"─".repeat(innerWidth())}</text>
+          <box flexDirection="row">
+            <text fg={accent()} attributes={1}>
+              {"▸ "}
+            </text>
+            <Show when={open().state.input.length === 0 && open().spec.placeholder} fallback={<text fg={props.theme.roles.text.primary}>{`${open().state.input}▏`}</text>}>
+              <text fg={props.theme.roles.text.primary}>{"▏"}</text>
+              <text fg={props.theme.roles.text.muted}>
+                {` ${open().spec.placeholder}`}
+              </text>
+            </Show>
+          </box>
+          <text fg={promptFooter(open().spec, open().state).error
+            ? props.theme.roles.statusTone.danger
+            : props.theme.roles.text.muted}>
+            {promptFooter(open().spec, open().state).text.slice(0, innerWidth())}
+          </text>
+        </box>
+      </Show>
+
+      <Show when={open().spec.kind === "confirm"}>
+        <box id="dialog-feature-surface" position="absolute" left={open().geometry.left} top={open().geometry.top} width={open().geometry.width} flexDirection="column" backgroundColor={props.theme.roles.surfaces.command} border borderColor={accent()} paddingLeft={1} paddingRight={1}>
+          <text fg={accent()} attributes={1}>
+            {open().spec.title.slice(0, innerWidth()).padEnd(innerWidth())}
+          </text>
+          <text fg={props.theme.roles.borders.subtle}>{"─".repeat(innerWidth())}</text>
+          <For each={open().spec.body
+            ? wrapText(open().spec.body, innerWidth())
+            : []}>
+            {(line) => <text fg={props.theme.roles.text.secondary}>{line || " "}</text>}
+          </For>
+          <For each={confirmOptions(open().spec)}>
+            {(label, index) => {
+            const selected = () => open().state.sel === index();
+            return (<box height={1} backgroundColor={selected()
+                    ? props.theme.roles.selection.selection
+                    : props.theme.roles.surfaces.command}>
+                  <text fg={selected()
+                    ? props.theme.roles.selection.selectionText
+                    : props.theme.roles.text.secondary}>
+                    {`${selected() ? "› " : "  "}${label}`.slice(0, innerWidth())}
+                  </text>
+                </box>);
+        }}
+          </For>
+          <text fg={props.theme.roles.text.muted}>{confirmFooter()}</text>
+        </box>
+      </Show>
+    </Show>);
+}

package/packages/daemon/dist/tui/mirror/features/dialogs/session.d.ts

@@ -0,0 +1,9 @@
+import type { DialogFeatureHost, DialogFeatureSession } from "./contract.ts";
+/**
+ * Per-application dialog authority.
+ *
+ * Unlike the historical module singleton, every application root gets a
+ * private stack and explicit Solid owner. Disposing the session synchronously
+ * cancels all pending one-shots before retiring its reactive owner.
+ */
+export declare function createDialogFeatureSession(host: DialogFeatureHost): DialogFeatureSession;