@timurproko/a1 0.2.7-dev.1252 → 0.2.7-dev.1264

package/dist/features/owned-ui/settings-edits.d.ts

@@ -0,0 +1,31 @@
+import type { OwnedUiSettingValue, OwnedUiSettingsChangeOutcome, OwnedUiSettingsEntry, OwnedSettingsManager } from "../../ui/settings/index.js";
+type SettingsRecord = Record<string, boolean | string>;
+/** The structured dialog an undo may need to roll back in place; null when none is open. */
+export interface OpenStructuredRecord {
+    readonly entry: OwnedUiSettingsEntry;
+    readonly record: SettingsRecord;
+}
+/**
+ * The settings screen's edits: values shown ahead of the source, and an undo history ordered by edit
+ * sequence. Undo requests drain one at a time so each restores against the result of the one before.
+ */
+export declare class SettingsEdits {
+    #private;
+    constructor(session: Pick<OwnedSettingsManager, "change" | "changeStructured">, openStructured: () => OpenStructuredRecord | null);
+    /** The value a row shows: a pending edit, or the source's value. */
+    shown(entry: OwnedUiSettingsEntry): OwnedUiSettingValue | null;
+    apply(entry: OwnedUiSettingsEntry, value: OwnedUiSettingValue): void;
+    /** Saves a structured dialog's record; `rollback` runs when the change fails. */
+    saveStructured(entry: OwnedUiSettingsEntry, previous: Readonly<SettingsRecord>, forward: Readonly<SettingsRecord>, rollback: () => void): void;
+    undo(): void;
+    open(): void;
+    /** Drops the history and queued requests; late results no longer record undo steps. */
+    close(): void;
+}
+/** The record the engine stores: a choice part at its fallback is unset, so the engine's default applies. */
+export declare function structuredValue(entry: OwnedUiSettingsEntry, record: Readonly<SettingsRecord>): SettingsRecord;
+export declare function sameRecord(left: Readonly<SettingsRecord>, right: Readonly<SettingsRecord>): boolean;
+export declare function replaceRecord(target: SettingsRecord, source: Readonly<SettingsRecord>): void;
+/** Why a change did not take effect, or null when it did. */
+export declare function changeFailure(outcome: OwnedUiSettingsChangeOutcome): string | null;
+export {};

package/dist/features/owned-ui/settings-edits.js

