tmux-ide 2.7.0 → 2.9.0-beta.5

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-palette-owner.d.ts

@@ -0,0 +1,65 @@
+import type { ResolvedThemeMode } from "../../../lib/theme-mode.ts";
+export type ApplicationTerminalPaletteAvailability = "pending" | "available" | "unavailable";
+export interface ApplicationTerminalPaletteColors {
+    readonly palette: readonly (string | null)[];
+    readonly defaultForeground: string | null;
+    readonly defaultBackground: string | null;
+    readonly cursorColor: string | null;
+    readonly mouseForeground: string | null;
+    readonly mouseBackground: string | null;
+    readonly tekForeground: string | null;
+    readonly tekBackground: string | null;
+    readonly highlightBackground: string | null;
+    readonly highlightForeground: string | null;
+}
+export interface ApplicationTerminalPaletteSnapshot extends ApplicationTerminalPaletteColors {
+    readonly availability: ApplicationTerminalPaletteAvailability;
+    readonly detectedMode: ResolvedThemeMode;
+    /** Renderer capability data projected to immutable, renderer-neutral values. */
+    readonly capabilities: Readonly<Record<string, unknown>> | null;
+    readonly signature: string;
+}
+interface PaletteQueryResult {
+    readonly palette?: readonly (string | null)[];
+    readonly defaultForeground?: string | null;
+    readonly defaultBackground?: string | null;
+    readonly cursorColor?: string | null;
+    readonly mouseForeground?: string | null;
+    readonly mouseBackground?: string | null;
+    readonly tekForeground?: string | null;
+    readonly tekBackground?: string | null;
+    readonly highlightBackground?: string | null;
+    readonly highlightForeground?: string | null;
+}
+export interface ApplicationTerminalPaletteRenderer {
+    readonly themeMode: ResolvedThemeMode | null;
+    readonly capabilities: unknown;
+    clearPaletteCache(): void;
+    getPalette(options: {
+        size: number;
+        timeout: number;
+    }): Promise<PaletteQueryResult>;
+    on(event: "theme_mode", listener: (mode: ResolvedThemeMode) => void): unknown;
+    off(event: "theme_mode", listener: (mode: ResolvedThemeMode) => void): unknown;
+    on(event: "capabilities", listener: (capabilities: unknown) => void): unknown;
+    off(event: "capabilities", listener: (capabilities: unknown) => void): unknown;
+    prependInputHandler(handler: (sequence: string) => boolean): void;
+    removeInputHandler(handler: (sequence: string) => boolean): void;
+}
+export interface ApplicationTerminalPaletteOwnerOptions {
+    /** Palette requests must settle without holding application readiness forever. */
+    readonly queryTimeoutMs?: number;
+    /** Theme-mode notifications only refresh host colors while system mode is unlocked. */
+    readonly isThemeModeUnlocked?: () => boolean;
+    readonly setTimeout?: typeof globalThis.setTimeout;
+    readonly clearTimeout?: typeof globalThis.clearTimeout;
+}
+export interface ApplicationTerminalPaletteOwner {
+    readonly ready: Promise<void>;
+    getSnapshot(): ApplicationTerminalPaletteSnapshot;
+    subscribe(listener: () => void): () => void;
+    refresh(): Promise<void>;
+    dispose(): void;
+}
+export declare function createApplicationTerminalPaletteOwner(renderer: ApplicationTerminalPaletteRenderer, options?: ApplicationTerminalPaletteOwnerOptions): ApplicationTerminalPaletteOwner;
+export {};

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-palette-owner.js

