@narumitw/pi-sync 0.53.1 → 0.54.1

package/src/ui/merged-sync-summary.ts

@@ -0,0 +1,128 @@
+import { truncateToWidth } from "@earendil-works/pi-tui";
+import type { PublicationCapability } from "../backends/sync-backend.js";
+import type { Snapshot } from "../snapshot/snapshot-types.js";
+import type { FileMergeDecision } from "../sync/file-merge-planner.js";
+import { fileHashMap } from "../sync/sync-state.js";
+import { safeTerminalText, snapshotPathLabel } from "./terminal-text.js";
+
+interface FileChange {
+  path: string;
+  action: "Add" | "Update" | "Delete";
+}
+
+export interface MergedSyncSummaryInput {
+  setupName: string;
+  destination: string;
+  localBefore: Snapshot;
+  localAfter: Snapshot;
+  remoteBefore: Snapshot;
+  remoteAfter: Snapshot;
+  publish: boolean;
+  sessions: boolean;
+  groups: readonly { paths: readonly string[] }[];
+  decisions: readonly FileMergeDecision[];
+  capability: PublicationCapability;
+}
+
+/** Presentation only: counts describe snapshot differences, not planner decisions. */
+export function mergedSyncSummary(input: MergedSyncSummaryInput) {
+  const local = changes(input.localBefore, input.localAfter);
+  const remote = changes(input.remoteBefore, input.remoteAfter);
+  const all = [...local, ...remote];
+  const updatesOnly = all.length > 0 && all.every((change) => change.action === "Update");
+  const verb = updatesOnly ? "Update" : "Apply changes to";
+  const title =
+    local.length && remote.length
+      ? "Apply local and remote changes?"
+      : all.length
+        ? `${verb} ${all.length} ${local.length ? "local" : "remote"} ${all.length === 1 ? "file" : "files"}?`
+        : input.publish
+          ? "Publish a new remote snapshot?"
+          : "Pi Sync is already up to date.";
+  const confirmationLabel =
+    local.length && remote.length
+      ? "apply local and remote changes"
+      : all.length
+        ? `${updatesOnly ? "update" : "apply changes to"} ${local.length ? "local" : "remote"} ${all.length === 1 ? "file" : "files"}`
+        : "publish remote snapshot";
+  const sources = new Map(
+    input.decisions.filter((item) => item.kind === "accepted").map((item) => [item.path, item.source]),
+  );
+  const label = (change: FileChange, side: "local" | "remote") => {
+    const source = sources.get(change.path);
+    const suffix =
+      source === "merged"
+        ? " (merged content)"
+        : side === "local" && source === "remote"
+          ? change.action === "Delete"
+            ? " (deleted remotely)"
+            : " from remote"
+          : "";
+    return `${change.action} ${snapshotPathLabel(change.path)}${suffix}`;
+  };
+  const section = (items: FileChange[], side: "local" | "remote", compact: boolean) => {
+    const heading = side === "local" ? "Local changes" : "Remote file changes";
+    if (!items.length) return [`${heading}: none`];
+    const counts = ["Add", "Update", "Delete"].flatMap((action) => {
+      const count = items.filter((item) => item.action === action).length;
+      return count ? [`${count} ${action.toLowerCase()}`] : [];
+    });
+    return [
+      `${heading}: ${counts.join(", ")}`,
+      ...(compact ? items.slice(0, 3) : items).map(
+        (item) => `  ${compact ? truncateToWidth(label(item, side), 80) : label(item, side)}`,
+      ),
+      ...(compact && items.length > 3 ? [`  ${items.length - 3} more files — View details`] : []),
+    ];
+  };
+  const context = [`Setup: ${safeTerminalText(input.setupName)}`, `Remote: ${safeTerminalText(input.destination)}`];
+  const safety = [
+    `Remote snapshot publication: ${input.publish ? "yes" : "no"}`,
+    `Sessions: ${input.sessions ? "included — may contain private conversations" : "not included"}`,
+    input.groups.length
+      ? `Unresolved groups: ${input.groups.length} — these paths stay unchanged on each side`
+      : "Conflicts: none",
+    ...(input.publish && input.capability === "read-check-write-verify"
+      ? ["Warning: simultaneous remote writes can still race; visible changes are rejected."]
+      : []),
+    ...(input.publish && input.capability === "conditional-required"
+      ? ["Remote publication requires verified conditional writes; verification failure stops the transfer."]
+      : []),
+    "The current session is protected. A backup and recovery journal will be saved.",
+    "Resources will not reload automatically.",
+  ];
+  return {
+    title,
+    confirmationLabel,
+    lines: [
+      ...context.map((line) => truncateToWidth(line, 100)),
+      ...section(local, "local", true),
+      ...section(remote, "remote", true),
+      ...safety,
+    ],
+    content: [
+      ...context,
+      "",
+      ...section(local, "local", false),
+      "",
+      ...section(remote, "remote", false),
+      "",
+      ...safety,
+      ...input.groups.flatMap((group) =>
+        group.paths.map((filePath) => `Unchanged (unresolved): ${snapshotPathLabel(filePath)}`),
+      ),
+    ].join("\n"),
+  };
+}
+
+function changes(before: Snapshot, after: Snapshot): FileChange[] {
+  const beforeMap = fileHashMap(before);
+  const afterMap = fileHashMap(after);
+  return [...new Set([...Object.keys(beforeMap), ...Object.keys(afterMap)])]
+    .sort()
+    .flatMap((filePath): FileChange[] => {
+      if (!Object.hasOwn(beforeMap, filePath)) return [{ path: filePath, action: "Add" }];
+      if (!Object.hasOwn(afterMap, filePath)) return [{ path: filePath, action: "Delete" }];
+      return beforeMap[filePath] !== afterMap[filePath] ? [{ path: filePath, action: "Update" }] : [];
+    });
+}