@@ -0,0 +1,139 @@
+/**
+ * The settings screen's edits: values shown ahead of the source, and an undo history ordered by edit
+ * sequence. Undo requests drain one at a time so each restores against the result of the one before.
+ */
+export class SettingsEdits {
+    #session;
+    #openStructured;
+    #pending = new Map();
+    #history = [];
+    #sequence = 0;
+    #requests = 0;
+    #active = false;
+    #closed = false;
+    constructor(session, openStructured) {
+        this.#session = session;
+        this.#openStructured = openStructured;
+    }
+    /** The value a row shows: a pending edit, or the source's value. */
+    shown(entry) {
+        return this.#pending.get(pendingKey(entry)) ?? entry.value;
+    }
+    apply(entry, value) {
+        const key = pendingKey(entry);
+        const previous = this.shown(entry);
+        const sequence = ++this.#sequence;
+        // Invariant: shown immediately so the row never lags a keypress, and so the next press
+        // steps from here rather than from a value the source has not caught up to.
+        this.#pending.set(key, value);
+        void this.#session.change(entry.backend, entry.id, value).then(outcome => {
+            const failed = changeFailure(outcome) !== null;
+            if (!failed && previous !== null && previous !== value)
+                this.#record({ kind: "scalar", sequence, entry, previous });
+            // Concurrency: a later press may have moved on; only the last request clears itself.
+            if (this.#pending.get(key) === value)
+                this.#pending.delete(key);
+        });
+    }
+    /** Saves a structured dialog's record; `rollback` runs when the change fails. */
+    saveStructured(entry, previous, forward, rollback) {
+        const sequence = ++this.#sequence;
+        void this.#session.changeStructured(entry.backend, entry.id, structuredValue(entry, forward)).then(outcome => {
+            if (changeFailure(outcome) === null)
+                this.#record({ kind: "structured", sequence, entry, previous, forward });
+            else
+                rollback();
+        });
+    }
+    undo() {
+        this.#requests++;
+        this.#drain();
+    }
+    open() { this.#closed = false; }
+    /** Drops the history and queued requests; late results no longer record undo steps. */
+    close() {
+        this.#closed = true;
+        this.#history.length = 0;
+        this.#requests = 0;
+    }
+    #record(record) {
+        if (this.#closed)
+            return;
+        const after = this.#history.findIndex(candidate => candidate.sequence > record.sequence);
+        if (after < 0)
+            this.#history.push(record);
+        else
+            this.#history.splice(after, 0, record);
+    }
+    #drain() {
+        if (this.#active || this.#requests === 0)
+            return;
+        const record = this.#history.pop();
+        if (record === undefined) {
+            this.#requests = 0;
+            return;
+        }
+        this.#requests--;
+        this.#active = true;
+        if (record.kind === "scalar") {
+            const key = pendingKey(record.entry);
+            this.#pending.set(key, record.previous);
+            void this.#session.change(record.entry.backend, record.entry.id, record.previous).then(outcome => {
+                if (this.#pending.get(key) === record.previous)
+                    this.#pending.delete(key);
+                this.#finish(record, outcome);
+            });
+            return;
+        }
+        const open = this.#openStructured();
+        const target = open !== null && sameEntry(open.entry, record.entry) ? open : null;
+        if (target !== null)
+            replaceRecord(target.record, record.previous);
+        void this.#session.changeStructured(record.entry.backend, record.entry.id, structuredValue(record.entry, record.previous)).then(outcome => {
+            if (changeFailure(outcome) !== null && target !== null && this.#openStructured() === target && sameRecord(target.record, record.previous)) {
+                replaceRecord(target.record, record.forward);
+            }
+            this.#finish(record, outcome);
+        });
+    }
+    #finish(record, outcome) {
+        if (changeFailure(outcome) !== null)
+            this.#record(record);
+        this.#active = false;
+        this.#drain();
+    }
+}
+function pendingKey(entry) {
+    return `${entry.backend}:${entry.id}`;
+}
+/** The record the engine stores: a choice part at its fallback is unset, so the engine's default applies. */
+export function structuredValue(entry, record) {
+    return Object.fromEntries(Object.entries(record).filter(([key, value]) => {
+        const part = entry.flags.find(candidate => candidate.key === key);
+        return part?.choices === undefined || value !== part.fallback;
+    }));
+}
+export function sameRecord(left, right) {
+    const leftEntries = Object.entries(left);
+    const rightEntries = Object.entries(right);
+    return leftEntries.length === rightEntries.length
+        && leftEntries.every(([key, value]) => right[key] === value);
+}
+export function replaceRecord(target, source) {
+    for (const key of Object.keys(target))
+        delete target[key];
+    Object.assign(target, source);
+}
+/** Why a change did not take effect, or null when it did. */
+export function changeFailure(outcome) {
+    if (outcome.failure !== null)
+        return outcome.failure;
+    if (outcome.status === "failed")
+        return "the effect failed";
+    if (outcome.status === "unavailable")
+        return outcome.limitationReason ?? "the setting is unavailable";
+    return outcome.limitationReason;
+}
+function sameEntry(left, right) {
+    return left.backend === right.backend && left.id === right.id;
+}

package/dist/features/owned-ui/settings-model-dialog.d.ts