@@ -0,0 +1,217 @@
+const PALETTE_SIZE = 16;
+const QUERY_TIMEOUT_MS = 1_000;
+const FOLLOW_UP_DELAYS_MS = [250, 1_000];
+const EMPTY_PALETTE = Object.freeze(Array(PALETTE_SIZE).fill(null));
+function normalizeColor(value) {
+    if (typeof value !== "string")
+        return null;
+    const normalized = value.trim().toLowerCase();
+    return normalized.length > 0 ? normalized : null;
+}
+function normalizePalette(values) {
+    const palette = Array(PALETTE_SIZE).fill(null);
+    if (Array.isArray(values))
+        for (let index = 0; index < PALETTE_SIZE; index += 1)
+            palette[index] = normalizeColor(values[index]);
+    return Object.freeze(palette);
+}
+function immutableValue(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    if (Array.isArray(value))
+        return Object.freeze(value.map(immutableValue));
+    const record = value;
+    const clone = {};
+    for (const key of Object.keys(record).sort())
+        clone[key] = immutableValue(record[key]);
+    return Object.freeze(clone);
+}
+function immutableCapabilities(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return immutableValue(value);
+}
+function detectedMode(background, fallback) {
+    if (!background)
+        return fallback;
+    const match = /^#([\da-f]{3}|[\da-f]{6})$/iu.exec(background);
+    if (!match)
+        return fallback;
+    const hex = match[1];
+    const expanded = hex.length === 3 ? `${hex[0]}${hex[0]}${hex[1]}${hex[1]}${hex[2]}${hex[2]}` : hex;
+    const red = Number.parseInt(expanded.slice(0, 2), 16) / 255;
+    const green = Number.parseInt(expanded.slice(2, 4), 16) / 255;
+    const blue = Number.parseInt(expanded.slice(4, 6), 16) / 255;
+    return 0.299 * red + 0.587 * green + 0.114 * blue > 0.5 ? "light" : "dark";
+}
+function snapshotSignature(input) {
+    return JSON.stringify(input);
+}
+function freezeSnapshot(input) {
+    return Object.freeze({ ...input, signature: snapshotSignature(input) });
+}
+function fallbackSnapshot(availability, mode, capabilities) {
+    return freezeSnapshot({
+        availability,
+        palette: EMPTY_PALETTE,
+        defaultForeground: null,
+        defaultBackground: null,
+        cursorColor: null,
+        mouseForeground: null,
+        mouseBackground: null,
+        tekForeground: null,
+        tekBackground: null,
+        highlightBackground: null,
+        highlightForeground: null,
+        detectedMode: mode,
+        capabilities,
+    });
+}
+function availableSnapshot(result, fallbackMode, capabilities) {
+    const defaultBackground = normalizeColor(result.defaultBackground);
+    return freezeSnapshot({
+        availability: "available",
+        palette: normalizePalette(result.palette),
+        defaultForeground: normalizeColor(result.defaultForeground),
+        defaultBackground,
+        cursorColor: normalizeColor(result.cursorColor),
+        mouseForeground: normalizeColor(result.mouseForeground),
+        mouseBackground: normalizeColor(result.mouseBackground),
+        tekForeground: normalizeColor(result.tekForeground),
+        tekBackground: normalizeColor(result.tekBackground),
+        highlightBackground: normalizeColor(result.highlightBackground),
+        highlightForeground: normalizeColor(result.highlightForeground),
+        detectedMode: detectedMode(defaultBackground, fallbackMode),
+        capabilities,
+    });
+}
+function hasReportedColor(result) {
+    return (normalizeColor(result.defaultForeground) !== null ||
+        normalizeColor(result.defaultBackground) !== null ||
+        (Array.isArray(result.palette) &&
+            result.palette.some((color) => normalizeColor(color) !== null)));
+}
+export function createApplicationTerminalPaletteOwner(renderer, options = {}) {
+    const queryTimeoutMs = Math.max(1, options.queryTimeoutMs ?? QUERY_TIMEOUT_MS);
+    const scheduleTimeout = options.setTimeout ?? globalThis.setTimeout;
+    const cancelTimeout = options.clearTimeout ?? globalThis.clearTimeout;
+    const isThemeModeUnlocked = options.isThemeModeUnlocked ?? (() => true);
+    const listeners = new Set();
+    const timers = new Set();
+    let capabilities = immutableCapabilities(renderer.capabilities);
+    let snapshot = fallbackSnapshot("pending", renderer.themeMode ?? "dark", capabilities);
+    let lastValid = null;
+    let active = null;
+    let queued = false;
+    let disposed = false;
+    const publish = (next) => {
+        if (disposed || next.signature === snapshot.signature)
+            return;
+        snapshot = next;
+        for (const listener of listeners)
+            listener();
+    };
+    const refresh = () => {
+        if (disposed)
+            return Promise.resolve();
+        if (active) {
+            queued = true;
+            return active;
+        }
+        renderer.clearPaletteCache();
+        const generation = Promise.resolve()
+            .then(() => renderer.getPalette({ size: PALETTE_SIZE, timeout: queryTimeoutMs }))
+            .then((result) => {
+            if (disposed)
+                return;
+            if (!hasReportedColor(result)) {
+                if (!lastValid)
+                    publish(fallbackSnapshot("unavailable", renderer.themeMode ?? "dark", capabilities));
+                return;
+            }
+            const next = availableSnapshot(result, renderer.themeMode ?? "dark", capabilities);
+            lastValid = next;
+            publish(next);
+        })
+            .catch(() => {
+            if (disposed || lastValid)
+                return;
+            publish(fallbackSnapshot("unavailable", renderer.themeMode ?? "dark", capabilities));
+        })
+            .finally(() => {
+            if (active !== generation)
+                return;
+            active = null;
+            if (disposed || !queued)
+                return;
+            queued = false;
+            void refresh();
+        });
+        active = generation;
+        return generation;
+    };
+    const scheduleFollowUps = () => {
+        if (disposed)
+            return;
+        void refresh();
+        for (const delay of FOLLOW_UP_DELAYS_MS) {
+            const timer = scheduleTimeout(() => {
+                timers.delete(timer);
+                if (!disposed)
+                    void refresh();
+            }, delay);
+            timers.add(timer);
+        }
+    };
+    const onThemeMode = () => {
+        if (isThemeModeUnlocked())
+            scheduleFollowUps();
+    };
+    const onCapabilities = (next) => {
+        capabilities = immutableCapabilities(next);
+        if (lastValid) {
+            const valid = { ...lastValid, capabilities };
+            Reflect.deleteProperty(valid, "signature");
+            lastValid = freezeSnapshot(valid);
+            publish(lastValid);
+            return;
+        }
+        publish(fallbackSnapshot(snapshot.availability === "pending" ? "pending" : "unavailable", renderer.themeMode ?? "dark", capabilities));
+    };
+    const onThemeNotification = (sequence) => {
+        if (sequence !== "\x1b[?997;1n" && sequence !== "\x1b[?997;2n")
+            return false;
+        if (isThemeModeUnlocked())
+            scheduleFollowUps();
+        return false;
+    };
+    renderer.on("theme_mode", onThemeMode);
+    renderer.on("capabilities", onCapabilities);
+    renderer.prependInputHandler(onThemeNotification);
+    const ready = refresh();
+    return {
+        ready,
+        getSnapshot: () => snapshot,
+        subscribe(listener) {
+            if (disposed)
+                return () => undefined;
+            listeners.add(listener);
+            return () => listeners.delete(listener);
+        },
+        refresh,
+        dispose() {
+            if (disposed)
+                return;
+            disposed = true;
+            queued = false;
+            renderer.off("theme_mode", onThemeMode);
+            renderer.off("capabilities", onCapabilities);
+            renderer.removeInputHandler(onThemeNotification);
+            for (const timer of timers)
+                cancelTimeout(timer);
+            timers.clear();
+            listeners.clear();
+            active = null;
+        },
+    };
+}

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-paste.d.ts