package/src/ui/operation-dialogs.ts

@@ -0,0 +1,29 @@
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+/** Track History's Pi-owned selector/confirmation lifetime without inspecting renderer internals. */
+export function trackOperationDialogs<Context extends ExtensionContext>(
+  ctx: Context,
+  onDialog?: (active: boolean) => void,
+): Context {
+  if (!onDialog) return ctx;
+  const runDialog = async <Value>(task: () => Promise<Value>): Promise<Value> => {
+    onDialog(true);
+    try {
+      return await task();
+    } finally {
+      onDialog(false);
+    }
+  };
+  const ui: ExtensionContext["ui"] = {
+    ...ctx.ui,
+    select: (...args) => runDialog(() => ctx.ui.select(...args)),
+    confirm: (...args) => runDialog(() => ctx.ui.confirm(...args)),
+  };
+  // Forward live context properties: copying the context would hide session
+  // replacement from mutation-owner revalidation after a dialog settles.
+  return new Proxy(ctx, {
+    get(target, key, receiver) {
+      return key === "ui" ? ui : Reflect.get(target, key, receiver);
+    },
+  });
+}

package/src/ui/settings-ui.ts

@@ -14,7 +14,9 @@ import {
 import { captureMutationOwner } from "../sync/sync-local.js";
 import type { RunRoute } from "./cancellable-operation.js";
 import { dispatchManagerResult } from "./manager-result-dispatcher.js";
+import { showEditSyncSetupStorage, showSyncSetupManager } from "./setup/setup-actions.js";
 import { AUTOMATIC_SYNC_DESCRIPTION } from "./setup/setup-prompts.js";
+import { showStorageConnections } from "./storage-connections-ui.js";
 import { configureSyncStatus } from "./sync-status.js";
 import { safeTerminalText } from "./terminal-text.js";
 
@@ -24,13 +26,46 @@ export async function showSyncSettings(
   ctx: ExtensionCommandContext,
   runRoute: SyncSettingsRoute,
   signal?: AbortSignal,
-) {
+): Promise<"back" | "exit"> {
+  let disposition: "back" | "exit" = "back";
+  const exitSettings = () => {
+    disposition = "exit";
+    return { kind: "close" as const };
+  };
   if (ctx.mode !== "tui") {
     ctx.ui.notify(`Edit pi-sync settings manually: ${safeTerminalText(localConfigPath())}`, "info");
-    return;
+    if (ctx.mode === "rpc" && ctx.hasUI) {
+      // Preserve RPC catalog management; preference/credential editing stays TUI-only.
+      const management = defineMenu<undefined, "management", "setups" | "connections", ExtensionCommandContext>({
+        start: "management",
+        screens: {
+          management: () => ({
+            kind: "actions",
+            title: "Sync settings management",
+            items: [
+              { id: "setups", label: "Manage sync setups", action: "setups" },
+              { id: "connections", label: "Manage storage connections", action: "connections" },
+            ],
+            hint: "back",
+          }),
+        },
+        actions: {
+          setups: async ({ signal: actionSignal }) => {
+            const result = await showSyncSetupManager(ctx, runRoute, actionSignal);
+            return result === "exit" ? exitSettings() : { kind: "stay" };
+          },
+          connections: async ({ signal: actionSignal }) => {
+            await showStorageConnections(ctx, actionSignal);
+            return { kind: "stay" };
+          },
+        },
+      });
+      await runMenu(ctx, management, { getState: () => undefined, signal, isCurrent: () => !signal?.aborted });
+    }
+    return disposition;
   }
   const initial = await loadConfig();
-  if (signal?.aborted) return;
+  if (signal?.aborted) return "back";
   const setupName = initial.setupName;
   type Action =
     | "automatic"
@@ -42,7 +77,10 @@ export async function showSyncSettings(
     | "show-status"
     | "on-switch"
     | "include"
-    | "remote-include";
+    | "remote-include"
+    | "storage-location"
+    | "setups"
+    | "connections";
   const menu = defineMenu<Awaited<ReturnType<typeof loadConfig>>, "settings", Action, ExtensionCommandContext>({
     start: "settings",
     screens: {
@@ -52,39 +90,9 @@ export async function showSyncSettings(
         lines: [
           `Sync setup: ${safeTerminalText(state.setupName)} · Storage connection: ${safeTerminalText(state.connectionName)}`,
         ],
+        // Flat, searchable task ordering: Content, Destination, Automation, Merge, Other.
+        // Kit has no heading rows; avoid focusable fake headings or a new component.
         items: [
-          {
-            id: "automatic",
-            label: "Automatic sync",
-            description: AUTOMATIC_SYNC_DESCRIPTION,
-            currentValue: state.automatic ? "On" : "Off",
-            values: ["On", "Off"],
-            action: "automatic",
-          },
-          {
-            id: "skipSecretScan",
-            label: "Skip secret scan (all setups)",
-            description: "All setups: allow pushes without checking managed local files for possible secrets.",
-            currentValue: state.skipSecretScan ? "On" : "Off",
-            values: ["On", "Off"],
-            action: "skip-secret-scan",
-          },
-          {
-            id: "showStatus",
-            label: "Show status (all setups)",
-            description: "All setups: show sync progress and attention in Pi status.",
-            currentValue: state.showStatus ? "On" : "Off",
-            values: ["On", "Off"],
-            action: "show-status",
-          },
-          {
-            id: "onSwitch",
-            label: "After switching setup (all setups)",
-            description: "All setups: ask before a pull review, open it automatically, or switch without pulling.",
-            currentValue: setupSwitchActionLabel(state.onSwitch),
-            values: SETUP_SWITCH_ACTION_OPTIONS.map(({ label }) => label),
-            action: "on-switch",
-          },
           {
             id: "include",
             label: "Included content",
@@ -99,6 +107,49 @@ export async function showSyncSettings(
             currentValue: "Review",
             action: "remote-include",
           },
+          {
+            id: "localFields",
+            label: "Machine-local settings fields",
+            description:
+              "Root field names omitted from future portable snapshots. Policy changes require directional migration; old history remains.",
+            currentValue: `${state.localFields?.length ?? 0} fields · Edit`,
+            action: "local-fields",
+          },
+          {
+            id: "storageLocation",
+            label: "Storage location",
+            description: "Destination: edit this setup's bucket, branch, or path; remote history is not moved.",
+            currentValue:
+              state.backend.type === "s3"
+                ? `${safeTerminalText(state.backend.destination.bucket)} · ${safeTerminalText(state.backend.destination.prefix)}`
+                : state.backend.type === "git"
+                  ? `${safeTerminalText(state.backend.destination.branch)} · ${safeTerminalText(state.backend.destination.directory)}`
+                  : safeTerminalText(state.backend.destination.path),
+            action: "storage-location",
+          },
+          {
+            id: "setups",
+            label: "Manage sync setups",
+            description: "Destination: add, switch, edit, or remove sync setups.",
+            currentValue: "Open",
+            action: "setups",
+          },
+          {
+            id: "connections",
+            label: "Manage storage connections",
+            description:
+              "Destination: manage shared server addresses and credentials; edits may affect multiple setups.",
+            currentValue: "Open",
+            action: "connections",
+          },
+          {
+            id: "automatic",
+            label: "Automatic sync",
+            description: AUTOMATIC_SYNC_DESCRIPTION,
+            currentValue: state.automatic ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "automatic",
+          },
           {
             id: "automaticTransfer",
             label: "Automatic transfer at startup",
@@ -108,6 +159,14 @@ export async function showSyncSettings(
             values: ["On", "Off"],
             action: "automatic-transfer",
           },
+          {
+            id: "onSwitch",
+            label: "After switching setup (all setups)",
+            description: "All setups: ask before a pull review, open it automatically, or switch without pulling.",
+            currentValue: setupSwitchActionLabel(state.onSwitch),
+            values: SETUP_SWITCH_ACTION_OPTIONS.map(({ label }) => label),
+            action: "on-switch",
+          },
           {
             id: "mergeSettings",
             label: "Settings field merge (experimental)",
@@ -117,14 +176,6 @@ export async function showSyncSettings(
             values: ["On", "Off"],
             action: "merge-settings",
           },
-          {
-            id: "localFields",
-            label: "Machine-local settings fields",
-            description:
-              "Root field names omitted from future portable snapshots. Policy changes require directional migration; old history remains.",
-            currentValue: `${state.localFields?.length ?? 0} fields · Edit`,
-            action: "local-fields",
-          },
           {
             id: "contentPolicy",
             label: "Content / partial sync (experimental)",
@@ -140,10 +191,41 @@ export async function showSyncSettings(
             values: ["Off", "Content only", "Content & partial", "Partial only"],
             action: "content-policy",
           },
+          {
+            id: "skipSecretScan",
+            label: "Skip secret scan (all setups)",
+            description: "All setups: allow pushes without checking managed local files for possible secrets.",
+            currentValue: state.skipSecretScan ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "skip-secret-scan",
+          },
+          {
+            id: "showStatus",
+            label: "Show status (all setups)",
+            description: "All setups: show sync progress and attention in Pi status.",
+            currentValue: state.showStatus ? "On" : "Off",
+            values: ["On", "Off"],
+            action: "show-status",
+          },
         ],
       }),
     },
     actions: {
+      "storage-location": async ({ signal: actionSignal }) => {
+        const editorSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        await showEditSyncSetupStorage(ctx, setupName, editorSignal);
+        return resumeSettings(editorSignal);
+      },
+      setups: async ({ signal: actionSignal }) => {
+        const editorSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        const result = await showSyncSetupManager(ctx, runRoute, editorSignal);
+        return result === "exit" ? exitSettings() : resumeSettings(editorSignal);
+      },
+      connections: async ({ signal: actionSignal }) => {
+        const editorSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
+        await showStorageConnections(ctx, editorSignal);
+        return resumeSettings(editorSignal);
+      },
       "content-policy": async ({ value, signal: actionSignal }) => {
         const mutationSignal = signal ? AbortSignal.any([signal, actionSignal]) : actionSignal;
         const validate = captureMutationOwner(ctx, mutationSignal);
@@ -356,17 +438,29 @@ export async function showSyncSettings(
         if (reviewSignal.aborted) return { kind: "rejected" };
         if (review.kind === "route-result") {
           const disposition = await dispatchManagerResult(ctx, review.result, review.route, runRoute, reviewSignal);
-          return disposition.kind === "close" ? { kind: "close" } : { kind: "stay" };
+          return disposition.kind === "close" ? exitSettings() : { kind: "stay" };
         }
-        return review.kind === "closed" || review.kind === "stale" ? { kind: "close" } : { kind: "stay" };
+        return review.kind === "closed" || review.kind === "stale" ? exitSettings() : { kind: "stay" };
       },
     },
   });
+  async function resumeSettings(editorSignal: AbortSignal) {
+    if (editorSignal.aborted) return { kind: "close" as const };
+    try {
+      const active = await loadConfig();
+      if (editorSignal.aborted || active.setupName !== setupName) return { kind: "close" as const };
+      // Stay reloads authoritative rows without pushing a duplicate screen or clearing search.
+      return { kind: "stay" as const };
+    } catch {
+      return { kind: "close" as const };
+    }
+  }
   await runMenu(ctx, menu, {
     getState: () => loadConfig(setupName),
     signal,
     isCurrent: () => !signal?.aborted,
   });
+  return disposition;
 }
 
 function notifySaveFailure(ctx: ExtensionCommandContext, error: unknown) {

package/src/ui/setup/setup-actions.ts

@@ -22,7 +22,7 @@ export async function showSyncSetupManager(ctx: ExtensionCommandContext, runRout
         await showAddTarget(ctx, setupSignal);
       },
       edit: async (name, setupSignal) => {
-        await showEditTarget(ctx, name, setupSignal);
+        await showEditSyncSetupStorage(ctx, name, setupSignal);
       },
       makeCurrent: async (name, setupSignal) => {
         const result = await showSetupSwitcher(ctx, runRoute, name, setupSignal);
@@ -84,7 +84,7 @@ async function showAddTarget(ctx: ExtensionCommandContext, signal?: AbortSignal)
   await showAddS3Target(ctx, raw, profile, name, signal);
 }
 
-async function showEditTarget(ctx: ExtensionCommandContext, name: string, signal?: AbortSignal) {
+export async function showEditSyncSetupStorage(ctx: ExtensionCommandContext, name: string, signal?: AbortSignal) {
   const partial = await loadPartialConfig(name);
   if (signal?.aborted) return;
   if (!partial.setupName) {

package/src/ui/sync-confirmation.ts

@@ -0,0 +1,153 @@
+import type { KeybindingsManager, Theme } from "@earendil-works/pi-coding-agent";
+import { Key, matchesKey, SelectList, type TUI, type TuiMouseEvent, truncateToWidth } from "@earendil-works/pi-tui";
+import { HorizontalRule, hardWrapTerminalDocument, sanitizeTerminalText } from "@narumitw/pi-tui-kit";
+
+export type SyncConfirmationChoice = "cancel" | "approve" | "details";
+
+/** Kit choice context is clipped on short terminals; this summary must remain reviewable. */
+export function createSyncConfirmation(options: {
+  title: string;
+  lines: readonly string[];
+  confirmationLabel: string;
+  tui: TUI;
+  theme: Theme;
+  keybindings: KeybindingsManager;
+  complete(choice: SyncConfirmationChoice): void;
+}) {
+  const { tui, theme, keybindings } = options;
+  const choices: SyncConfirmationChoice[] = ["cancel", "approve", "details"];
+  const list = new SelectList(
+    [
+      { value: "cancel", label: "No, cancel" },
+      { value: "approve", label: `Yes, ${sanitizeTerminalText(options.confirmationLabel)}` },
+      { value: "details", label: "View details" },
+    ],
+    3,
+    {
+      selectedPrefix: (text) => theme.fg("accent", text),
+      selectedText: (text) => theme.fg("accent", text),
+      description: (text) => theme.fg("muted", text),
+      scrollInfo: (text) => theme.fg("dim", text),
+      noMatch: (text) => theme.fg("muted", text),
+    },
+  );
+  const rule = new HorizontalRule({ ruleStyle: (text) => theme.fg("border", text) });
+  let selected = 0;
+  let offset = 0;
+  let maximumOffset = 0;
+  let lastWidth = 0;
+  let lastRows = 0;
+  let seen = new Set<number>();
+  let summary: readonly string[] = [];
+  let reviewed = false;
+  let disposed = false;
+  let finished = false;
+  let summaryStart = 0;
+  let summaryEnd = 0;
+  let actionsStart = 0;
+  const finish = (choice: SyncConfirmationChoice) => {
+    if (disposed || finished) return;
+    finished = true;
+    options.complete(choice);
+  };
+  const select = (index: number) => {
+    selected = (index + choices.length) % choices.length;
+    list.setSelectedIndex(selected);
+  };
+  list.onSelectionChange = (item) => {
+    selected = Math.max(0, choices.indexOf(item.value as SyncConfirmationChoice));
+  };
+  list.onSelect = (item) => {
+    const choice = choices[selected] ?? "cancel";
+    if (item.value === choice && (choice !== "approve" || reviewed)) finish(choice);
+  };
+  const component = {
+    render(width: number, expose = true): string[] {
+      if (!Number.isFinite(width) || width <= 0) {
+        reviewed = false;
+        return [];
+      }
+      const cells = Math.floor(width);
+      const rows = Math.max(1, Math.floor(tui.terminal.rows) - 3);
+      if (cells !== lastWidth || rows !== lastRows) {
+        // Reflow can expose previously unseen rows or hide the selected action.
+        // Reset proof and selection rather than carry approval across a resize.
+        summary = options.lines.flatMap((line) => hardWrapTerminalDocument(line, cells));
+        seen = new Set();
+        offset = 0;
+        select(0);
+        lastWidth = cells;
+        lastRows = rows;
+      }
+      const framed = rows >= 9;
+      const actions = list.render(cells);
+      const viewport = Math.max(0, rows - actions.length - 3 - (framed ? 2 : 0));
+      maximumOffset = Math.max(0, summary.length - viewport);
+      offset = Math.min(offset, maximumOffset);
+      const visible = summary.slice(offset, offset + viewport);
+      if (expose) for (let index = offset; index < offset + visible.length; index++) seen.add(index);
+      reviewed = viewport > 0 && seen.size === summary.length;
+      // Describe actions without advertising configured keys that can be invalid,
+      // aliased, or shadowed by an earlier cancellation/navigation binding.
+      const hint = reviewed ? "Select an action." : "Navigation keys scroll the summary before selecting Yes.";
+      const body = [
+        theme.fg("accent", theme.bold(hardWrapTerminalDocument(options.title, cells).join(" "))),
+        ...visible.map((line) => theme.fg("text", line)),
+        theme.fg(
+          "muted",
+          `Summary ${visible.length ? offset + 1 : 0}-${offset + visible.length}/${summary.length}${reviewed ? "" : " — review before Yes"}`,
+        ),
+        ...actions,
+        theme.fg("dim", hint),
+      ];
+      summaryStart = Number(framed) + 1;
+      summaryEnd = summaryStart + visible.length;
+      actionsStart = summaryEnd + 1;
+      const frame = framed ? [...rule.render(cells), ...body, ...rule.render(cells)] : body;
+      // Very small terminals cannot display the summary and all choices together.
+      // Keep cancellation available, but never approve a zero-row summary viewport.
+      return frame.slice(0, rows).map((line) => truncateToWidth(line, cells, ""));
+    },
+    invalidate() {
+      list.invalidate();
+      rule.invalidate();
+    },
+    handleInput(data: string) {
+      if (disposed || finished) return;
+      if (matchesKey(data, Key.ctrl("c")) || keybindings.matches(data, "tui.select.cancel")) {
+        finish("cancel");
+        return;
+      }
+      // Refresh height/width proof before handling an input racing with terminal resize.
+      component.render(tui.terminal.columns ?? lastWidth, false);
+      if (keybindings.matches(data, "tui.select.up")) {
+        if (!reviewed || (selected === 0 && offset > 0)) offset = Math.max(0, offset - 1);
+        else select(selected - 1);
+      } else if (keybindings.matches(data, "tui.select.down")) {
+        if (!reviewed || (selected === 0 && offset < maximumOffset)) offset = Math.min(maximumOffset, offset + 1);
+        else select(selected + 1);
+      } else if (keybindings.matches(data, "tui.select.confirm")) {
+        const choice = choices[selected] ?? "cancel";
+        if (choice !== "approve" || reviewed) finish(choice);
+      }
+      tui.requestRender();
+    },
+    handleMouse(event: TuiMouseEvent) {
+      if (disposed || finished || event.width !== lastWidth) return undefined;
+      component.render(event.width, false);
+      if (event.y >= summaryStart && event.y < summaryEnd && event.type === "wheel" && event.wheelDelta) {
+        offset = Math.max(0, Math.min(maximumOffset, offset + (event.wheelDelta < 0 ? -1 : 1)));
+        select(0);
+        tui.requestRender();
+        return { handled: true, render: true };
+      }
+      if (event.y < actionsStart || event.y >= actionsStart + choices.length || event.y >= lastRows) return undefined;
+      return list.handleMouse({ ...event, y: event.y - actionsStart, height: choices.length });
+    },
+    dispose() {
+      disposed = true;
+      seen.clear();
+    },
+  };
+  return component;
+}