@@ -0,0 +1,41 @@
+import type { DialogRow } from "../../ui/components/index.js";
+import { LineInput, type PaneInputResult, type UiTheme } from "../../ui/components/index.js";
+import type { OwnedSettingsManager, OwnedUiSettingsEntry } from "../../ui/settings/index.js";
+/**
+ * A structured setting being edited: its parts, the row in hand, and their values. A part is a
+ * toggle when the declaration offers no choices, and a choice cycle otherwise; a choice part at its
+ * fallback is unset and leaves the record.
+ */
+export interface StructuredEdit {
+    readonly entry: OwnedUiSettingsEntry;
+    readonly flags: readonly string[];
+    readonly modelDialog: "thinking" | "default" | null;
+    /** Searchable flag dialog for owned tab-bar configuration. */
+    readonly filter: LineInput | null;
+    step: "model" | "level";
+    modelKey: string | null;
+    modelIndex: number;
+    index: number;
+    error: string | null;
+    readonly record: Record<string, boolean | string>;
+}
+/** What the model dialog asks of the settings screen that owns it. */
+export interface ModelDialogActions {
+    readonly session: Pick<OwnedSettingsManager, "change">;
+    close(): void;
+    /** Show the dialog again, as after a failed save. */
+    reopen(open: StructuredEdit): void;
+    /** Save a changed record, rolling back if the source refuses it. */
+    save(open: StructuredEdit, previous: Readonly<Record<string, boolean | string>>, forward: Readonly<Record<string, boolean | string>>): void;
+}
+/**
+ * One key in the default-model selector or the two-step thinking-level dialog. `key` is the
+ * named key for `data`; typed text that names no shortcut edits the search.
+ */
+export declare function modelDialogKey(open: StructuredEdit, data: string, key: string, actions: ModelDialogActions): PaneInputResult;
+export declare function modelDialogLines(open: StructuredEdit, width: number, height: number, theme: UiTheme): readonly string[];
+/** The rows a dialog of `maximum` rows shows, centred on `index` where the list allows. */
+export declare function dialogWindow(rows: readonly DialogRow[], index: number, maximum: number): {
+    readonly rows: readonly DialogRow[];
+    readonly index: number;
+};

package/dist/features/owned-ui/settings-model-dialog.js