@@ -0,0 +1,4 @@
+import type { ApplicationTerminalInteractionController } from "./application-terminal-interaction-controller.ts";
+import { terminalInputForOpenTuiKey } from "./terminal-input-adapter.ts";
+export declare function sendApplicationTerminalKey(interaction: ApplicationTerminalInteractionController, event: Parameters<typeof terminalInputForOpenTuiKey>[0], captureOrigin: boolean): boolean;
+export declare function sendApplicationTerminalPaste(interaction: ApplicationTerminalInteractionController, bytes: Uint8Array, captureOrigin: boolean): void;

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-paste.js

@@ -0,0 +1,22 @@
+import { terminalInputsForPaste } from "./terminal-input-adapter.js";
+import { terminalInputForOpenTuiKey } from "./terminal-input-adapter.js";
+export function sendApplicationTerminalKey(interaction, event, captureOrigin) {
+    const input = terminalInputForOpenTuiKey(event);
+    if (!input)
+        return false;
+    const parserOrigin = captureOrigin
+        ? { origin: "keyboard", payload: Buffer.from(input.data, "utf8") }
+        : undefined;
+    void interaction.sendInput(input, parserOrigin);
+    return true;
+}
+export function sendApplicationTerminalPaste(interaction, bytes, captureOrigin) {
+    const text = Buffer.from(bytes).toString("utf8");
+    const inputs = terminalInputsForPaste(text);
+    for (let index = 0; index < inputs.length; index += 1) {
+        const parserOrigin = index === 0 && captureOrigin
+            ? { origin: "bracketed-paste", payload: Buffer.from(bytes) }
+            : undefined;
+        void interaction.sendInput(inputs[index], parserOrigin);
+    }
+}

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-renderer-sources.d.ts

