tmux-ide 2.6.0 → 2.7.0

package/packages/daemon/src/tui/mirror/dialog-model.ts

@@ -0,0 +1,298 @@
+/**
+ * Dialog primitives — the PURE model (M22.4). Types + geometry + filtering for
+ * the three dialogs every setting is built from: {@link DialogSelectSpec} (a
+ * filterable list with a ● current-value marker and per-row key actions),
+ * {@link DialogPromptSpec} (one text input with validation), and
+ * {@link DialogConfirmSpec} (two options). The STACK that runs them lives in
+ * {@link ./dialog-stack.ts}; app.tsx mounts ONE overlay for whatever is on top.
+ *
+ * Geometry follows the palette's law (M21.9): the overlay is app-rendered, so
+ * its full geometry is knowable by pure math shared between the RENDER
+ * (placement) and the central mouse ROUTER (row hit-test / inside-vs-outside)
+ * — a click can never land where a row isn't drawn. Layout, in screen rows
+ * from `top`:
+ *   border (top+0) · title (top+1) · [filter input, select only] · rule ·
+ *   body rows (confirm only) · list/content rows … · footer hints · border.
+ * Rows span the box interior in x: [left+1, left+width-1).
+ */
+import { fuzzyFilter } from "../team/fuzzy.ts";
+
+// ── Specs ────────────────────────────────────────────────────────────────────
+
+/** One row of a select dialog. */
+export interface DialogSelectItem {
+  /** Stable id the caller dispatches on. */
+  id: string;
+  /** What the list shows and the fuzzy filter scores. */
+  label: string;
+  /** Dim, right-aligned annotation (current value, key name, …). */
+  detail?: string;
+  /** The current value — rendered with the ● marker. */
+  current?: boolean;
+  /** Destructive — enter/click arms an inline "press again to confirm" first. */
+  danger?: boolean;
+  /** Optional RGB swatch rendered as a colored ● before the label (theme rows). */
+  swatch?: [number, number, number];
+}
+
+/** A per-row action bound to a ctrl+key chord, shown in the footer. */
+export interface DialogRowAction {
+  /** The letter — triggered as ctrl+<key> so it never collides with filter typing. */
+  key: string;
+  /** Footer label, e.g. `^d delete`. */
+  label: string;
+}
+
+export interface DialogSelectSpec {
+  kind: "select";
+  title: string;
+  items: DialogSelectItem[];
+  /** Type-to-filter (default true). Read-only viewers keep it on for search. */
+  filterable?: boolean;
+  /** Plain-language footer note (e.g. "applies after re-adopt — run tmux-ide adopt <session>"). */
+  footerHint?: string;
+  /** Per-row key-bound actions listed in the footer. */
+  actions?: DialogRowAction[];
+  /** Live-preview hook — fired by the stack whenever the SELECTION lands on a
+   *  different item (keyboard and mouse both), never on open. */
+  onMove?: (item: DialogSelectItem) => void;
+  /** Start the selection here (defaults to the `current` item, else 0). */
+  initialSel?: number;
+}
+
+export interface DialogPromptSpec {
+  kind: "prompt";
+  title: string;
+  /** Dim example shown while the input is empty. */
+  placeholder?: string;
+  /** Pre-filled input. */
+  initial?: string;
+  /** Plain-language footer note shown while there is no error. */
+  footerHint?: string;
+  /** Return an error message to reject, null to accept. */
+  validate?: (value: string) => string | null;
+}
+
+export interface DialogConfirmSpec {
+  kind: "confirm";
+  title: string;
+  /** Optional explanation line(s) — wrapped to the box width. */
+  body?: string;
+  /** First option (the affirmative). Default "Yes". */
+  yesLabel?: string;
+  /** Second option. Default "No". */
+  noLabel?: string;
+  /** Start on the second option (the safe default for destructive asks). */
+  defaultNo?: boolean;
+}
+
+export type DialogSpec = DialogSelectSpec | DialogPromptSpec | DialogConfirmSpec;
+
+/** What a select resolves with: the chosen item, plus the action key when a
+ *  per-row ctrl+key action (not enter/click) triggered it. */
+export interface DialogSelectResult {
+  item: DialogSelectItem;
+  action?: string;
+}
+
+// ── Constants ────────────────────────────────────────────────────────────────
+
+/** Box width — matches the palette so the two overlays read as one family. */
+export const DIALOG_W = 60;
+/** Visible list rows before the wheel/follow-scroll windows the slice. */
+export const DIALOG_ROWS = 10;
+/** The inline destructive re-arm suffix (plain language, no modal). */
+export const DIALOG_CONFIRM_SUFFIX = " — press again to confirm";
+/** The current-value marker. */
+export const DIALOG_CURRENT_MARK = "●";
+
+// ── Filtering / selection ────────────────────────────────────────────────────
+
+/** PURE — the visible rows for a query: fuzzy-filtered + score-sorted (the
+ *  palette's idiom); an empty query returns every item in natural order. */
+export function filterDialogItems(
+  query: string,
+  items: readonly DialogSelectItem[],
+): DialogSelectItem[] {
+  const q = query.trim();
+  if (q.length === 0) return [...items];
+  return fuzzyFilter(q, [...items], (i) => i.label).map((m) => m.item);
+}
+
+/** PURE — where the selection starts: `initialSel` when valid, else the
+ *  `current` item, else 0. */
+export function initialSelIndex(spec: DialogSelectSpec): number {
+  if (
+    spec.initialSel !== undefined &&
+    spec.initialSel >= 0 &&
+    spec.initialSel < spec.items.length
+  ) {
+    return spec.initialSel;
+  }
+  const cur = spec.items.findIndex((i) => i.current);
+  return cur >= 0 ? cur : 0;
+}
+
+/** PURE — keep `sel` visible: the window `top` that contains it, moving as
+ *  little as possible (keyboard follow-scroll; the wheel moves `top` alone). */
+export function followTop(sel: number, top: number, pageRows: number): number {
+  if (sel < top) return sel;
+  if (sel > top + pageRows - 1) return sel - pageRows + 1;
+  return top;
+}
+
+/** PURE — clamp a wheel-scrolled list top into [0, count - pageRows]. */
+export function clampDialogTop(top: number, count: number, pageRows: number): number {
+  return Math.max(0, Math.min(top, count - pageRows));
+}
+
+// ── Geometry ─────────────────────────────────────────────────────────────────
+
+/** The placed box + the row bands the router hit-tests. */
+export interface DialogGeom {
+  left: number;
+  top: number;
+  width: number;
+  /** Chrome rows above the first hit-testable row: top border + title +
+   *  (filter input) + rule + (confirm body). */
+  headerRows: number;
+  /** Hit-testable rows on screen right now (select window / confirm options /
+   *  the prompt's input row). 0 renders one non-hittable placeholder row. */
+  visibleRows: number;
+  /** Footer hint rows (always 1 — hints/errors live there). */
+  footerRows: number;
+}
+
+/** PURE — placement: horizontally centered, top at a sixth of the height
+ *  (min 1 — below the surface tab bar). Same law as the palette. */
+export function dialogPos(
+  termW: number,
+  termH: number,
+  width: number,
+): { left: number; top: number } {
+  return {
+    left: Math.max(0, Math.floor((termW - width) / 2)),
+    top: Math.max(1, Math.floor(termH / 6)),
+  };
+}
+
+/** PURE — greedy word-wrap for the confirm body (never returns empty for
+ *  non-empty text; words longer than the width hard-break). */
+export function wrapText(text: string, width: number): string[] {
+  if (width <= 0) return [text];
+  const out: string[] = [];
+  for (const para of text.split("\n")) {
+    let line = "";
+    for (const word of para.split(/\s+/).filter(Boolean)) {
+      if (line.length === 0) {
+        let w = word;
+        while (w.length > width) {
+          out.push(w.slice(0, width));
+          w = w.slice(width);
+        }
+        line = w;
+      } else if (line.length + 1 + word.length <= width) {
+        line += ` ${word}`;
+      } else {
+        out.push(line);
+        let w = word;
+        while (w.length > width) {
+          out.push(w.slice(0, width));
+          w = w.slice(width);
+        }
+        line = w;
+      }
+    }
+    if (line.length > 0 || para.length === 0) out.push(line);
+  }
+  return out.length > 0 ? out : [""];
+}
+
+/** PURE — the interior text width of the box (borders + 1-cell padding each side). */
+export function dialogInnerW(width: number): number {
+  return width - 4;
+}
+
+/** PURE — chrome rows above the first hit-testable row, per kind. */
+export function dialogHeaderRows(spec: DialogSpec): number {
+  // top border + title + rule = 3 …
+  if (spec.kind === "select") return spec.filterable === false ? 3 : 4; // … + filter input
+  if (spec.kind === "prompt") return 3;
+  return 3 + (spec.body ? wrapText(spec.body, dialogInnerW(DIALOG_W)).length : 0);
+}
+
+/** PURE — total box height for a geometry (empty lists still show one
+ *  placeholder row) — used for inside/outside containment. */
+export function dialogHeight(g: DialogGeom): number {
+  return g.headerRows + Math.max(1, g.visibleRows) + g.footerRows + 1;
+}
+
+/** PURE — the VISIBLE hit-testable row index under (x, y), or -1. x must be
+ *  inside the box interior (borders excluded); only real rows hit. */
+export function dialogRowAt(g: DialogGeom, x: number, y: number): number {
+  if (x < g.left + 1 || x >= g.left + g.width - 1) return -1;
+  const row = y - (g.top + g.headerRows);
+  return row >= 0 && row < g.visibleRows ? row : -1;
+}
+
+/** PURE — whether (x, y) falls anywhere on the box (border included). A press
+ *  outside pops ONE stack level; inside-but-not-a-row is a no-op. */
+export function dialogContains(g: DialogGeom, x: number, y: number): boolean {
+  return x >= g.left && x < g.left + g.width && y >= g.top && y < g.top + dialogHeight(g);
+}
+
+// ── Row / footer text ────────────────────────────────────────────────────────
+
+/** PURE — a select row's leading marker: `● ` on the current value (kept even
+ *  while selected — the value marker is the point), else `› `/2 spaces. */
+export function dialogMarker(item: { current?: boolean }, selected: boolean): string {
+  if (item.current) return `${DIALOG_CURRENT_MARK} `;
+  return selected ? "› " : "  ";
+}
+
+/** PURE — a select row's body text: marker + label (+ the inline destructive
+ *  re-arm suffix when armed), with `detail` right-aligned in the interior
+ *  width; overlong labels truncate before the detail. */
+export function dialogRowText(
+  item: DialogSelectItem,
+  opts: { selected: boolean; armed: boolean; innerW: number },
+): string {
+  const marker = dialogMarker(item, opts.selected);
+  const label = opts.armed ? `${item.label}${DIALOG_CONFIRM_SUFFIX}` : item.label;
+  const detail = opts.armed ? "" : (item.detail ?? "");
+  const bodyW = opts.innerW - marker.length;
+  if (detail.length === 0) return marker + label.slice(0, bodyW).padEnd(bodyW);
+  const labelW = Math.max(1, bodyW - detail.length - 2);
+  return `${marker}${label.slice(0, labelW).padEnd(labelW)}  ${detail}`.slice(0, opts.innerW);
+}
+
+/** PURE — the select footer: key hints first, then the per-row actions, then
+ *  the caller's plain-language note. */
+export function selectFooter(spec: DialogSelectSpec): string {
+  const parts = ["enter select", "esc cancel"];
+  for (const a of spec.actions ?? []) parts.push(`^${a.key} ${a.label}`);
+  if (spec.footerHint) parts.push(spec.footerHint);
+  return parts.join(" · ");
+}
+
+/** PURE — the prompt footer: a busy note wins, then the validation error, then
+ *  the hint, then the default keys line. The `error` flag tells the render to
+ *  tint it as a problem. */
+export function promptFooter(
+  spec: DialogPromptSpec,
+  state: { error: string | null; busy: boolean },
+): { text: string; error: boolean } {
+  if (state.busy) return { text: "saving…", error: false };
+  if (state.error) return { text: state.error, error: true };
+  return { text: spec.footerHint ?? "enter save · esc cancel", error: false };
+}
+
+/** PURE — the confirm footer. */
+export function confirmFooter(): string {
+  return "enter choose · y/n · esc cancel";
+}
+
+/** PURE — the confirm option labels in row order (affirmative first). */
+export function confirmOptions(spec: DialogConfirmSpec): [string, string] {
+  return [spec.yesLabel ?? "Yes", spec.noLabel ?? "No"];
+}