@@ -0,0 +1,194 @@
+import { DIALOG_BACK_SHORTCUT_HINT, DIALOG_CLOSE_SHORTCUT_HINT } from "../../contracts/presentation/index.js";
+import { LineInput, ShortcutRegistry, assertNoShortcutConflicts, configureDialogChoiceCapacity, configureDialogTextRows, handleLineInputKey, humanizeLabel, renderSteppedDialogPanel, } from "../../ui/components/index.js";
+import { changeFailure, structuredValue } from "./settings-edits.js";
+import { SETTINGS_APP_ID } from "./settings-route.js";
+const MODEL_SCOPE = `${SETTINGS_APP_ID}-models`;
+const MODEL_LEVEL_SCOPE = `${SETTINGS_APP_ID}-model-levels`;
+const MODEL_SHORTCUTS = new ShortcutRegistry();
+MODEL_SHORTCUTS.declare({ key: "edit", scope: MODEL_SCOPE, description: "Search models", section: "Choose", hint: { keys: "Type", does: "search" } }, "edit-filter");
+MODEL_SHORTCUTS.declare({ key: "up", scope: MODEL_SCOPE, description: "Previous model", section: "Choose" }, "previous");
+MODEL_SHORTCUTS.declare({ key: "down", scope: MODEL_SCOPE, description: "Next model", section: "Choose" }, "next");
+MODEL_SHORTCUTS.declare({ key: "enter", scope: MODEL_SCOPE, description: "Select model", section: "Choose", hint: { keys: "Enter", does: "select" } }, "select");
+MODEL_SHORTCUTS.declare({ key: "escape", scope: MODEL_SCOPE, description: "Close selector", section: "Choose", hint: { keys: DIALOG_CLOSE_SHORTCUT_HINT.key, does: DIALOG_CLOSE_SHORTCUT_HINT.action } }, "close");
+MODEL_SHORTCUTS.declare({ key: "up", scope: MODEL_LEVEL_SCOPE, description: "Previous level", section: "Choose", hint: { keys: "↑↓", does: "navigate" } }, "previous");
+MODEL_SHORTCUTS.declare({ key: "down", scope: MODEL_LEVEL_SCOPE, description: "Next level", section: "Choose", hint: { keys: "↑↓", does: "navigate" } }, "next");
+MODEL_SHORTCUTS.declare({ key: "enter", scope: MODEL_LEVEL_SCOPE, description: "Select level", section: "Choose", hint: { keys: "Enter", does: "select" } }, "select");
+MODEL_SHORTCUTS.declare({ key: "escape", scope: MODEL_LEVEL_SCOPE, description: "Return to models", section: "Choose", hint: { keys: DIALOG_BACK_SHORTCUT_HINT.key, does: DIALOG_BACK_SHORTCUT_HINT.action } }, "back");
+assertNoShortcutConflicts(MODEL_SHORTCUTS.assemble());
+/**
+ * One key in the default-model selector or the two-step thinking-level dialog. `key` is the
+ * named key for `data`; typed text that names no shortcut edits the search.
+ */
+export function modelDialogKey(open, data, key, actions) {
+    if (open.modelDialog === "default" || open.step === "model") {
+        const flags = filteredModelFlags(open);
+        const action = MODEL_SHORTCUTS.resolve(key, MODEL_SCOPE) ?? "edit-filter";
+        if (action === "close") {
+            actions.close();
+            return { consumed: true };
+        }
+        if (action === "previous" || action === "next") {
+            open.index = Math.min(Math.max(0, flags.length - 1), Math.max(0, open.index + (action === "next" ? 1 : -1)));
+            return { consumed: true };
+        }
+        if (action === "select") {
+            const selected = flags[open.index];
+            if (selected === undefined)
+                return { consumed: true, render: false };
+            if (open.modelDialog === "default")
+                selectDefaultModel(open, selected.key, actions);
+            else {
+                open.modelIndex = open.index;
+                open.modelKey = selected.key;
+                open.step = "level";
+                const options = modelLevelOptions(open, selected);
+                const current = structuredValue(open.entry, open.record)[selected.key];
+                open.index = Math.max(0, options.findIndex(option => option.value === current));
+            }
+            return { consumed: true };
+        }
+        if (open.filter === null)
+            return { consumed: true, render: false };
+        handleLineInputKey(open.filter, data);
+        open.index = 0;
+        return { consumed: true };
+    }
+    const selected = open.entry.flags.find(flag => flag.key === open.modelKey);
+    const choices = selected === undefined ? [] : modelLevelOptions(open, selected);
+    const action = MODEL_SHORTCUTS.resolve(key, MODEL_LEVEL_SCOPE);
+    if (action === "back") {
+        returnToModels(open);
+        return { consumed: true };
+    }
+    if (action === "previous" || action === "next") {
+        open.index = Math.min(Math.max(0, choices.length - 1), Math.max(0, open.index + (action === "next" ? 1 : -1)));
+        return { consumed: true };
+    }
+    if (action === "select") {
+        const choice = choices[open.index];
+        if (selected === undefined || choice === undefined)
+            return { consumed: true, render: false };
+        const previous = { ...open.record };
+        open.record[selected.key] = choice.value;
+        const forward = { ...open.record };
+        actions.save(open, previous, forward);
+        returnToModels(open);
+        return { consumed: true };
+    }
+    return { consumed: true, render: false };
+}
+export function modelDialogLines(open, width, height, theme) {
+    if (open.modelDialog === "default") {
+        const flags = filteredModelFlags(open);
+        const current = typeof open.entry.rawValue === "string" ? open.entry.rawValue : null;
+        const rows = flags.length === 0
+            ? [{ label: "No models found", value: "" }]
+            : flags.map(flag => ({
+                ...modelLabelParts(flag.label ?? humanizeLabel(flag.key)),
+                ...(flag.key === current ? { successSuffix: "✓" } : {}),
+                value: "",
+            }));
+        const description = open.error ?? "Select the model used for new sessions";
+        const visible = dialogWindow(rows, open.index, configureDialogChoiceCapacity(height, true, configureDialogTextRows(description, width)));
+        return renderSteppedDialogPanel({
+            title: "Default Model", description, input: open.filter ?? new LineInput(""),
+            rows: visible.rows, index: visible.index, hint: MODEL_SHORTCUTS.hintEntries(MODEL_SCOPE),
+        }, width, theme);
+    }
+    if (open.step === "model") {
+        const flags = filteredModelFlags(open);
+        const stored = structuredValue(open.entry, open.record);
+        const allRows = flags.length === 0
+            ? [{ label: "No models found", value: "" }]
+            : flags.map(flag => ({
+                ...modelLabelParts(flag.label ?? humanizeLabel(flag.key)),
+                value: stored[flag.key] === undefined ? "" : String(stored[flag.key]),
+            }));
+        const description = "Select a model to configure";
+        const visible = dialogWindow(allRows, open.index, configureDialogChoiceCapacity(height, true, configureDialogTextRows(description, width)));
+        return renderSteppedDialogPanel({
+            title: "Thinking Level",
+            step: 1,
+            steps: 2,
+            description,
+            ...(open.filter === null ? {} : { input: open.filter }),
+            rows: visible.rows,
+            index: visible.index,
+            hint: MODEL_SHORTCUTS.hintEntries(MODEL_SCOPE),
+        }, width, theme);
+    }
+    const selected = open.entry.flags.find(flag => flag.key === open.modelKey);
+    const current = selected === undefined ? undefined : structuredValue(open.entry, open.record)[selected.key];
+    const allRows = (selected === undefined ? [] : modelLevelOptions(open, selected)).map(choice => ({
+        label: choice.value === current ? `✓ ${choice.label}` : choice.label,
+        value: choice.description,
+    }));
+    const description = `Select default thinking level for ${selected?.label ?? open.modelKey ?? "model"}`;
+    const visible = dialogWindow(allRows, open.index, configureDialogChoiceCapacity(height, false, configureDialogTextRows(description, width)));
+    return renderSteppedDialogPanel({
+        title: "Thinking Level",
+        step: 2,
+        steps: 2,
+        description,
+        rows: visible.rows,
+        index: visible.index,
+        hint: MODEL_SHORTCUTS.hintEntries(MODEL_LEVEL_SCOPE),
+    }, width, theme);
+}
+/** The rows a dialog of `maximum` rows shows, centred on `index` where the list allows. */
+export function dialogWindow(rows, index, maximum) {
+    if (rows.length <= maximum)
+        return { rows, index: Math.min(Math.max(0, rows.length - 1), Math.max(0, index)) };
+    const start = Math.min(rows.length - maximum, Math.max(0, index - Math.floor(maximum / 2)));
+    return { rows: rows.slice(start, start + maximum), index: index - start };
+}
+// Concurrency: the dialog closes at once; a refused save reopens it with the reason.
+function selectDefaultModel(open, model, actions) {
+    open.error = null;
+    actions.close();
+    void actions.session.change(open.entry.backend, open.entry.id, model).then(outcome => {
+        const failure = changeFailure(outcome);
+        if (failure !== null) {
+            open.error = `Could not save: ${failure}`;
+            actions.reopen(open);
+        }
+    });
+}
+function returnToModels(open) {
+    open.step = "model";
+    open.modelKey = null;
+    open.index = open.modelIndex;
+}
+function filteredModelFlags(open) {
+    const needle = open.filter?.value.trim().toLowerCase() ?? "";
+    return open.entry.flags.filter(flag => needle.length === 0
+        || (flag.label ?? humanizeLabel(flag.key)).toLowerCase().includes(needle)
+        || flag.description.toLowerCase().includes(needle)
+        || flag.key.toLowerCase().includes(needle));
+}
+function modelLevelOptions(open, selected) {
+    const fallback = String(selected.fallback);
+    const supported = (selected.choices ?? [])
+        .filter(choice => choice !== fallback)
+        .map(choice => ({ value: choice, label: choice, description: thinkingLevelDescription(choice) }));
+    return structuredValue(open.entry, open.record)[selected.key] === undefined
+        ? supported
+        : [...supported, { value: fallback, label: "(clear override)", description: "Revert to global default" }];
+}
+function modelLabelParts(label) {
+    const match = /^(.*?)(\s+\[[^\]]+\])$/u.exec(label);
+    return match === null ? { label } : { label: match[1] ?? label, labelSuffix: match[2] ?? "" };
+}
+function thinkingLevelDescription(level) {
+    switch (level) {
+        case "default": return "global default";
+        case "off": return "No reasoning";
+        case "minimal": return "Very brief reasoning (~1k tokens)";
+        case "low": return "Light reasoning (~2k tokens)";
+        case "medium": return "Moderate reasoning (~8k tokens)";
+        case "high": return "Deep reasoning (~16k tokens)";
+        case "xhigh": return "Extra-high reasoning (~32k tokens)";
+        case "max": return "Maximum reasoning";
+        default: return "";
+    }
+}