@@ -0,0 +1,15 @@
+import { type Accessor } from "solid-js";
+import type { OpenTuiGenerationHostSnapshot } from "./open-tui-generation-host.ts";
+export declare function createApplicationTerminalRendererSources(generation: Accessor<OpenTuiGenerationHostSnapshot | null>): Readonly<{
+    terminalRendererSource: Accessor<Readonly<{
+        adapter: import("./terminal-fast-lane-renderer-adapter.ts").TerminalFastLaneRendererAdapter;
+        rendererEpoch: number;
+    }> | null>;
+    terminalGestureRuntime: Accessor<import("./terminal-selection.ts").TerminalGestureRuntimeIdentity | null>;
+    focusRendererSource: Accessor<Readonly<{
+        adapter: import("./terminal-fast-lane-renderer-adapter.ts").TerminalFastLaneRendererAdapter;
+        rendererEpoch: number;
+        daemonGeneration: string;
+        clientGeneration: number;
+    }> | null>;
+}>;

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-renderer-sources.js

@@ -0,0 +1,31 @@
+import { createMemo } from "solid-js";
+import { terminalGestureRuntimeIdentity } from "./application-terminal-selection-owner.js";
+export function createApplicationTerminalRendererSources(generation) {
+    const terminalRendererSource = createMemo(() => {
+        const active = generation();
+        return active?.adapter && (active.status === "live" || active.status === "rebinding")
+            ? Object.freeze({ adapter: active.adapter, rendererEpoch: active.rendererEpoch })
+            : null;
+    });
+    const terminalGestureRuntime = createMemo(() => terminalGestureRuntimeIdentity(generation()));
+    const focusRendererSource = createMemo(() => {
+        const active = generation();
+        if (!active?.adapter || active.status !== "live" || !active.daemonGeneration)
+            return null;
+        try {
+            const clientGeneration = active.client?.getSnapshot().generation;
+            if (!Number.isSafeInteger(clientGeneration))
+                return null;
+            return Object.freeze({
+                adapter: active.adapter,
+                rendererEpoch: active.rendererEpoch,
+                daemonGeneration: active.daemonGeneration,
+                clientGeneration: clientGeneration,
+            });
+        }
+        catch {
+            return null;
+        }
+    });
+    return Object.freeze({ terminalRendererSource, terminalGestureRuntime, focusRendererSource });
+}

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-selection-owner.d.ts

