tmux-ide 2.7.0 → 2.8.0

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

@@ -12,7 +12,7 @@
  * never left guessing.
  */
 import type { AppConfig, AppConfigPatch, AppKeys } from "../../lib/app-config.ts";
-import { parseHHMM, type NotificationPrefs } from "../chrome/notify.ts";
+import { parseHHMM, type NotificationPrefs } from "../chrome/notify-prefs.ts";
 import type { DialogSelectItem } from "./dialog-model.ts";
 
 // ── Command registry (what the palette offers) ───────────────────────────────
@@ -107,24 +107,83 @@ export function themePatch(accent: string): AppConfigPatch {
 
 // ── Notifications ────────────────────────────────────────────────────────────
 
-export type NotificationToggleId = "enabled" | "toast" | "macos" | "onBlocked" | "onDone";
+export type NotificationToggleId =
+  | "enabled"
+  | "toast"
+  | "macos"
+  | "terminal"
+  | "onBlocked"
+  | "onDone";
 
 const onOff = (v: boolean) => (v ? "on" : "off");
 
 /** PURE — the notification toggle rows (the REAL fields notify.ts reads: the
- *  typed toast/macos plus the polish-era raw fields), and a quiet-hours row
- *  that descends into its own flow. Enter toggles in place. */
+ *  typed channel fields plus the polish-era raw fields), plus the rows that
+ *  descend into their own flows (sound tri-choice, delay prompt, quiet hours).
+ *  Enter toggles the boolean rows in place. */
 export function notificationItems(prefs: NotificationPrefs): DialogSelectItem[] {
   return [
     { id: "enabled", label: "All notifications", detail: onOff(prefs.enabled) },
     { id: "toast", label: "In-terminal toasts", detail: onOff(prefs.toast) },
-    { id: "macos", label: "macOS banners", detail: onOff(prefs.macos) },
+    { id: "macos", label: "System banners", detail: onOff(prefs.macos) },
+    { id: "terminal", label: "Terminal banners (OSC)", detail: onOff(prefs.terminal) },
     { id: "onBlocked", label: "Alert when an agent needs you", detail: onOff(prefs.onBlocked) },
     { id: "onDone", label: "Alert when an agent finishes", detail: onOff(prefs.onDone) },
+    { id: "sound", label: "Sound…", detail: soundSummary(prefs) },
+    { id: "delaySeconds", label: "Alert delay…", detail: delaySummary(prefs) },
     { id: "quietHours", label: "Quiet hours…", detail: quietHoursSummary(prefs) },
   ];
 }
 