package/dist/features/owned-ui/settings-scroll-rail.d.ts

@@ -0,0 +1,29 @@
+import { type PaneMouseEvent, type RailPosition, type ScrollbarGeometry, type ScrollbarPresentation, type ScrollbarPresentationInput } from "../../ui/components/index.js";
+/** Where the rail was painted in the last frame, with the list page it scrolls by. */
+export interface SettingsRailFrame {
+    readonly rail: RailPosition;
+    readonly geometry: ScrollbarGeometry;
+    readonly page: number;
+}
+/** How a pointer report landed on the rail: owned keeps it from the list, and `scroll` is the list's new offset. */
+export interface SettingsRailPointer {
+    readonly owned: boolean;
+    readonly changed: boolean;
+    readonly overRail: boolean;
+    readonly scroll?: number;
+}
+/** The settings list's scrollbar rail: hover, thumb drag, track paging, and the lingering highlight after a scroll. */
+export declare class SettingsScrollRail {
+    #private;
+    /** Notes the frame's scroll; a moved list keeps the rail lit and repaints once the highlight lapses. */
+    noteRenderedScroll(scroll: number, now: number, requestRender: () => void): void;
+    presentation(input: Omit<ScrollbarPresentationInput, "hovered" | "dragging" | "activeUntil">): ScrollbarPresentation;
+    /** Records where the rail was painted, or null when this frame has no rail. */
+    setFrame(frame: Omit<SettingsRailFrame, "rail"> & {
+        readonly rail: Omit<RailPosition, "key">;
+    } | null): void;
+    pointer(event: PaneMouseEvent, scroll: number): SettingsRailPointer;
+    /** Drops hover and any drag, as when a dialog takes the screen. */
+    clear(): void;
+    dispose(): void;
+}