@@ -0,0 +1,47 @@
+import type { OpenTuiGenerationHostSnapshot } from "./open-tui-generation-host.ts";
+import type { TerminalGestureRuntimeIdentity } from "./terminal-selection.ts";
+import type { ApplicationTerminalInteractionController } from "./application-terminal-interaction-controller.ts";
+import type { ApplicationTerminalWorkspaceProps } from "./application-terminal-workspace.tsx";
+export interface TerminalSelectionCopyEvidence {
+    readonly semanticPaneId: string;
+    readonly bytes: number;
+    readonly start: Readonly<{
+        row: number;
+        col: number;
+    }>;
+    readonly end: Readonly<{
+        row: number;
+        col: number;
+    }>;
+}
+export declare function terminalGestureRuntimeIdentity(active: OpenTuiGenerationHostSnapshot | null): TerminalGestureRuntimeIdentity | null;
+export declare function settleApplicationClipboardReadiness(readiness: Promise<boolean>, required: boolean, resolve: () => void, reject: (error: Error & {
+    code?: string;
+    boundary?: string;
+}) => void): void;
+export declare function applicationClipboardReadiness(configure: () => Promise<boolean>, required: boolean): Promise<void>;
+export declare function routeApplicationTerminalPointerInput(interaction: ApplicationTerminalInteractionController, paneId: string, input: Parameters<NonNullable<ApplicationTerminalWorkspaceProps["onTerminalInput"]>>[1]): void;
+export declare function applicationMousePointerIngressCapability<T>(diagnosticsEnabled: boolean, ingress: T): T | undefined;
+export declare function createApplicationTerminalSelectionOwner(options: {
+    readonly copyText: (text: string) => boolean;
+    readonly diagnosticsEnabled: boolean;
+    readonly generation: () => OpenTuiGenerationHostSnapshot | null;
+}): Readonly<{
+    beginPointerIngress(input: {
+        readonly action: "down" | "drag" | "move" | "up" | "wheel-up" | "wheel-down";
+        readonly x: number;
+        readonly y: number;
+        readonly atMicros: number;
+    }): Readonly<{
+        gestureId: string;
+        action: "move" | "down" | "drag" | "up" | "wheel-up" | "wheel-down";
+        x: number;
+        y: number;
+        atMicros: number;
+    }> | null;
+    copy(text: string, evidence: TerminalSelectionCopyEvidence): boolean;
+    copyCurrent: () => boolean;
+    handleKey: (name: string) => boolean;
+    registerCopy(copy: (() => boolean) | null): void;
+    registerKey(next: ((name: string) => boolean) | null): void;
+}>;

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-selection-owner.js