package/packages/daemon/src/tui/mirror/dialog-stack.ts

@@ -0,0 +1,354 @@
+/**
+ * The global dialog STACK (M22.4) — one overlay mount in app.tsx renders
+ * whatever is on top; everything else is state here, framework-free so it
+ * unit-tests without OpenTUI.
+ *
+ * The API is Promise-based one-shots, so multi-step flows read as sequential
+ * awaits:
+ *
+ *   const choice = await DialogSelect.show({ title, items });
+ *   if (choice && (await DialogConfirm.show({ title: "Sure?" }))) { … }
+ *
+ * `push` may be called while another dialog is open — the new one stacks on
+ * top and only IT renders/receives input; resolving it reveals the one below.
+ * Escape (and a click outside the box) pops ONE level, resolving that dialog
+ * with its cancel value (`null`, or `false` for confirms). `replace` swaps the
+ * top in place; `clear` cancels the whole stack (quit paths).
+ *
+ * INPUT while a dialog is open is fully owned here: app.tsx feeds every key to
+ * {@link dialogKey} and every pointer event to its dialog route block FIRST, so
+ * nothing leaks to panes/editor underneath. Selection changes — keyboard and
+ * mouse alike — funnel through one place, which is where a select's `onMove`
+ * live-preview hook fires (never on open) and where an armed destructive row
+ * disarms.
+ *
+ * Solid bridge: the stack is not reactive; app.tsx subscribes and bumps a
+ * `dialogRev` signal on every notification (the `editorRev` idiom).
+ */
+import {
+  filterDialogItems,
+  initialSelIndex,
+  followTop,
+  clampDialogTop,
+  DIALOG_ROWS,
+  type DialogConfirmSpec,
+  type DialogPromptSpec,
+  type DialogSelectItem,
+  type DialogSelectResult,
+  type DialogSelectSpec,
+  type DialogSpec,
+} from "./dialog-model.ts";
+
+/** Mutable interaction state of one open dialog. */
+export interface DialogEntryState {
+  /** select: the filter query. */
+  query: string;
+  /** select/confirm: the selected row (select: index into the FILTERED list). */
+  sel: number;
+  /** select: the scroll window top. */
+  top: number;
+  /** select: the armed destructive row (filtered index), disarmed on any move. */
+  armed: number | null;
+  /** prompt: the typed value. */
+  input: string;
+  /** prompt: the current validation error. */
+  error: string | null;
+  /** prompt: a busy flag the caller may set while persisting. */
+  busy: boolean;
+}
+
+/** One stack entry: the spec, its interaction state, and the pending resolver. */
+export interface DialogEntry {
+  spec: DialogSpec;
+  state: DialogEntryState;
+  resolve: (result: unknown) => void;
+}
+
+function freshState(spec: DialogSpec): DialogEntryState {
+  return {
+    query: "",
+    sel:
+      spec.kind === "select"
+        ? initialSelIndex(spec)
+        : spec.kind === "confirm" && spec.defaultNo
+          ? 1
+          : 0,
+    top: 0,
+    armed: null,
+    input: spec.kind === "prompt" ? (spec.initial ?? "") : "",
+    error: null,
+    busy: false,
+  };
+}
+
+/** The cancel value a dismissed dialog resolves with. */
+function cancelValue(spec: DialogSpec): unknown {
+  return spec.kind === "confirm" ? false : null;
+}
+
+export interface DialogStack {
+  /** The rendered/driven entry — the top of the stack, or null. */
+  top(): DialogEntry | null;
+  depth(): number;
+  /** Re-render notifications (app.tsx bumps a signal). Returns unsubscribe. */
+  subscribe(fn: () => void): () => void;
+  /** Open a dialog ON TOP; resolves when it closes. */
+  push(spec: DialogSpec): Promise<unknown>;
+  /** Swap the top dialog in place (its promise resolves with the cancel value). */
+  replace(spec: DialogSpec): Promise<unknown>;
+  /** Resolve + remove the top entry. */
+  pop(result: unknown): void;
+  /** Pop ONE level with its cancel value — what Escape and a click outside do. */
+  dismiss(): void;
+  /** Cancel every open dialog (bottom-up resolves with cancel values). */
+  clear(): void;
+  /** The top select's rows for its current query. */
+  filtered(): DialogSelectItem[];
+  /** Move the selection by delta (select/confirm) — fires onMove, follows scroll. */
+  moveSel(delta: number): void;
+  /** Set the selection to a FILTERED index (mouse motion) — fires onMove. */
+  setSel(index: number): void;
+  /** Wheel: shift the select window top by delta rows. */
+  scrollBy(delta: number): void;
+  /** Activate a filtered row (enter / click): arms danger rows first. */
+  activate(index: number): void;
+  /** Confirm: resolve option 0 (true) / 1 (false). */
+  choose(option: number): void;
+  /** Prompt: mark busy (footer shows "saving…", input ignores keys). */
+  setBusy(busy: boolean): void;
+  /** Notify subscribers after a direct state mutation (query/input edits). */
+  touch(): void;
+}
+
+export function createDialogStack(): DialogStack {
+  const stack: DialogEntry[] = [];
+  const listeners = new Set<() => void>();
+  const notify = () => {
+    for (const fn of listeners) fn();
+  };
+
+  const top = () => stack[stack.length - 1] ?? null;
+
+  const filtered = (): DialogSelectItem[] => {
+    const e = top();
+    if (!e || e.spec.kind !== "select") return [];
+    return filterDialogItems(e.state.query, e.spec.items);
+  };
+
+  /** Central selection change — the ONLY place `sel` moves, so onMove and the
+   *  danger disarm can't be bypassed by one of the two input paths. */
+  const applySel = (next: number) => {
+    const e = top();
+    if (!e) return;
+    if (e.spec.kind === "confirm") {
+      e.state.sel = Math.max(0, Math.min(1, next));
+      notify();
+      return;
+    }
+    if (e.spec.kind !== "select") return;
+    const rows = filtered();
+    if (rows.length === 0) return;
+    const clamped = Math.max(0, Math.min(rows.length - 1, next));
+    if (clamped === e.state.sel) return;
+    e.state.sel = clamped;
+    e.state.armed = null;
+    e.state.top = followTop(clamped, e.state.top, DIALOG_ROWS);
+    e.spec.onMove?.(rows[clamped]!);
+    notify();
+  };
+
+  const pop = (result: unknown) => {
+    const e = stack.pop();
+    if (!e) return;
+    e.resolve(result);
+    notify();
+  };
+
+  return {
+    top,
+    depth: () => stack.length,
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    push(spec) {
+      return new Promise<unknown>((resolve) => {
+        stack.push({ spec, state: freshState(spec), resolve });
+        notify();
+      });
+    },
+    replace(spec) {
+      const e = stack.pop();
+      if (e) e.resolve(cancelValue(e.spec));
+      return new Promise<unknown>((resolve) => {
+        stack.push({ spec, state: freshState(spec), resolve });
+        notify();
+      });
+    },
+    pop,
+    dismiss() {
+      const e = top();
+      if (e) pop(cancelValue(e.spec));
+    },
+    clear() {
+      while (stack.length > 0) {
+        const e = stack.pop()!;
+        e.resolve(cancelValue(e.spec));
+      }
+      notify();
+    },
+    filtered,
+    moveSel(delta) {
+      const e = top();
+      if (!e) return;
+      applySel(e.state.sel + delta);
+    },
+    setSel(index) {
+      applySel(index);
+    },
+    scrollBy(delta) {
+      const e = top();
+      if (!e || e.spec.kind !== "select") return;
+      e.state.top = clampDialogTop(e.state.top + delta, filtered().length, DIALOG_ROWS);
+      notify();
+    },
+    activate(index) {
+      const e = top();
+      if (!e || e.spec.kind !== "select") return;
+      const rows = filtered();
+      const item = rows[index];
+      if (!item) return;
+      if (index !== e.state.sel) applySel(index);
+      if (item.danger && e.state.armed !== index) {
+        // Inline destructive confirm — the row itself asks again, no modal.
+        e.state.armed = index;
+        notify();
+        return;
+      }
+      pop({ item } satisfies DialogSelectResult);
+    },
+    choose(option) {
+      const e = top();
+      if (!e || e.spec.kind !== "confirm") return;
+      pop(option === 0);
+    },
+    setBusy(busy) {
+      const e = top();
+      if (!e || e.spec.kind !== "prompt") return;
+      e.state.busy = busy;
+      notify();
+    },
+    touch: notify,
+  };
+}
+
+/** THE stack — one per app process; the overlay mount and the routers all
+ *  address this instance. */
+export const dialogStack = createDialogStack();
+
+// ── One-shot façades (the exploration's API shape) ───────────────────────────
+
+export const DialogSelect = {
+  /** Open a select; resolves the chosen row (+ action key) or null on cancel. */
+  show(spec: Omit<DialogSelectSpec, "kind">, stack: DialogStack = dialogStack) {
+    return stack.push({ kind: "select", ...spec }) as Promise<DialogSelectResult | null>;
+  },
+};
+
+export const DialogPrompt = {
+  /** Open a prompt; resolves the (validated) text or null on cancel. */
+  show(spec: Omit<DialogPromptSpec, "kind">, stack: DialogStack = dialogStack) {
+    return stack.push({ kind: "prompt", ...spec }) as Promise<string | null>;
+  },
+};
+
+export const DialogConfirm = {
+  /** Open a two-option confirm; resolves true only on the affirmative. */
+  show(spec: Omit<DialogConfirmSpec, "kind">, stack: DialogStack = dialogStack) {
+    return stack.push({ kind: "confirm", ...spec }) as Promise<boolean>;
+  },
+};
+
+// ── The keyboard reducer ─────────────────────────────────────────────────────
+
+/** The key-event shape app.tsx feeds (matches its useKeyboard events). */
+export interface DialogKeyEvent {
+  name: string;
+  ctrl: boolean;
+  meta: boolean;
+  shift: boolean;
+}
+
+/**
+ * Feed one key to the stack's top dialog. Centralized ESCAPE lives here: it
+ * pops exactly one level. The caller must treat EVERY key as consumed while
+ * `stack.depth() > 0` (input suppression — nothing forwards to panes).
+ */
+export function dialogKey(stack: DialogStack, evt: DialogKeyEvent): void {
+  const e = stack.top();
+  if (!e) return;
+  const { spec, state } = e;
+  if (evt.name === "escape") {
+    stack.dismiss();
+    return;
+  }
+  if (spec.kind === "select") {
+    if (evt.name === "up") return stack.moveSel(-1);
+    if (evt.name === "down") return stack.moveSel(1);
+    if (evt.name === "return") return stack.activate(state.sel);
+    // Per-row actions ride ctrl+<key> so they never collide with filter typing.
+    if (evt.ctrl && evt.name.length === 1) {
+      const action = (spec.actions ?? []).find((a) => a.key === evt.name);
+      const item = stack.filtered()[state.sel];
+      if (action && item) {
+        stack.pop({ item, action: action.key } satisfies DialogSelectResult);
+      }
+      return;
+    }
+    if (spec.filterable === false) return;
+    if (evt.name === "backspace") {
+      state.query = state.query.slice(0, -1);
+      state.sel = 0;
+      state.top = 0;
+      state.armed = null;
+      return stack.touch();
+    }
+    if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
+      state.query += evt.shift ? evt.name.toUpperCase() : evt.name;
+      state.sel = 0;
+      state.top = 0;
+      state.armed = null;
+      return stack.touch();
+    }
+    return;
+  }
+  if (spec.kind === "prompt") {
+    if (state.busy) return; // a persisting prompt ignores edits
+    if (evt.name === "return") {
+      const err = spec.validate?.(state.input) ?? null;
+      if (err) {
+        state.error = err;
+        return stack.touch();
+      }
+      stack.pop(state.input);
+      return;
+    }
+    if (evt.name === "backspace") {
+      state.input = state.input.slice(0, -1);
+      state.error = null;
+      return stack.touch();
+    }
+    if (evt.name.length === 1 && !evt.ctrl && !evt.meta) {
+      state.input += evt.shift ? evt.name.toUpperCase() : evt.name;
+      state.error = null;
+      return stack.touch();
+    }
+    return;
+  }
+  // confirm
+  if (evt.name === "up" || evt.name === "left") return stack.setSel(0);
+  if (evt.name === "down" || evt.name === "right") return stack.setSel(1);
+  if (evt.name === "return") return stack.choose(state.sel);
+  if (evt.name === "y") return stack.choose(0);
+  if (evt.name === "n") return stack.choose(1);
+}