package/dist/features/owned-ui/settings-scroll-rail.js

@@ -0,0 +1,79 @@
+import { scrollForTrackPage, scrollbarPresentation, ScrollbarRails, } from "../../ui/components/index.js";
+/** Identity of the settings list rail in the shared rail state. */
+const RAIL_KEY = "settings";
+// Compatibility: the transcript rail stays lit this long after a scroll, and repaints just after.
+const SCROLL_LINGER_MS = 900;
+const SCROLL_LINGER_REPAINT_MS = 925;
+/** The settings list's scrollbar rail: hover, thumb drag, track paging, and the lingering highlight after a scroll. */
+export class SettingsScrollRail {
+    #rails = new ScrollbarRails();
+    #frame = null;
+    #activeUntil = 0;
+    #activityTimer;
+    #renderedScroll;
+    /** Notes the frame's scroll; a moved list keeps the rail lit and repaints once the highlight lapses. */
+    noteRenderedScroll(scroll, now, requestRender) {
+        // Rationale: every way of scrolling ends in this frame, so a moved list is noticed here
+        // once rather than at each wheel, drag, key, and search branch.
+        if (this.#renderedScroll !== undefined && this.#renderedScroll !== scroll) {
+            this.#activeUntil = Math.max(this.#activeUntil, now + SCROLL_LINGER_MS);
+            this.#clearTimer();
+            this.#activityTimer = setTimeout(() => {
+                this.#activityTimer = undefined;
+                requestRender();
+            }, SCROLL_LINGER_REPAINT_MS);
+            this.#activityTimer.unref?.();
+        }
+        this.#renderedScroll = scroll;
+    }
+    presentation(input) {
+        return scrollbarPresentation({
+            ...input,
+            hovered: this.#rails.isHovered(RAIL_KEY),
+            dragging: this.#rails.isDragging(RAIL_KEY),
+            activeUntil: this.#activeUntil,
+        });
+    }
+    /** Records where the rail was painted, or null when this frame has no rail. */
+    setFrame(frame) {
+        this.#frame = frame === null ? null : { ...frame, rail: { ...frame.rail, key: RAIL_KEY } };
+    }
+    // Rationale: the rail takes its share of a pointer report first: hover, a thumb drag, or a
+    // track page. Owned means the list must not see the report; changed means the rail looks different.
+    pointer(event, scroll) {
+        const frame = this.#frame;
+        const wasHovered = this.#rails.isHovered(RAIL_KEY);
+        if (frame === null) {
+            this.#rails.clear();
+            return { owned: false, changed: wasHovered, overRail: false };
+        }
+        const pointer = { column: event.column, row: event.row - 1 };
+        if (this.#rails.isDragging(RAIL_KEY)) {
+            // Invariant: a drag keeps the pointer wherever it goes until the button comes up.
+            if (event.kind === "release") {
+                this.#rails.endDrag();
+                return { owned: true, changed: true, overRail: false };
+            }
+            const target = this.#rails.dragTo(frame.rail, frame.geometry, pointer);
+            return target === null ? { owned: true, changed: true, overRail: false } : { owned: true, changed: true, overRail: false, scroll: target };
+        }
+        const over = this.#rails.notePointer([frame.rail], pointer) !== null;
+        if (!over)
+            return { owned: false, changed: wasHovered, overRail: false };
+        if (event.kind === "press" && !this.#rails.beginDrag(frame.rail, frame.geometry, pointer)) {
+            return { owned: true, changed: true, overRail: true, scroll: scrollForTrackPage(frame.geometry, pointer.row - frame.rail.rowStart, scroll, frame.page) };
+        }
+        return { owned: true, changed: true, overRail: true };
+    }
+    /** Drops hover and any drag, as when a dialog takes the screen. */
+    clear() { this.#rails.clear(); }
+    dispose() {
+        this.#clearTimer();
+        this.#rails.clear();
+    }
+    #clearTimer() {
+        if (this.#activityTimer !== undefined)
+            clearTimeout(this.#activityTimer);
+        this.#activityTimer = undefined;
+    }
+}

package/dist/features/owned-ui/settings-search-input.d.ts

@@ -1,5 +1,5 @@
 import type { UiTheme } from "../../ui/components/index.js";
-export interface SettingsSearchPointerEvent {
+interface SettingsSearchPointerEvent {
     readonly kind: "press" | "motion" | "release";
     readonly button: number;
     readonly column: number;
@@ -27,3 +27,4 @@ export interface SettingsSearchInputFactory {
     create(options: SettingsSearchInputOptions): SettingsSearchInput;
     isTextInput(data: string): boolean;
 }
+export {};

package/dist/features/prompt-history/service.d.ts

@@ -1,8 +1,8 @@
 import type { Worker } from "node:worker_threads";
 import { type PromptHistoryFailure, type PromptHistoryPort, type PromptHistoryResult, type PromptHistorySnapshot, type PromptHistorySubmission } from "../../contracts/owned-ui/index.js";
 import { type PromptHistoryScope } from "./paths.js";
-export type HistoryRecoveryState = "starting" | "ready" | "recovering" | "blocked-storage" | "closing" | "closed";
-export interface HistoryClock {
+type HistoryRecoveryState = "starting" | "ready" | "recovering" | "blocked-storage" | "closing" | "closed";
+interface HistoryClock {
     now(): number;
     setTimeout(callback: () => void, milliseconds: number): ReturnType<typeof setTimeout>;
     clearTimeout(timer: ReturnType<typeof setTimeout> | undefined): void;
@@ -57,3 +57,4 @@ export declare class PromptHistoryService implements PromptHistoryPort {
     onFailure(listener: (code: PromptHistoryFailure) => void): () => void;
     close(): Promise<void>;
 }
+export {};

package/dist/foundation/lifecycle/claim-gate.d.ts

@@ -1,4 +1,4 @@
-export interface ClaimGateHandle {
+interface ClaimGateHandle {
     release(): void;
 }
 /**
@@ -6,3 +6,4 @@ export interface ClaimGateHandle {
  * file; contention returns null so the caller keeps its own bounded retry.
  */
 export declare function tryAcquireClaimGate(path: string): ClaimGateHandle | null;
+export {};

package/dist/foundation/release/automatic-update.d.ts

@@ -1,7 +1,5 @@
 import { type AvailableRelease, type ReleaseChannel } from "./latest-release.js";
-export declare const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
-export declare const AUTOMATIC_UPDATE_RETRY_MS: number;
-export declare const ACTIVE_RELEASE_FALLBACK_MS = 5000;
+declare const AUTOMATIC_UPDATE_STATE_SCHEMA = 1;
 export interface AutomaticUpdateState {
     readonly schema: typeof AUTOMATIC_UPDATE_STATE_SCHEMA;
     readonly channel: ReleaseChannel;
@@ -12,24 +10,16 @@ export interface AutomaticUpdateState {
     readonly installedVersion: string | null;
     readonly failure: string | null;
 }
-export declare class AutomaticUpdateStateStore {
-    readonly path: string;
-    constructor(dataDir: string);
-    read(): Promise<AutomaticUpdateState | null>;
-    write(value: AutomaticUpdateState): Promise<void>;
-}
-export interface ActiveReleaseObservationOptions {
+interface ActiveReleaseObservationOptions {
     readonly runningVersion: string;
     readonly environment?: NodeJS.ProcessEnv;
     readonly signal?: AbortSignal;
     readonly onNewer: (version: string) => void;
     readonly fallbackMs?: number;
 }
-/** Read the approved active release only when this process executes an older release on that channel. */
-export declare function readNewerActiveRelease(runningVersion: string, environment?: NodeJS.ProcessEnv): Promise<string | null>;
 /** Observe local release activation promptly, with a bounded fallback for missed filesystem events. */
 export declare function observeNewerActiveRelease(options: ActiveReleaseObservationOptions): () => void;
-export interface AutomaticUpdateRequestOptions {
+interface AutomaticUpdateRequestOptions {
     readonly release: AvailableRelease;
     readonly runningVersion: string;
     readonly environment?: NodeJS.ProcessEnv;
@@ -37,7 +27,7 @@ export interface AutomaticUpdateRequestOptions {
     readonly now?: () => number;
     readonly spawnWorker?: (entry: string, arguments_: readonly string[], environment: NodeJS.ProcessEnv) => Promise<void>;
     readonly sleep?: (durationMs: number) => Promise<void>;
-    /** Focused-test seams; production resolves both from the certified launch cohort. */
+    /** Focused-test seams; production resolves both from the certified launch release. */
     readonly worker?: {
         readonly entry: string;
         readonly packageRoot: string;
@@ -47,3 +37,4 @@ export interface AutomaticUpdateRequestOptions {
 /** Start or observe one silent update and resolve with the active newer version once restart is useful. */
 export declare function requestAutomaticUpdate(options: AutomaticUpdateRequestOptions): Promise<string | null>;
 export declare function runAutomaticUpdateWorker(argv: readonly string[], environment?: NodeJS.ProcessEnv): Promise<number>;
+export {};