@@ -0,0 +1,161 @@
+import { randomUUID } from "node:crypto";
+import { tuiPerfCriticalMark, tuiPerfDiagnostics } from "./application-performance-log.js";
+export function terminalGestureRuntimeIdentity(active) {
+    if (active?.status !== "live" ||
+        !active.daemonGeneration ||
+        !active.connection ||
+        !active.client ||
+        !active.adapter)
+        return null;
+    try {
+        const clientGeneration = active.client.getSnapshot().generation;
+        if (!Number.isSafeInteger(clientGeneration))
+            return null;
+        return Object.freeze({
+            daemonGeneration: active.daemonGeneration,
+            clientGeneration,
+            connection: active.connection,
+            client: active.client,
+            adapter: active.adapter,
+            rendererEpoch: active.rendererEpoch,
+        });
+    }
+    catch {
+        return null;
+    }
+}
+export function settleApplicationClipboardReadiness(readiness, required, resolve, reject) {
+    void readiness.then((configured) => {
+        if (!required || configured) {
+            resolve();
+            return;
+        }
+        const error = new Error("tmux clipboard policy was not ready");
+        error.code = "clipboard_not_ready";
+        error.boundary = "clipboard-ready";
+        reject(error);
+    }, (reason) => {
+        const error = new Error("tmux clipboard policy failed", { cause: reason });
+        error.code = "clipboard_not_ready";
+        error.boundary = "clipboard-ready";
+        reject(error);
+    });
+}
+export function applicationClipboardReadiness(configure, required) {
+    if (!required)
+        return Promise.resolve();
+    return new Promise((resolve, reject) => {
+        let readiness;
+        try {
+            readiness = configure();
+        }
+        catch (error) {
+            readiness = Promise.reject(error);
+        }
+        settleApplicationClipboardReadiness(readiness, true, resolve, reject);
+    });
+}
+export function routeApplicationTerminalPointerInput(interaction, paneId, input) {
+    const routed = interaction.sendInputToPane(paneId, { kind: "text", data: input.data }, input.kind === "application-mouse" && input.ingress
+        ? {
+            origin: "application-mouse",
+            payload: Buffer.from(input.data),
+            ingressAtMicros: input.ingress.atMicros,
+            gestureId: input.ingress.gestureId,
+            pointerAction: input.action,
+            pointerColumn: input.column,
+            pointerRow: input.row,
+            pointerButton: input.button,
+        }
+        : undefined);
+    if (input.kind !== "application-mouse" || !input.ingress) {
+        void routed;
+        return;
+    }
+    const emit = (sent, outcome) => {
+        try {
+            tuiPerfCriticalMark(`terminal-application-mouse-route:${input.ingress.gestureId}:${input.action}`, "terminal-application-mouse-route", {
+                semanticPaneId: paneId,
+                gestureId: input.ingress.gestureId,
+                action: input.action,
+                column: input.column,
+                row: input.row,
+                button: input.button,
+                sent,
+                outcome,
+                writerHealth: tuiPerfDiagnostics(),
+            });
+        }
+        catch {
+            // Route diagnostics never own the product input promise.
+        }
+    };
+    void routed.then((sent) => emit(sent, sent ? "sent" : "refused"), () => emit(false, "error"));
+}
+export function applicationMousePointerIngressCapability(diagnosticsEnabled, ingress) {
+    return diagnosticsEnabled ? ingress : undefined;
+}
+export function createApplicationTerminalSelectionOwner(options) {
+    let copySelection = null;
+    let handleKey = null;
+    let copyOrdinal = 0;
+    let pointerGestureId = null;
+    return Object.freeze({
+        beginPointerIngress(input) {
+            if (!options.diagnosticsEnabled)
+                return null;
+            try {
+                if (!Number.isSafeInteger(input.atMicros) || input.atMicros < 0)
+                    return null;
+                if (input.action === "down" || pointerGestureId === null)
+                    pointerGestureId = randomUUID();
+                const ingress = Object.freeze({
+                    gestureId: pointerGestureId,
+                    action: input.action,
+                    x: input.x,
+                    y: input.y,
+                    atMicros: input.atMicros,
+                });
+                if (input.action === "up")
+                    pointerGestureId = null;
+                return ingress;
+            }
+            catch {
+                pointerGestureId = null;
+                return null;
+            }
+        },
+        copy(text, evidence) {
+            const copied = options.copyText(text);
+            if (!options.diagnosticsEnabled)
+                return copied;
+            try {
+                const ordinal = copyOrdinal++;
+                const active = options.generation();
+                const identity = active?.adapter?.paneCanonicalIdentity(evidence.semanticPaneId);
+                tuiPerfCriticalMark(`terminal-selection-copy:${active?.rendererEpoch ?? 0}:${identity?.revision ?? -1}:${ordinal}`, "terminal-selection-copy", {
+                    ...evidence,
+                    copyOrdinal: ordinal,
+                    copied,
+                    daemonGeneration: active?.daemonGeneration ?? null,
+                    clientGeneration: active?.client?.getSnapshot().generation ?? null,
+                    rendererEpoch: active?.rendererEpoch ?? null,
+                    canonicalIdentity: identity,
+                    writerHealth: tuiPerfDiagnostics(),
+                });
+            }
+            catch {
+                // Clipboard diagnostics never own a successful OSC52 write.
+            }
+            return copied;
+        },
+        copyCurrent: () => copySelection?.() === true,
+        handleKey: (name) => handleKey?.(name) === true,
+        registerCopy(copy) {
+            copySelection = copy;
+        },
+        registerKey(next) {
+            handleKey = next;
+        },
+    });
+}

