@cueloop/client 0.1.0-alpha.63 → 0.1.0-alpha.64

package/src/config.ts

@@ -12,6 +12,7 @@ import { join } from "node:path";
 import { OBSIDIAN_DEFAULTS, type ObsidianConfig } from "@cueloop/integration-obsidian";
 import { writeFileSync, mkdirSync } from "node:fs";
 import { dirname } from "node:path";
+import * as v from "valibot";
 import { DARK, type Theme } from "./theme";
 import { DEFAULT_THEME_NAME, isThemeName, themeForName, type ThemeName } from "./theme-presets";
 import { REVIEW_DEFAULT_WIDTH, clampWidth, type ReviewPanelMode } from "./review-panel";
@@ -112,7 +113,7 @@ export interface CueloopConfig {
 }
 
 /** Every action in the grammar, with its default binding(s). */
-export const DEFAULT_KEYS: Record<string, string[]> = {
+export const DEFAULT_KEYS: CueloopConfig["keys"] = {
   down: ["j", "down"],
   up: ["k", "up"],
   top: ["g"],
@@ -136,100 +137,87 @@ export const DEFAULT_KEYS: Record<string, string[]> = {
   review_narrower: ["["],
 };
 
-function parseToml(text: string): Record<string, unknown> {
-  // Bun ships a native TOML parser
-  return Bun.TOML.parse(text) as Record<string, unknown>;
+const ConfigDocumentSchema = v.object({
+  actions: v.optional(v.array(v.unknown())),
+  authors: v.optional(v.unknown()),
+  integrations: v.optional(v.unknown()),
+  keys: v.optional(v.unknown()),
+  theme: v.optional(v.unknown()),
+  ui: v.optional(v.unknown()),
+});
+
+const QuickActionSchema = v.object({
+  prompt: v.pipe(
+    v.string(),
+    v.check((prompt) => Boolean(prompt.trim())),
+  ),
+  metadata: v.optional(v.string()),
+});
+
+const AuthorsSchema = v.record(v.string(), v.unknown());
+const KeysSchema = v.record(v.string(), v.unknown());
+const KeyComboSchema = v.union([v.string(), v.array(v.string())]);
+// Every field falls back to undefined on its own, so one bad value in a
+// section never discards the section's other settings.
+const UiSchema = v.object({
+  auto_close: v.fallback(
+    v.optional(v.union([v.literal("off"), v.pipe(v.number(), v.minValue(0))])),
+    undefined,
+  ),
+  editor: v.fallback(v.optional(v.string()), undefined),
+  review_width: v.fallback(v.optional(v.pipe(v.number(), v.finite())), undefined),
+  review_state: v.fallback(v.optional(v.picklist(["expanded", "compact", "hidden"])), undefined),
+  theme: v.fallback(v.optional(v.string()), undefined),
+});
+const ObsidianSchema = v.object({
+  vault: v.fallback(v.optional(v.string()), undefined),
+  folder: v.fallback(v.optional(v.string()), undefined),
+  filenameFormat: v.fallback(v.optional(v.string()), undefined),
+  separator: v.fallback(v.optional(v.picklist(["space", "dash", "underscore"])), undefined),
+  exportOn: v.fallback(v.optional(v.picklist(["approve", "resolve", "manual"])), undefined),
+});
+const IntegrationsSchema = v.object({ obsidian: v.optional(ObsidianSchema) });
+const ThemeOverridesSchema = v.record(v.string(), v.unknown());
+
+function isThemeToken(token: string): token is keyof Theme {
+  return token in DARK;
 }
 
-/**
- * Parse a `[[actions]]` array-of-tables. A table without a non-empty `prompt`
- * is skipped; any valid table REPLACES the defaults (the whole set is the
- * user's, not merged). Returns undefined when nothing usable is present.
- */
-function parseActions(raw: unknown): QuickAction[] | undefined {
-  if (!Array.isArray(raw)) return undefined;
-  const actions: QuickAction[] = [];
-
-  for (const entry of raw) {
-    if (!entry || typeof entry !== "object") continue;
-    const table = entry as Record<string, unknown>;
-    const prompt = table["prompt"];
-
-    if (typeof prompt !== "string" || !prompt.trim()) continue;
-    const metadata = table["metadata"];
-
-    actions.push(
-      typeof metadata === "string" && metadata.trim() ? { prompt, metadata } : { prompt },
-    );
-  }
-
-  return actions.length ? actions : undefined;
+function parseToml(text: string) {
+  return v.parse(ConfigDocumentSchema, Bun.TOML.parse(text));
 }
 
-function mergeAuthors(target: Record<string, string>, raw: unknown): void {
-  const authors = raw as Record<string, unknown> | undefined;
+function parseActions(entries: readonly unknown[] | undefined): QuickAction[] | undefined {
+  if (!entries) return undefined;
+  const actions: QuickAction[] = [];
 
-  if (!authors) return;
-  for (const [id, value] of Object.entries(authors)) {
-    if (typeof value === "string") target[id] = value;
-  }
-}
+  for (const entry of entries) {
+    const result = v.safeParse(QuickActionSchema, entry);
 
-function mergeKeys(target: Record<string, string[]>, raw: unknown): void {
-  const keys = raw as KeymapConfig | undefined;
+    if (!result.success) continue;
+    const { prompt, metadata } = result.output;
 
-  if (!keys) return;
-  for (const [action, combo] of Object.entries(keys)) {
-    target[action] = Array.isArray(combo) ? combo : [combo];
+    actions.push(metadata?.trim() ? { prompt, metadata } : { prompt });
   }
-}
 
-function mergeAutoClose(target: CueloopConfig["ui"], value: unknown): void {
-  if (value === undefined) return;
-  if (value === "off") target.autoClose = "off";
-  else if (typeof value === "number" && value >= 0) target.autoClose = value;
-}
-
-function mergeUi(target: CueloopConfig["ui"], raw: unknown): void {
-  const ui = raw as
-    | { auto_close?: unknown; editor?: unknown; review_width?: unknown; review_state?: unknown }
-    | undefined;
-
-  if (!ui) return;
-  mergeAutoClose(target, ui.auto_close);
-  if (typeof ui.editor === "string" && ui.editor.trim()) target.editor = ui.editor.trim();
-  if (typeof ui.review_width === "number" && Number.isFinite(ui.review_width)) {
-    target.reviewWidth = clampWidth(ui.review_width);
-  }
-  if (
-    ui.review_state === "expanded" ||
-    ui.review_state === "compact" ||
-    ui.review_state === "hidden"
-  ) {
-    target.reviewState = ui.review_state;
-  }
+  return actions.length ? actions : undefined;
 }
 
-function mergeObsidian(target: ObsidianConfig, raw: unknown): void {
-  const integrations = raw as Record<string, unknown> | undefined;
-  const obsidian = integrations?.["obsidian"] as Record<string, unknown> | undefined;
-
-  if (!obsidian) return;
-  if (typeof obsidian["vault"] === "string") target.vault = obsidian["vault"];
-  if (typeof obsidian["folder"] === "string") target.folder = obsidian["folder"];
-  if (typeof obsidian["filenameFormat"] === "string")
-    target.filenameFormat = obsidian["filenameFormat"];
-  const separator = obsidian["separator"];
-
-  if (separator === "space" || separator === "dash" || separator === "underscore")
-    target.separator = separator;
-  const exportOn = obsidian["exportOn"];
-
-  if (exportOn === "approve" || exportOn === "resolve" || exportOn === "manual")
-    target.exportOn = exportOn;
+function mergeObsidian(
+  target: ObsidianConfig,
+  obsidian: v.InferOutput<typeof ObsidianSchema>,
+): void {
+  if (obsidian.vault !== undefined) target.vault = obsidian.vault;
+  if (obsidian.folder !== undefined) target.folder = obsidian.folder;
+  if (obsidian.filenameFormat !== undefined) target.filenameFormat = obsidian.filenameFormat;
+  if (obsidian.separator !== undefined) target.separator = obsidian.separator;
+  if (obsidian.exportOn !== undefined) target.exportOn = obsidian.exportOn;
 }
 
-function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig {
+function layer(
+  base: CueloopConfig,
+  raw: v.InferOutput<typeof ConfigDocumentSchema>,
+): CueloopConfig {
   const out: CueloopConfig = {
     keys: { ...base.keys },
     theme: { ...base.theme },
@@ -239,13 +227,38 @@ function layer(base: CueloopConfig, raw: Record<string, unknown>): CueloopConfig
     actions: [...base.actions],
     integrations: { obsidian: { ...base.integrations.obsidian } },
   };
-  const actions = parseActions(raw["actions"]);
+  const actions = parseActions(raw.actions);
+  const authors = v.safeParse(AuthorsSchema, raw.authors);
+  const keys = v.safeParse(KeysSchema, raw.keys);
+  const ui = v.safeParse(UiSchema, raw.ui);
+  const integrations = v.safeParse(IntegrationsSchema, raw.integrations);
 
   if (actions) out.actions = actions;
-  mergeAuthors(out.authors, raw["authors"]);
-  mergeKeys(out.keys, raw["keys"]);
-  mergeUi(out.ui, raw["ui"]);
-  mergeObsidian(out.integrations.obsidian, raw["integrations"]);
+  if (authors.success) {
+    for (const [id, value] of Object.entries(authors.output)) {
+      const name = v.safeParse(v.string(), value);
+
+      if (name.success) out.authors[id] = name.output;
+    }
+  }
+  if (keys.success) {
+    for (const [action, value] of Object.entries(keys.output)) {
+      const combo = v.safeParse(KeyComboSchema, value);
+
+      if (combo.success)
+        out.keys[action] = Array.isArray(combo.output) ? combo.output : [combo.output];
+    }
+  }
+  if (ui.success) {
+    if (ui.output.auto_close !== undefined) out.ui.autoClose = ui.output.auto_close;
+    if (ui.output.editor?.trim()) out.ui.editor = ui.output.editor.trim();
+    if (ui.output.review_width !== undefined)
+      out.ui.reviewWidth = clampWidth(ui.output.review_width);
+    if (ui.output.review_state !== undefined) out.ui.reviewState = ui.output.review_state;
+  }
+  if (integrations.success && integrations.output.obsidian) {
+    mergeObsidian(out.integrations.obsidian, integrations.output.obsidian);
+  }
 
   return out;
 }
@@ -284,10 +297,18 @@ export function loadConfig(
       const raw = parseToml(readFileSync(path, "utf8"));
 
       config = layer(config, raw);
-      const rawTheme = (raw["ui"] as { theme?: unknown } | undefined)?.theme;
-
-      if (typeof rawTheme === "string" && isThemeName(rawTheme)) themeName = rawTheme;
-      collectThemeOverrides(raw["theme"], themeOverrides);
+      const ui = v.safeParse(UiSchema, raw.ui);
+      const rawTheme = ui.success ? ui.output.theme : undefined;
+      const parsedThemeOverrides = v.safeParse(ThemeOverridesSchema, raw.theme);
+
+      if (rawTheme && isThemeName(rawTheme)) themeName = rawTheme;
+      if (parsedThemeOverrides.success) {
+        for (const [token, value] of Object.entries(parsedThemeOverrides.output)) {
+          const override = v.safeParse(v.string(), value);
+
+          if (override.success && isThemeToken(token)) themeOverrides[token] = override.output;
+        }
+      }
     } catch {
       // a broken config never blocks a review; defaults win
     }
@@ -299,14 +320,6 @@ export function loadConfig(
   return config;
 }
 
-/** Merge a raw `[theme]` table's known string tokens into the accumulated overrides. */
-function collectThemeOverrides(raw: unknown, into: Partial<Record<keyof Theme, string>>): void {
-  if (!raw || typeof raw !== "object") return;
-  for (const [token, value] of Object.entries(raw)) {
-    if (token in DARK && typeof value === "string") into[token as keyof Theme] = value;
-  }
-}
-
 /** Reverse lookup: key name (+shift) → action, per the loaded keymap. */
 export function actionFor(
   keys: Record<string, string[]>,

package/src/editor.ts

@@ -21,7 +21,11 @@ export interface EditResult {
 const DEFAULT_EDITOR = "nano";
 
 /** GUI editors fork and return immediately unless given their wait flag. */
-const GUI_WAIT_FLAGS: Record<string, string[]> = {
+interface GuiWaitFlags {
+  [editor: string]: string[];
+}
+
+const GUI_WAIT_FLAGS: GuiWaitFlags = {
   code: ["--wait"],
   "code-insiders": ["--wait"],
   codium: ["--wait"],

package/src/ghostty-terminal.test.ts

@@ -8,7 +8,7 @@ const factory = loadGhosttyTerminals();
 describe("ghostty-terminal FFI", () => {
   test("reports platform support without throwing", () => {
     // Assert - null on unsupported platforms, a factory where a dylib ships
-    expect(factory === null || typeof factory.create === "function").toBe(true);
+    expect(factory === null || factory.create !== undefined).toBe(true);
   });
 
   test.skipIf(!factory)("writes VT bytes and reads back decoded cells", () => {

package/src/herdr.ts

@@ -6,6 +6,12 @@
  * is best-effort - a failure never blocks closing the review.
  */
 
+import * as v from "valibot";
+
+const HerdrPaneSchema = v.object({
+  result: v.optional(v.object({ pane: v.optional(v.object({ tab_id: v.optional(v.string()) })) })),
+});
+
 /** Focus the tab holding the target pane. Synchronous: runs just before exit. */
 export function focusHerdrPane(binPath: string, paneId: string): boolean {
   try {
@@ -15,8 +21,10 @@ export function focusHerdrPane(binPath: string, paneId: string): boolean {
     });
 
     if (got.exitCode !== 0) return false;
-    const parsed = JSON.parse(got.stdout.toString()) as { result?: { pane?: { tab_id?: string } } };
-    const tab = parsed.result?.pane?.tab_id;
+    const parsed = v.safeParse(HerdrPaneSchema, JSON.parse(got.stdout.toString()));
+
+    if (!parsed.success) return false;
+    const tab = parsed.output.result?.pane?.tab_id;
 
     if (!tab) return false;
 

package/src/intent-dispatch.test.ts

@@ -6,54 +6,106 @@
  */
 
 import { describe, expect, mock, test } from "bun:test";
-import type { ReviewSession } from "@cueloop/schema";
+import type { SetStateAction } from "react";
+import { SCHEMA_VERSION, type Annotation, type ReviewSession } from "@cueloop/schema";
 import { createIntentDispatch, type IntentDispatchDeps } from "./intent-dispatch";
+import type { ControllerSnapshot, CurationItem, ReviewController } from "./session-controller";
 import type { DisplayBlock } from "./view-plan";
 
 function block(text: string): DisplayBlock {
-  return { text, kind: "text", work: true } as unknown as DisplayBlock;
+  return { type: "same", kind: "p", work: { kind: "p", text, lineStart: 0, lineEnd: 0 } };
 }
 
-function sessionWith(annotationIds: string[]): ReviewSession {
+function annotation(id: string, overrides: Partial<Annotation> = {}): Annotation {
   return {
-    annotations: annotationIds.map((id) => ({ id })),
-    workingCopy: undefined,
-  } as unknown as ReviewSession;
+    id,
+    kind: "comment",
+    anchor: { quote: "", prefix: "", suffix: "" },
+    body: "",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
+}
+
+function sessionWith(
+  annotations: Annotation[],
+  overrides: Partial<ReviewSession> = {},
+): ReviewSession {
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    id: "ses_1",
+    workspace: { repoRoot: "/repo", branch: "main" },
+    artifact: { type: "plan", content: "# Plan\n", meta: {} },
+    revisions: [],
+    annotations,
+    verdict: null,
+    status: "pending",
+    createdAt: "2026-01-01T00:00:00.000Z",
+    ...overrides,
+  };
 }
 
+const EMPTY_SNAPSHOT: ControllerSnapshot = {
+  session: null,
+  inbox: null,
+  status: "",
+  toast: null,
+  error: null,
+  completion: { phase: "idle" },
+  editOrphanCount: 0,
+  walk: null,
+};
+
 /** A controller where every verb is a mock; annotate returns undefined by default. */
-function baseController() {
+function baseController(): ReviewController {
   return {
+    readOnly: false,
+    subscribe: mock(() => () => {}),
+    getSnapshot: mock(() => EMPTY_SNAPSHOT),
+    connect: mock(),
+    close: mock(),
+    applyConfig: mock(),
     setStatus: mock(),
+    showToast: mock(),
+    dismissToast: mock(),
+    display: mock(() => []),
+    rows: mock(() => []),
+    files: mock(() => []),
+    working: mock(() => ""),
     open: mock(),
     deleteSession: mock(),
     setSelfName: mock(),
     cut: mock(),
+    toggleRejectHunk: mock(),
+    toggleRejectChange: mock(),
+    rejectedRows: mock(() => new Set<number>()),
     curationItems: mock(() => []),
     restoreCuration: mock(),
-    annotate: mock(),
-    annotatePrototype: mock(),
+    edit: mock(),
+    annotate: mock(() => undefined),
+    annotatePrototype: mock(() => undefined),
     updateAnnotation: mock(),
     removeAnnotation: mock(),
+    setWorkingCopy: mock(),
     walkStart: mock(),
     walkForward: mock(),
     walkBack: mock(),
     walkLeave: mock(),
     submit: mock(),
     share: mock(),
+    pullShared: mock(() => Promise.resolve()),
+    startSharePoll: mock(() => () => {}),
     finishReview: mock(),
-    optInAutoClose: mock(),
     dismissCompletion: mock(),
+    optInAutoClose: mock(),
     saveReviewPanel: mock(),
   };
 }
 
 /** A deps bag where every effect is a mock and every read has a plain default. */
 function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDeps {
-  const controller = baseController();
-
   return {
-    controller: controller as unknown as IntentDispatchDeps["controller"],
+    controller: baseController(),
     onExit: mock(),
     isDiff: false,
     display: [],
@@ -90,20 +142,24 @@ function makeDeps(overrides: Partial<IntentDispatchDeps> = {}): IntentDispatchDe
   };
 }
 
+function isUpdater(action: SetStateAction<number>): action is (current: number) => number {
+  return typeof action === "function";
+}
+
 describe("move", () => {
   test("down clamps at the last row and up clamps at the first", () => {
     // Arrange
-    const deps = makeDeps({ display: [block("a"), block("b"), block("c")] });
+    const setCursor = mock((_action: SetStateAction<number>) => {});
+    const deps = makeDeps({ display: [block("a"), block("b"), block("c")], setCursor });
     const dispatch = createIntentDispatch(deps);
 
     // Act
     dispatch({ type: "move", to: "down" });
 
     // Assert
-    const advance = (deps.setCursor as ReturnType<typeof mock>).mock.calls[0]![0] as (
-      current: number,
-    ) => number;
+    const advance = setCursor.mock.calls[0]![0];
 
+    if (!isUpdater(advance)) throw new Error("expected setCursor to receive an updater");
     expect(advance(2)).toBe(2); // already at the end, stays
     expect(advance(0)).toBe(1);
   });
@@ -124,7 +180,10 @@ describe("move", () => {
 describe("annotation navigation", () => {
   test("nextAnnotation wraps from the last annotation back to the first", () => {
     // Arrange
-    const deps = makeDeps({ session: sessionWith(["a1", "a2", "a3"]), focusedAnnotationId: "a3" });
+    const deps = makeDeps({
+      session: sessionWith([annotation("a1"), annotation("a2"), annotation("a3")]),
+      focusedAnnotationId: "a3",
+    });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -136,7 +195,10 @@ describe("annotation navigation", () => {
 
   test("prevAnnotation wraps from the first annotation to the last", () => {
     // Arrange
-    const deps = makeDeps({ session: sessionWith(["a1", "a2", "a3"]), focusedAnnotationId: "a1" });
+    const deps = makeDeps({
+      session: sessionWith([annotation("a1"), annotation("a2"), annotation("a3")]),
+      focusedAnnotationId: "a1",
+    });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -148,12 +210,11 @@ describe("annotation navigation", () => {
 
   test("cycling skips annotations a revision already addressed", () => {
     // Arrange: a2 is addressed, so next from a1 lands on a3
-    const session = sessionWith(["a1", "a2", "a3"]);
-
-    (session.annotations[1] as { resolution?: object }).resolution = {
-      revision: 2,
-      source: "agent",
-    };
+    const session = sessionWith([
+      annotation("a1"),
+      annotation("a2", { resolution: { revision: 2, source: "agent" } }),
+      annotation("a3"),
+    ]);
     const deps = makeDeps({ session, focusedAnnotationId: "a1" });
     const dispatch = createIntentDispatch(deps);
 
@@ -233,7 +294,7 @@ describe("marker-actions popover", () => {
       mode: { type: "spanActions", span, index: 1 },
       session: sessionWith([]),
       quickActions: [{ prompt: "Needs a test" }, { prompt: "YAGNI", metadata: "cut scope" }],
-      controller: { ...baseController(), annotate } as unknown as IntentDispatchDeps["controller"],
+      controller: { ...baseController(), annotate },
     });
     const dispatch = createIntentDispatch(deps);
 
@@ -253,7 +314,7 @@ describe("marker-actions popover", () => {
       mode: { type: "spanActions", span, index: 0 },
       session: sessionWith([]),
       quickActions: [{ prompt: "Needs a test" }, { prompt: "Extract the duplication" }],
-      controller: { ...baseController(), annotate } as unknown as IntentDispatchDeps["controller"],
+      controller: { ...baseController(), annotate },
     });
     const dispatch = createIntentDispatch(deps);
 
@@ -320,28 +381,15 @@ describe("share", () => {
 });
 
 describe("restoreCuration", () => {
-  const items = [
-    {
-      id: "diff:f#0#hunk",
-      source: "diff" as const,
-      label: "f:1 - hunk",
-      preview: [],
-      revealIndex: 1,
-    },
-    {
-      id: "diff:f#1#2",
-      source: "diff" as const,
-      label: "f:9 - change",
-      preview: [],
-      revealIndex: 9,
-    },
+  const items: CurationItem[] = [
+    { id: "diff:f#0#hunk", source: "diff", preview: [], revealIndex: 1 },
+    { id: "diff:f#1#2", source: "diff", preview: [], revealIndex: 9 },
   ];
 
   test("restores the selected item and clears the selection", () => {
     // Arrange
-    const deps = makeDeps({ selectedCurationId: "diff:f#1#2" });
-
-    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue(items);
+    const controller = { ...baseController(), curationItems: mock(() => items) };
+    const deps = makeDeps({ selectedCurationId: "diff:f#1#2", controller });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -354,9 +402,8 @@ describe("restoreCuration", () => {
 
   test("with nothing selected, undoes the last removal", () => {
     // Arrange
-    const deps = makeDeps({ selectedCurationId: undefined });
-
-    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue(items);
+    const controller = { ...baseController(), curationItems: mock(() => items) };
+    const deps = makeDeps({ selectedCurationId: undefined, controller });
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -369,8 +416,6 @@ describe("restoreCuration", () => {
   test("does nothing when there is nothing curated out", () => {
     // Arrange
     const deps = makeDeps();
-
-    (deps.controller.curationItems as ReturnType<typeof mock>).mockReturnValue([]);
     const dispatch = createIntentDispatch(deps);
 
     // Act
@@ -398,7 +443,9 @@ describe("exit", () => {
 describe("inbox delete", () => {
   test("requestDeleteSession opens the confirm on the cursor row", () => {
     // Arrange
-    const inbox = [{ id: "ses_1", artifact: { meta: { title: "Plan A" } } }] as never;
+    const inbox = [
+      sessionWith([], { artifact: { type: "plan", content: "", meta: { title: "Plan A" } } }),
+    ];
     const deps = makeDeps({ inbox, inboxCursor: 0 });
 
     // Act
@@ -428,7 +475,7 @@ describe("inbox delete", () => {
 describe("rename author", () => {
   test("openRename seeds the prompt with the author's current local name", () => {
     // Arrange
-    const session = { annotations: [{ id: "a1", author: "SHA256:x" }] } as never;
+    const session = sessionWith([annotation("a1", { author: "SHA256:x" })]);
     const deps = makeDeps({
       session,
       focusedAnnotationId: "a1",
@@ -448,7 +495,7 @@ describe("rename author", () => {
 
   test("openRename on your own note does nothing but explain", () => {
     // Arrange
-    const session = { annotations: [{ id: "a1" }] } as never;
+    const session = sessionWith([annotation("a1")]);
     const deps = makeDeps({ session, focusedAnnotationId: "a1" });
 
     // Act

package/src/intent-dispatch.ts

@@ -526,9 +526,11 @@ function handleResizeReviewPanel(
   deps.controller.saveReviewPanel({ width: next });
 }
 
-const intentHandlers: {
+type IntentHandlers = {
   [Kind in Intent["type"]]: (intent: IntentOfType<Kind>, deps: IntentDispatchDeps) => void;
-} = {
+};
+
+const intentHandlers: IntentHandlers = {
   exit: handleExit,
   status: handleStatus,
   move: handleMove,
@@ -572,14 +574,14 @@ const intentHandlers: {
   resizeReviewPanel: handleResizeReviewPanel,
 };
 
+function dispatchIntent<Kind extends Intent["type"]>(
+  intent: IntentOfType<Kind>,
+  deps: IntentDispatchDeps,
+): void {
+  intentHandlers[intent.type](intent, deps);
+}
+
 /** Build the intent handler for one render from its dependency bag. */
 export function createIntentDispatch(deps: IntentDispatchDeps): (intent: Intent) => void {
-  return (intent: Intent): void => {
-    const handler = intentHandlers[intent.type] as (
-      intent: Intent,
-      deps: IntentDispatchDeps,
-    ) => void;
-
-    handler(intent, deps);
-  };
+  return (intent: Intent): void => dispatchIntent(intent, deps);
 }