+/** PURE — plain words for the sound tri-state. */
+export function soundSummary(prefs: NotificationPrefs): string {
+  return prefs.sound === "blocked" ? "when blocked" : prefs.sound === "all" ? "always" : "off";
+}
+
+/** PURE — the sound chooser rows (● on the saved choice). */
+export function soundItems(prefs: NotificationPrefs): DialogSelectItem[] {
+  return [
+    {
+      id: "blocked",
+      label: "When an agent needs you",
+      detail: "sound + terminal bell on blocked",
+      current: prefs.sound === "blocked",
+    },
+    {
+      id: "all",
+      label: "Every alert",
+      detail: "blocked and finished",
+      current: prefs.sound === "all",
+    },
+    { id: "none", label: "Off — no sound", current: prefs.sound === "none" },
+  ];
+}
+
+/** PURE — persist a picked sound mode. */
+export function soundPatch(id: string): AppConfigPatch {
+  return { notifications: { sound: id } };
+}
+
+/** PURE — "2 s" / "immediately". */
+export function delaySummary(prefs: NotificationPrefs): string {
+  return prefs.delaySeconds > 0 ? `${prefs.delaySeconds} s` : "immediately";
+}
+
+/** PURE — 0–60 whole seconds (0 = fire immediately; the delay exists to swallow
+ *  flappy transitions, and a minute is already generous). */
+export function validateDelaySeconds(value: string): string | null {
+  const n = Number(value.trim());
+  if (!Number.isInteger(n) || n < 0 || n > 60) {
+    return "Use a whole number of seconds between 0 and 60 (0 alerts immediately)";
+  }
+  return null;
+}
+
+/** PURE — persist a validated delay. */
+export function delaySecondsPatch(value: string): AppConfigPatch {
+  return { notifications: { delaySeconds: Number(value.trim()) } };
+}
+
 /** PURE — flip one notification toggle. */
 export function notificationTogglePatch(
   id: NotificationToggleId,
@@ -144,7 +203,7 @@ export function quietHoursItems(prefs: NotificationPrefs): DialogSelectItem[] {
     { id: "off", label: "Off — always notify", current: prefs.quietHours === null },
     {
       id: "window",
-      label: "Silence banners during a daily window…",
+      label: "Silence banners & sounds during a daily window…",
       detail: prefs.quietHours ? quietHoursSummary(prefs) : undefined,
       current: prefs.quietHours !== null,
     },
@@ -258,10 +317,35 @@ export function prefixTwinFor(altKey: string): string | null {
   return letter;
 }
 
+/** THE app-key enumeration — the ONE place the unified app's fixed keys are
+ *  listed (M24.4). The keybind viewer's app rows AND the palette's right-aligned
+ *  row shortcuts both read this; `paletteAction` is the stable palette action
+ *  key ({@link ./palette.ts}'s paletteActionKey) a keycap attaches to. */
+const APP_KEY_ROWS: ReadonlyArray<{ label: string; keycap: string; paletteAction?: string }> = [
+  { label: "Command palette", keycap: "F5 · ^p" },
+  { label: "Home tab", keycap: "F1", paletteAction: "tab:home" },
+  { label: "Terminal tab", keycap: "F2", paletteAction: "tab:terminal" },
+  { label: "Files tab", keycap: "F3", paletteAction: "tab:files" },
+  { label: "Diff tab", keycap: "F4", paletteAction: "tab:diff" },
+  { label: "Save file", keycap: "^s", paletteAction: "save" },
+  { label: "Back to Home", keycap: "^g" },
+  { label: "Toggle editor", keycap: "^e" },
+  { label: "Quit / detach", keycap: "^q", paletteAction: "quit" },
+];
+
+/** PURE — palette action key → keycap, derived from {@link APP_KEY_ROWS}. The
+ *  palette right-aligns these on rows that have one; app.tsx drops `quit` in
+ *  HOSTED mode, where ^q detaches instead. */
+export const PALETTE_KEYCAPS: Readonly<Record<string, string>> = Object.fromEntries(
+  APP_KEY_ROWS.filter((r) => r.paletteAction).map((r) => [r.paletteAction!, r.keycap]),
+);
+
 /** PURE — the read-only shortcut rows: the chrome actions from the LIVE config
  *  (prefix-first, the Alt fast path second — the prefix form is the one that
- *  survives every keyboard protocol) and then the app's fixed keys. */
-export function keybindingItems(keys: AppKeys): DialogSelectItem[] {
+ *  survives every keyboard protocol) and then the app's fixed keys
+ *  ({@link APP_KEY_ROWS}). `superK` appends the kitty-protocol ⌘K fast path to
+ *  the palette row — shown only when the renderer actually enables it. */
+export function keybindingItems(keys: AppKeys, superK = false): DialogSelectItem[] {
   const chrome: Array<{ label: string; altKey: string }> = [
     { label: "Home cockpit", altKey: keys.home },
     { label: "Session switcher", altKey: keys.popup },
@@ -280,14 +364,10 @@ export function keybindingItems(keys: AppKeys): DialogSelectItem[] {
       detail: twin ? `prefix ${twin} · ${altKey}` : altKey,
     };
   });
-  const app: Array<[string, string]> = [
-    ["Command palette", "F5 · ^p"],
-    ["Home / Terminal / Files / Diff tabs", "F1–F4"],
-    ["Back to Home", "^g"],
-    ["Toggle editor", "^e"],
-    ["Detach from the app", "^q"],
-  ];
-  for (const [label, detail] of app) rows.push({ id: `app:${label}`, label, detail });
+  for (const { label, keycap } of APP_KEY_ROWS) {
+    const detail = superK && label === "Command palette" ? `${keycap} · ⌘K` : keycap;
+    rows.push({ id: `app:${label}`, label, detail });
+  }
   return rows;
 }
 

package/packages/daemon/src/tui/mirror/sidebar.tsx

@@ -0,0 +1,218 @@
+/**
+ * The sidebar — the fleet nav column. Extracted from app.tsx (M26) as a PURE
+ * PRESENTATIONAL component: it renders, it does not fetch, resolve, or route.
+ *
+ * Everything it needs arrives as props, which is what lets TWO hosts render the
+ * same component:
+ *
+ *   - the terminal app (app.tsx) — OpenTUI's native renderer, over tmux
+ *   - the web (docs/tui-web)     — a solid-js universal renderer over DOM
+ *
+ * Consequently: NO node imports, NO tmux, NO app state. The only pointer surface
+ * is `onMouse` on the root box, carrying CELL coordinates — the same contract in
+ * both hosts (the web host synthesizes cells from DOM events), so the router
+ * (`sidebarHit`) is shared too rather than reimplemented per host.
+ *
+ * Row order is the CALLER's: pass agents already sorted (app's `fleetAgents`
+ * memo applies `sortAgentRows`). Sorting here would double-sort and let the two
+ * hosts silently disagree with the palette's jump list, which reads the same memo.
+ *
+ * The y-accounting this render implies — title, rule, session rows, gap, agents
+ * header, agent rows — is reversed by `sidebarHit` in agent-rows.ts. The two MUST
+ * move together; that's why AGENTS_GAP_ROWS is shared rather than a literal here.
+ */
+import { For, Show } from "solid-js";
+import { STATUS_COLOR, STATUS_GLYPH } from "./status-grammar.ts";
+import {
+  AGENTS_ADD_CHIP,
+  AGENTS_EMPTY_LINE,
+  AGENTS_GAP_ROWS,
+  agentAgeLabel,
+  agentDisplayKind,
+  agentRowLabel,
+  agentsHeaderLabel,
+  type AgentRowInput,
+} from "./agent-rows.ts";
+import {
+  ACCENT,
+  BUTTON_HOVER_BG,
+  CHIP_ATTN_BG,
+  DEFAULT_FG,
+  HOVER_BG,
+  MUTED,
+  SIDEBAR_BG,
+  TAB_ACTIVE_BG,
+} from "./theme.ts";
+import type { AgentStatus } from "../detect/classify.ts";
+
+/** A session row: the fleet's name + its rolled-up status. */
+export interface SidebarSession {
+  name: string;
+  status: AgentStatus;
+}
+
+/** The hover regions the sidebar owns. A subset of app.tsx's HoverRegion — kept
+ *  structural so the host's wider union assigns without a cast. */
+export type SidebarHoverRegion =
+  | "sidebar"
+  | "sidebaragent"
+  | "agentshdr"
+  | "agentschip"
+  | "sidebtn";
+
+/** The pointer event shape (structurally OpenTUI's MouseEvent; app.tsx's
+ *  RouteEvent assigns to it). Cell coordinates, not pixels. */
+export interface SidebarMouseEvent {
+  type: string;
+  x: number;
+  y: number;
+}
+
+export interface SidebarProps {
+  /** Column width in cells. */
+  width: number;
+  sessions: SidebarSession[];
+  /** Pre-sorted, attention-first (see the note above). */
+  agents: AgentRowInput[];
+  /** The session whose workspace is open — renders as the active row. */
+  current: string;
+  /** Epoch SECONDS, injected so the age readout is testable and the component
+   *  stays clock-free. */
+  nowSec: number;
+  isHovered: (region: SidebarHoverRegion, index: number) => boolean;
+  /** M25.1 attention flash, by pane id. */
+  flashed: (paneId: string) => boolean;
+  /** The footer hint's three runs — the middle one is the clickable chip whose
+   *  cells the router hit-tests (SIDEBAR_HINT_SPAN). Passed in because the quit
+   *  hint differs by host. */
+  hint: { pre: string; btn: string; post: string };
+  onMouse?: (e: SidebarMouseEvent) => void;
+}
+
+export function Sidebar(props: SidebarProps) {
+  return (
+    <box
+      width={props.width}
+      flexDirection="column"
+      backgroundColor={SIDEBAR_BG}
+      paddingLeft={1}
+      overflow="hidden"
+      onMouse={(e: SidebarMouseEvent) => props.onMouse?.(e)}
+    >
+      <text fg={ACCENT} attributes={1}>
+        tmux-ide
+      </text>
+      <text fg={MUTED}>{"─".repeat(props.width - 2)}</text>
+      <box flexDirection="column">
+        <For each={props.sessions}>
+          {(s, i) => (
+            <box
+              flexDirection="row"
+              gap={1}
+              backgroundColor={
+                s.name === props.current
+                  ? TAB_ACTIVE_BG
+                  : props.isHovered("sidebar", i())
+                    ? HOVER_BG
+                    : SIDEBAR_BG
+              }
+            >
+              <text fg={STATUS_COLOR[s.status]}>{STATUS_GLYPH[s.status]}</text>
+              <text fg={s.name === props.current ? DEFAULT_FG : MUTED}>
+                {s.name.slice(0, props.width - 5)}
+              </text>
+            </box>
+          )}
+        </For>
+      </box>
+      {/* AGENTS section (M22.2): the fleet's agents at a glance, one row per
+        agent, sorted attention-first, each a JUMP target (click → its
+        session/window/pane). REUSES the session rows' glyph + state-color
+        grammar. Hover reveals the state age. */}
+      <box flexDirection="column" marginTop={AGENTS_GAP_ROWS}>
+        {/* Header row (M24.1): label + a right-aligned [+ agent] chip. The row
+          body opens the TEAM dialog, the chip spawns; the router x-tests
+          `agentsChipSpans` — the flexGrow spacer lays the chip on exactly those
+          cells. The empty state keeps a chip twin so spawning is discoverable
+          before any agent runs. */}
+        <box
+          flexDirection="row"
+          backgroundColor={props.isHovered("agentshdr", 0) ? HOVER_BG : SIDEBAR_BG}
+        >
+          <text fg={MUTED} attributes={1}>
+            {agentsHeaderLabel(
+              props.agents.length,
+              Math.max(1, props.width - AGENTS_ADD_CHIP.length - 2),
+            )}
+          </text>
+          <box flexGrow={1} />
+          <text fg={MUTED} bg={props.isHovered("agentschip", 0) ? BUTTON_HOVER_BG : SIDEBAR_BG}>
+            {AGENTS_ADD_CHIP}
+          </text>
+        </box>
+        <Show
+          when={props.agents.length > 0}
+          fallback={
+            <box flexDirection="row">
+              <text fg={MUTED}>
+                {AGENTS_EMPTY_LINE.slice(0, Math.max(1, props.width - AGENTS_ADD_CHIP.length - 2))}
+              </text>
+              <box flexGrow={1} />
+              <text fg={MUTED} bg={props.isHovered("agentschip", 1) ? BUTTON_HOVER_BG : SIDEBAR_BG}>
+                {AGENTS_ADD_CHIP}
+              </text>
+            </box>
+          }
+        >
+          <For each={props.agents}>
+            {(a, i) => {
+              const hovered = () => props.isHovered("sidebaragent", i());
+              const ageShown = () =>
+                hovered() ? agentAgeLabel(a.state, a.since, props.nowSec) : null;
+              const labelBudget = () => {
+                const age = ageShown();
+                return props.width - 5 - (age ? age.length + 1 : 0);
+              };
+              // Blocked is the attention state: bold, matching the statusline's
+              // grammar (`blocked` reads bold there too).
+              const attn = () => (a.state === "blocked" ? 1 : 0);
+              const flashed = () => props.flashed(a.paneId);
+              return (
+                <box
+                  flexDirection="row"
+                  gap={1}
+                  backgroundColor={flashed() ? CHIP_ATTN_BG : hovered() ? HOVER_BG : SIDEBAR_BG}
+                >
+                  <text fg={STATUS_COLOR[a.state]} attributes={attn()}>
+                    {STATUS_GLYPH[a.state]}
+                  </text>
+                  <text
+                    fg={a.state === "blocked" ? STATUS_COLOR.blocked : MUTED}
+                    attributes={attn()}
+                  >
+                    {agentRowLabel(agentDisplayKind(a), a.session, labelBudget())}
+                  </text>
+                  <Show when={ageShown()}>
+                    <box flexGrow={1} />
+                    <text fg={MUTED}>{ageShown()}</text>
+                  </Show>
+                </box>
+              );
+            }}
+          </For>
+        </Show>
+      </box>
+      <box flexGrow={1} />
+      {/* Footer hint — its middle segment is a CHIP (M21.9): the router
+        hit-tests SIDEBAR_HINT_SPAN on the last screen row, and these three runs
+        render the exact same cells. */}
+      <box flexDirection="row">
+        <text fg={MUTED}>{props.hint.pre}</text>
+        <text fg={MUTED} bg={props.isHovered("sidebtn", 0) ? BUTTON_HOVER_BG : SIDEBAR_BG}>
+          {props.hint.btn}
+        </text>
+        <text fg={MUTED}>{props.hint.post}</text>
+      </box>
+    </box>
+  );
+}

package/packages/daemon/src/tui/mirror/size-truth.ts

@@ -10,6 +10,18 @@
  * mismatch from the pane layout, center the grid inside the canvas, and format
  * the quiet honest hint. No tmux, no render loop — unit-tested in isolation; the
  * app reads the pane geometry and the pinned canvas size and wires the rest.
+ *
+ * KNOWN GAP, measured (M25.5, tmux 3.7b): when TWO app processes mirror the
+ * same session (one per terminal — the non-hosted double-open), the later
+ * control client's boot pin wins `window-size latest`, and the other app can
+ * NEVER re-win it by interaction — the keys/mouse it forwards travel as
+ * control-client `send-keys` commands, which do not update tmux's
+ * latest-client
+ * bookkeeping (measured: local keystroke and wheel left the window at the
+ * other app's pin). The hint + the palette's "Resize to fit" verb are the
+ * designed escape; the structural fix is the hosted cockpit (`--detachable`),
+ * where one app process serves every terminal and REAL clients attach to the
+ * host session, whose native latest handling re-adopts on attach/focus/detach.
  */
 
 export interface Size {
@@ -66,6 +78,47 @@ export function letterboxOffset(canvas: Size, content: Size): { x: number; y: nu
   };
 }
 
+/** An in-flight re-pin (M23.5): we changed our pinned size and tmux has not
+ *  confirmed the new layout yet. `prev` is the pin BEFORE this re-pin. */
+export interface RepinState {
+  prev: Size;
+  at: number;
+}
+
+/** How long any mismatch is suppressed after a re-pin (server round-trip +
+ *  layout-change latency is sub-ms; the margin covers a loaded machine). */
+export const REPIN_GRACE_MS = 400;
+/** How long a mismatch that still equals the PRE-repin pin is suppressed — the
+ *  unambiguous "tmux hasn't applied our new pin yet" signature can wait longer
+ *  before we call it another terminal's doing. */
+export const REPIN_STALE_GRACE_MS = 1500;
+
+/**
+ * PURE — {@link detectSizeMismatch}, gated for the re-pin transition (M23.5,
+ * D4b): between our `refresh-client -C` and tmux's `%layout-change` the
+ * effective size is legitimately stale, and surfacing it flashed a false
+ * "window sized by another terminal" hint plus a letterbox jump-to-center on
+ * EVERY grow (measured). Suppress the mismatch while a re-pin is in flight:
+ * any mismatch within {@link REPIN_GRACE_MS}, and — for longer, up to
+ * {@link REPIN_STALE_GRACE_MS} — one whose effective size still equals the
+ * pre-repin pin exactly (that shape can only be the old pin, not a co-attached
+ * terminal's choice). Past the grace the honest hint returns.
+ */
+export function detectSizeMismatchWithRepin(
+  pinned: Size,
+  effective: Size,
+  repin: RepinState | null,
+  now: number,
+): Size | null {
+  const mm = detectSizeMismatch(pinned, effective);
+  if (!mm || !repin) return mm;
+  const age = now - repin.at;
+  if (age < REPIN_GRACE_MS) return null;
+  const isPrevPin = effective.cols === repin.prev.cols && effective.rows === repin.prev.rows;
+  if (isPrevPin && age < REPIN_STALE_GRACE_MS) return null;
+  return mm;
+}
+
 /**
  * PURE — the quiet, plain-language hint for a size mismatch: the honest answer
  * ("here is the size another terminal chose"), dimensions in the terminal-native

package/packages/daemon/src/tui/mirror/theme.ts

@@ -0,0 +1,45 @@
+/**
+ * The unified app's color tokens — PURE data, hoisted out of app.tsx (M26) so
+ * the surfaces extracted from it (starting with {@link ./sidebar.tsx}) carry
+ * their palette with them instead of reaching back into a 21k-line module.
+ *
+ * Companion to {@link ./status-grammar.ts}: that file owns the per-AGENT-STATE
+ * glyph + hue (a status signal), this one owns the CHROME (surface, accent,
+ * hover, selection). Keep the two families distinct — focus is an accent signal,
+ * agent state is a status signal, and they must never collide on a hue.
+ *
+ * Node-free on purpose: the web host (docs/tui-web) imports this module
+ * verbatim, aliasing @opentui/core to a browser shim for RGBA.
+ */
+import { RGBA } from "@opentui/core";
+
+export const DEFAULT_FG = RGBA.fromInts(212, 212, 216, 255);
+export const DEFAULT_BG = RGBA.fromInts(16, 16, 22, 255);
+
+/** The sidebar's surface — one lift above DEFAULT_BG so the nav column reads as
+ *  chrome, not as content. */
+export const SIDEBAR_BG = RGBA.fromInts(22, 22, 30, 255);
+export const ACCENT = RGBA.fromInts(130, 170, 255, 255);
+export const MUTED = RGBA.fromInts(110, 110, 130, 255);
+export const BADGE_BG = RGBA.fromInts(60, 66, 92, 255);
+
+/** Focused-pane gutter hairline (M22.7): the ACCENT family, drawn as │/─ glyphs
+ *  so the gutter stays visually thin (a filled bar read as extra padding — user
+ *  feedback). Doesn't compete with the blocked chip's red — focus is an accent
+ *  signal, agent state is a status signal, never the same hue. */
+export const FOCUS_BORDER_FG = RGBA.fromInts(110, 145, 230, 255);
+
+/** The selected row/tab. Always wins over HOVER_BG. */
+export const TAB_ACTIVE_BG = RGBA.fromInts(40, 46, 66, 255);
+
+/** A single subtle pointer-hover tint, one lift above both DEFAULT_BG (16,16,22)
+ *  and SIDEBAR_BG (22,22,30) and below TAB_ACTIVE_BG — the active/selected state
+ *  always wins over hover. Used on every hoverable row/segment. */
+export const HOVER_BG = RGBA.fromInts(30, 34, 48, 255);
+
+/** A chip/button under the pointer. */
+export const BUTTON_HOVER_BG = RGBA.fromInts(52, 60, 86, 255);
+
+/** The attention flash (M25.1): a just-flipped hidden agent's row pulses this
+ *  for a beat — the status-strip note's "look here" twin. */
+export const CHIP_ATTN_BG = RGBA.fromInts(92, 44, 48, 255);

package/packages/daemon/src/tui/team/fuzzy.ts

@@ -24,6 +24,15 @@ const START_BONUS = 10; // matched char is the first char of the target
 const SEPARATOR_BONUS = 8; // matched char follows a separator (word start)
 const CONTIGUOUS_BONUS = 5; // matched char is adjacent to the previous match
 const BASE = 1; // every matched char is worth at least this
+// Whole-alignment extra when the query is a contiguous PREFIX of the target
+// (M24.4): typing a label's start must rank that label above mid-word runs
+// AND above scattered matches that rack up several word-start bonuses —
+// measured: "save" scored 29 on "Save file" but 30 on "swap pane view east"
+// (three word-start hits). Sized to dominate realistic competitors (a
+// non-prefix alignment outscores a prefix only past ~8 all-word-start chars);
+// word-boundary preference WITHIN non-prefix matches is untouched ("web"
+// still anchors on the "web" of `wavyr-website`, not the leading "w").
+const PREFIX_EXTRA = 24;
 
 /**
  * Case-insensitive subsequence match of `query` against `target`.
@@ -106,6 +115,17 @@ export function fuzzyMatch(
   }
   if (start === -1) return null;
 
+  // The exact/prefix tier (M24.4): when the query IS the target's start, that
+  // alignment (positions 0..m-1) + PREFIX_EXTRA competes with the DP's best —
+  // and effectively always wins, so prefix matches rank first however many
+  // word-start bonuses a scattered alignment collected.
+  if (t.startsWith(q)) {
+    const prefixScore = m * BASE + START_BONUS + (m - 1) * CONTIGUOUS_BONUS + PREFIX_EXTRA;
+    if (prefixScore >= bestScore) {
+      return { score: prefixScore, positions: Array.from({ length: m }, (_, i) => i) };
+    }
+  }
+
   const positions: number[] = [];
   let j = start;
   for (let i = 0; i < m && j !== -1; i++) {