package/packages/daemon/dist/tui/mirror/runtime/application-terminal-workspace-policy.d.ts

@@ -0,0 +1,44 @@
+import type { AgentActivity } from "@tmux-ide/contracts";
+import type { OpenTuiWorkspaceLayoutSnapshot } from "../open-tui-workspace-runtime-port.ts";
+import { type ResizeGuideRect } from "../resize-model.ts";
+import type { OpenTuiPaneFrame } from "./terminal-layout-projection.ts";
+export interface ApplicationTerminalAgentIndicator {
+    readonly name: string;
+    readonly activity: AgentActivity;
+    readonly attention: boolean;
+}
+export interface ApplicationPaneResizePreview {
+    readonly semanticPaneId: string;
+    readonly axis: "cols" | "rows";
+    readonly cells: number;
+    readonly guide: ResizeGuideRect;
+    /** Exact renderer-global guide cells after nested shell/canvas projection. */
+    readonly globalGuide?: ResizeGuideRect;
+    readonly pointerIngress?: {
+        readonly gestureId: string;
+        readonly traceId: string;
+        readonly action: "down" | "drag" | "up";
+        readonly x: number;
+        readonly y: number;
+        readonly atMicros: number;
+    };
+}
+export interface ApplicationPaneSeparator {
+    readonly axis: "x" | "y";
+    readonly position: number;
+    readonly start: number;
+    readonly end: number;
+    readonly paneId: string;
+    readonly initialCells: number;
+    readonly siblingCells: number;
+}
+export declare function terminalAgentStatusLabel(activity: AgentActivity): string;
+export declare function terminalPaneChromeLabel(paneId: string, focused: boolean, width: number, indicator?: ApplicationTerminalAgentIndicator, displayName?: string | null, displayNameSource?: "manual" | "agent" | "process" | "title" | "generated" | null): string;
+export declare function terminalPaneDisplayTitle(paneId: string, indicator?: ApplicationTerminalAgentIndicator, displayName?: string | null, displayNameSource?: "manual" | "agent" | "process" | "title" | "generated" | null): string;
+export declare function terminalWindowTitle(window: OpenTuiWorkspaceLayoutSnapshot["windows"][number]): string;
+export declare function terminalWindowPane(window: OpenTuiWorkspaceLayoutSnapshot["windows"][number]): string | null;
+export declare function retainedTerminalWindowKey(window: OpenTuiWorkspaceLayoutSnapshot["windows"][number]): string | null;
+export declare function terminalWindowAgentIndicator(window: OpenTuiWorkspaceLayoutSnapshot["windows"][number], indicators: ReadonlyMap<string, ApplicationTerminalAgentIndicator>): Pick<ApplicationTerminalAgentIndicator, "activity" | "attention"> | undefined;
+export declare function terminalPaneSeparatorAt(frames: readonly OpenTuiPaneFrame[], paneBorderStatus: "top" | "bottom" | "off", x: number, y: number): ApplicationPaneSeparator | null;
+export declare function terminalPaneSeparators(frames: readonly OpenTuiPaneFrame[], paneBorderStatus: "top" | "bottom" | "off"): readonly ApplicationPaneSeparator[];
+export declare function terminalPaneResizePreview(separator: ApplicationPaneSeparator, pointer: number, origin: number): ApplicationPaneResizePreview;